检查数组是否已排序和旋转

给定一个包含 N 个不同整数的数组。任务是编写一个程序来检查这个数组是否被排序和逆时针旋转。排序后的数组不被认为是排序和旋转的，即应该至少有一个旋转。
例子：

Input : arr[] = { 3, 4, 5, 1, 2 }
Output : YES
The above array is sorted and rotated.
Sorted array: {1, 2, 3, 4, 5}. 
Rotating this sorted array clockwise 
by 3 positions, we get: { 3, 4, 5, 1, 2}

Input: arr[] = {7, 9, 11, 12, 5}
Output: YES

Input: arr[] = {1, 2, 3}
Output: NO

Input: arr[] = {3, 4, 6, 1, 2, 5}
Output: NO

方法：

• 找到数组中的最小元素。
• 现在，如果对数组进行排序，然后旋转最小元素之前的所有元素将按升序排列，并且最小元素之后的所有元素也将按升序排列。
• 检查最小元素之前的所有元素是否按递增顺序排列。
• 检查最小元素之后的所有元素是否按升序排列。
• 检查数组的最后一个元素是否小于起始元素。
• 如果以上三个条件都满足，则打印YES否则打印NO 。

下面是上述思想的实现：

C++

// CPP program to check if an array is
// sorted and rotated clockwise
#include 
#include 
 
using namespace std;
 
// Function to check if an array is
// sorted and rotated clockwise
void checkIfSortRotated(int arr[], int n)
{
    int minEle = INT_MAX;
    int maxEle = INT_MIN;
 
    int minIndex = -1;
 
    // Find the minimum element
    // and it's index
    for (int i = 0; i < n; i++) {
        if (arr[i] < minEle) {
            minEle = arr[i];
            minIndex = i;
        }
    }
 
    int flag1 = 1;
 
    // Check if all elements before minIndex
    // are in increasing order
    for (int i = 1; i < minIndex; i++) {
        if (arr[i] < arr[i - 1]) {
            flag1 = 0;
            break;
        }
    }
 
    int flag2 = 1;
 
    // Check if all elements after minIndex
    // are in increasing order
    for (int i = minIndex + 1; i < n; i++) {
        if (arr[i] < arr[i - 1]) {
            flag2 = 0;
            break;
        }
    }
 
    // Check if last element of the array
    // is smaller than the element just
    // starting element of the array
    // for arrays like [3,4,6,1,2,5] - not circular array
    if (flag1 && flag2 && (arr[n - 1] < arr[0]))
        cout << "YES";
    else
        cout << "NO";
}
 
// Driver code
int main()
{
    int arr[] = { 3, 4, 5, 1, 2 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    checkIfSortRotated(arr, n);
    return 0;
}

Java

// Java program to check if an
// array is sorted and rotated
// clockwise
import java.io.*;
 
class GFG {
 
    // Function to check if an array is
    // sorted and rotated clockwise
    static void checkIfSortRotated(int arr[], int n)
    {
        int minEle = Integer.MAX_VALUE;
        int maxEle = Integer.MIN_VALUE;
 
        int minIndex = -1;
 
        // Find the minimum element
        // and it's index
        for (int i = 0; i < n; i++) {
            if (arr[i] < minEle) {
                minEle = arr[i];
                minIndex = i;
            }
        }
 
        boolean flag1 = true;
 
        // Check if all elements before
        // minIndex are in increasing order
        for (int i = 1; i < minIndex; i++) {
            if (arr[i] < arr[i - 1]) {
                flag1 = false;
                break;
            }
        }
 
        boolean flag2 = true;
 
        // Check if all elements after
        // minIndex are in increasing order
        for (int i = minIndex + 1; i < n; i++) {
            if (arr[i] < arr[i - 1]) {
                flag2 = false;
                break;
            }
        }
 
        // check if the minIndex is 0, i.e the first element
        // is the smallest , which is the case when array is
        // sorted but not rotated.
        if (minIndex == 0) {
            System.out.print("NO");
            return;
        }
        // Check if last element of the array
        // is smaller than the element just
        // before the element at minIndex
        // starting element of the array
        // for arrays like [3,4,6,1,2,5] - not sorted
        // circular array
        if (flag1 && flag2 && (arr[n - 1] < arr[0]))
            System.out.println("YES");
        else
            System.out.print("NO");
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 3, 4, 5, 1, 2 };
 
        int n = arr.length;
 
        // Function Call
        checkIfSortRotated(arr, n);
    }
}
 
