Javascript程序检查是否可以在旋转后对数组进行排序

给定一个大小为 N 的数组，任务是确定是否可以仅通过一次 shuffle 对数组进行排序。在一次 shuffle 中，我们可以将一些连续的元素从数组的末尾移动到数组的前面。
例如：

1. A = {2, 3, 1, 2}, we can shift {1, 2} from the end of the array to the front of the array to sort it.
2. A = {1, 2, 3, 2} since we cannot sort it in one shuffle hence it’s not possible to sort the array.

例子：

Input: arr[] = {1, 2, 3, 4} 
Output: Possible 
Since this array is already sorted hence no need for shuffle.

Input: arr[] = {6, 8, 1, 2, 5}
Output: Possible
Place last three elements at the front 
in the same order i.e. {1, 2, 5, 6, 8}

方法：

1. 检查数组是否已经排序。如果是，则返回 true。
2. 否则开始遍历数组元素，直到当前元素小于下一个元素。将该索引存储在 arr[i] > arr[i+1] 的位置。
3. 从该点遍历并检查该索引中的元素是否按升序排列。
4. 如果满足以上两个条件，则检查最后一个元素是否小于或等于给定数组的第一个元素。
5. 如果满足以上三个条件，则打印“可能”，如果以上三个条件中的任何一个不满足，则打印“不可能”。

以下是上述方法的实现：

Javascript

// Javascript implementation of above approach  
// check if array is sorted 
    function is_sorted(a)
    {
        let c1=0,c2=0;
        // if array is ascending 
        for(let i=0;i<n-1;i++)
        {
            if(a[i]<=a[i+1])
            {
                c1++;
            }
        }
        // if array is descending 
        for(let i=1;i<n;i++) 
        { 
            if(a[i]<=a[i-1]) 
                c2++; 
        } 
        if(c1==n||c2==n)
        {
            return true;
        }
        return false;
    }
    // Function to check if it is possible
    function isPossible(a,n)
    {
        // step 1
        if (is_sorted(a,n))
        {
            document.write("Possible");    
        }
        else
        {
            // break where a[i] > a[i+1] 
            let flag = true;
            let i;
            for (i = 0; i < n - 1; i++)
            {
                if (a[i] > a[i + 1])
                {
                    break;
                }
            }
            // break point + 1  
            i++;
            // check whether the sequence is  
            // further increasing or not  
            for (let k = i; k < n - 1; k++)
            {
                if (a[k] > a[k + 1])
                {
                    flag = false;  
                    break;
                }
            }
            // If not increasing after break point  
            if (!flag)  
            {
                return false; 
            }
            else
            {
                // last element <= First element  
                if (a[n - 1] <= a[0])  
                    return true;  
      
                else
                    return false;  
            }
        }
              
        return false; 
    }
    // Driver code  
    let arr=[3, 1, 2, 2, 3];
    let n = arr.length;
    if(isPossible(arr, n))
        document.write("Possible");
    else
        document.write("Not Possible");
          
    // This code is contributed by avanitrachhadiya2155

输出：

Possible

请参阅完整的文章检查是否可以在旋转后对数组进行排序以获取更多详细信息！