// This code is contributed
// by inder_verma.

Python3

# Python3 program to check if an
# array is sorted and rotated clockwise
import sys
 
# Function to check if an array is
# sorted and rotated clockwise
 
 
def checkIfSortRotated(arr, n):
    minEle = sys.maxsize
    maxEle = -sys.maxsize - 1
    minIndex = -1
 
    # Find the minimum element
    # and it's index
    for i in range(n):
        if arr[i] < minEle:
            minEle = arr[i]
            minIndex = i
    flag1 = 1
 
    # Check if all elements before
    # minIndex are in increasing order
    for i in range(1, minIndex):
        if arr[i] < arr[i - 1]:
            flag1 = 0
            break
    flag2 = 2
 
    # Check if all elements after
    # minIndex are in increasing order
    for i in range(minIndex + 1, n):
        if arr[i] < arr[i - 1]:
            flag2 = 0
            break
 
    # Check if last element of the array
    # is smaller than the element just
    # before the element at minIndex
    # starting element of the array
    # for arrays like [3,4,6,1,2,5] - not sorted circular array
    if (flag1 and flag2 and
            arr[n - 1] < arr[0]):
        print("YES")
    else:
        print("NO")
 
 
# Driver code
arr = [3, 4, 5, 1, 2]
n = len(arr)
 
# Function Call
checkIfSortRotated(arr, n)
 
# This code is contributed
# by Shrikant13

C#

// C# program to check if an
// array is sorted and rotated
// clockwise
using System;
 
class GFG {
 
    // Function to check if an array is
    // sorted and rotated clockwise
    static void checkIfSortRotated(int[] arr, int n)
    {
        int minEle = int.MaxValue;
        // int maxEle = int.MinValue;
 
        int minIndex = -1;
 
        // Find the minimum element
        // and it's index
        for (int i = 0; i < n; i++) {
            if (arr[i] < minEle) {
                minEle = arr[i];
                minIndex = i;
            }
        }
 
        bool flag1 = true;
 
        // Check if all elements before
        // minIndex are in increasing order
        for (int i = 1; i < minIndex; i++) {
            if (arr[i] < arr[i - 1]) {
                flag1 = false;
                break;
            }
        }
 
        bool flag2 = true;
 
        // Check if all elements after
        // minIndex are in increasing order
        for (int i = minIndex + 1; i < n; i++) {
            if (arr[i] < arr[i - 1]) {
                flag2 = false;
                break;
            }
        }
 
        // Check if last element of the array
        // is smaller than the element just
        // before the element at minIndex
        // starting element of the array
        // for arrays like [3,4,6,1,2,5] - not circular
        // array
        if (flag1 && flag2 && (arr[n - 1] < arr[0]))
            Console.WriteLine("YES");
        else
            Console.WriteLine("NO");
    }
 
    // Driver code
    public static void Main()
    {
        int[] arr = { 3, 4, 5, 1, 2 };
 
        int n = arr.Length;
         
          // Function Call
        checkIfSortRotated(arr, n);
    }
}
 
// This code is contributed
// by inder_verma.

Javascript

    // Javascript program to check if an
    // array is sorted and rotated
    // clockwise
     
    // Function to check if an array is
    // sorted and rotated clockwise
    function checkIfSortRotated(arr, n)
    {
        let minEle = Number.MAX_VALUE;
        // int maxEle = int.MinValue;
  
        let minIndex = -1;
  
        // Find the minimum element
        // and it's index
        for (let i = 0; i < n; i++) {
            if (arr[i] < minEle) {
                minEle = arr[i];
                minIndex = i;
            }
        }
  
        let flag1 = true;
  
        // Check if all elements before
        // minIndex are in increasing order
        for (let i = 1; i < minIndex; i++) {
            if (arr[i] < arr[i - 1]) {
                flag1 = false;
                break;
            }
        }
  
        let flag2 = true;
  
        // Check if all elements after
        // minIndex are in increasing order
        for (let i = minIndex + 1; i < n; i++) {
            if (arr[i] < arr[i - 1]) {
                flag2 = false;
                break;
            }
        }
  
        // Check if last element of the array
        // is smaller than the element just
        // before the element at minIndex
        // starting element of the array
        // for arrays like [3,4,6,1,2,5] - not circular
        // array
        if (flag1 && flag2 && (arr[n - 1] < arr[0]))
            document.write("YES");
        else
            document.write("NO");
    }
     
    let arr = [ 3, 4, 5, 1, 2 ];
  
    let n = arr.length;
 
    // Function Call
    checkIfSortRotated(arr, n);
 
// This code is contributed by mukesh07.

输出

YES

方法二：

方法：

• 取两个变量 x 和 y，初始化为 0。
• 现在遍历数组。
• 如果我们发现前一个元素小于当前元素，我们将 x 加一。
• 否则，如果我们发现前一个元素大于当前元素，我们将 y 加一。
• 遍历后，如果 x 和 y 中的任何一个不等于 1，则返回 false。
• 如果 x 或 y 中的任何一个为 1，则将最后一个元素与第一个元素（第 0 个元素作为当前元素，最后一个元素作为前一个元素）进行比较。即，如果最后一个元素更大，则将 y 增加 1，否则将 x 增加 1。
• 再次检查 x 和 y，如果任何一个等于 1，则返回 true。即数组被排序和旋转。否则返回假。

解释：

• 这个想法很简单。如果数组被排序和旋转，元素要么增加要么减少，但有一个例外。所以我们计算元素比它的前一个元素大多少倍，以及这个元素比它的前一个元素小多少倍。
• 特殊情况是数组已排序但未旋转。为此特别检查最后一个元素和第一个元素。

下面是上述方法的实现：

C++

#include 
using namespace std;
 
bool checkRotatedAndSorted(int arr[], int n)
{
 
    // Your code here
    // Initializing two variables x,y as zero.
    int x = 0, y = 0;
 
    // Traversing array 0 to last element.
    // n-1 is taken as we used i+1.
    for (int i = 0; i < n - 1; i++) {
        if (arr[i] < arr[i + 1])
            x++;
        else
            y++;
    }
 
    // If till now both x,y are greater then 1 means
    // array is not sorted. If both any of x,y is zero
    // means array is not rotated.
    if (x == 1 || y == 1) {
        // Checking for last element with first.
        if (arr[n - 1] < arr[0])
            x++;
        else
            y++;
 
        // Checking for final result.
        if (x == 1 || y == 1)
            return true;
    }
 
    // If still not true then definitely false.
    return false;
}
 
//  Driver Code Starts.
 
int main()
{
    int arr[] = { 4, 5, 1, 2, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    // Function Call
    if (checkRotatedAndSorted(arr, n))
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
     
  return 0;
}

Java

import java.io.*;
 
class GFG {
 
    // Function to check if an array is
    // Sorted and rotated clockwise
    static boolean checkIfSortRotated(int arr[], int n)
    {
        // Initializing two variables x,y as zero.
        int x = 0, y = 0;
 
        // Traversing array 0 to last element.
        // n-1 is taken as we used i+1.
        for (int i = 0; i < n - 1; i++) {
            if (arr[i] < arr[i + 1])
                x++;
            else
                y++;
        }
 
        // If till now both x,y are greater
        // then 1 means array is not sorted.
        // If both any of x,y is zero means
        // array is not rotated.
        if (x == 1 || y == 1) {
            // Checking for last element with first.
            if (arr[n - 1] < arr[0])
                x++;
            else
                y++;
 
            // Checking for final result.
            if (x == 1 || y == 1)
                return true;
        }
        // If still not true then definitely false.
        return false;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int arr[] = { 5, 1, 2, 3, 4 };
 
        int n = arr.length;
 
        // Function Call
        boolean x = checkIfSortRotated(arr, n);
        if (x == true)
            System.out.println("YES");
        else
            System.out.println("NO");
    }
}

Python3

def checkRotatedAndSorted(arr, n):
 
    # Your code here
    # Initializing two variables x,y as zero.
    x = 0
    y = 0
 
    # Traversing array 0 to last element.
    # n-1 is taken as we used i+1.
    for i in range (n-1):
        if (arr[i] < arr[i + 1]):
            x += 1
        else:
            y += 1
     
 
    # If till now both x,y are greater then 1 means
    # array is not sorted. If both any of x,y is zero
    # means array is not rotated.
    if (x == 1 or y == 1):
        # Checking for last element with first.
        if (arr[n - 1] < arr[0]):
            x += 1
        else:
            y += 1
 
        # Checking for final result.
        if (x == 1 or y == 1):
            return True
     
    # If still not true then definitely false.
    return False
 
# Driver Code Starts.
arr = [ 4, 5, 1, 2, 3 ]
n = len(arr)
 
# Function Call
if (checkRotatedAndSorted(arr, n)):
    print("YES")
else:
    print("NO")
 
# This code is contributed by shivanisinghss2110

C＃

using System;
public class GFG {
 
    // Function to check if an array is
    // Sorted and rotated clockwise
    static bool checkIfSortRotated(int []arr, int n)
    {
        // Initializing two variables x,y as zero.
        int x = 0, y = 0;
 
        // Traversing array 0 to last element.
        // n-1 is taken as we used i+1.
        for (int i = 0; i < n - 1; i++) {
            if (arr[i] < arr[i + 1])
                x++;
            else
                y++;
        }
 
        // If till now both x,y are greater
        // then 1 means array is not sorted.
        // If both any of x,y is zero means
        // array is not rotated.
        if (x == 1 || y == 1) {
            // Checking for last element with first.
            if (arr[n - 1] < arr[0])
                x++;
            else
                y++;
 
            // Checking for readonly result.
            if (x == 1 || y == 1)
                return true;
        }
        // If still not true then definitely false.
        return false;
    }
 
    // Driver code
    public static void Main(String[] args)
    {
        int []arr = { 5, 1, 2, 3, 4 };
 
        int n = arr.Length;
 
        // Function Call
        bool x = checkIfSortRotated(arr, n);
        if (x == true)
            Console.WriteLine("YES");
        else
            Console.WriteLine("NO");
    }
}
 
// This code is contributed by umadevi9616

Javascript

// JavaScript Function to check if an array is
// Sorted and rotated clockwise
function checkIfSortRotated(arr, n)
    {
     
        // Initializing two variables x,y as zero.
        var x = 0, y = 0;
 
        // Traversing array 0 to last element.
        // n-1 is taken as we used i+1.
        for (var i = 0; i < n - 1; i++) {
            if (arr[i] < arr[i + 1])
                x++;
            else
                y++;
        }
 
        // If till now both x,y are greater
        // then 1 means array is not sorted.
        // If both any of x,y is zero means
        // array is not rotated.
        if (x == 1 || y == 1) {
            // Checking for last element with first.
            if (arr[n - 1] < arr[0])
                x++;
            else
                y++;
 
            // Checking for final result.
            if (x == 1 || y == 1)
                return true;
        }
        // If still not true then definitely false.
        return false;
    }
 
    // Driver code
        var arr = [ 5, 1, 2, 3, 4 ];
 
        var n = arr.length;
 
        // Function Call
        var x = checkIfSortRotated(arr, n);
        if (x == true)
            document.write("YES");
        else
            document.write("NO");
 
// This code is contributed by shivanisinghss2110

输出

YES

时间复杂度： O(N)
辅助空间： O(1)