📌  相关文章
📜  通过在每次操作中删除给定数组的一半,将数组减少为最长排序的数组

📅  最后修改于: 2021-05-14 01:31:49             🧑  作者: Mango

给定大小为N (始终为2的幂)的数组arr [] ,任务是找到最长排序的数组的长度,可以通过在每次操作中删除数组的一半来减少给定数组的长度。

例子:

方法:请按照以下步骤解决问题:

  • 初始化一个变量,例如MaxLength ,以存储可以通过执行给定操作获得的排序数组的最大长度。
  • 将数组递归地分成两个相等的一半,并针对每一半检查数组的分区是否已排序。如果发现为真,则将MaxLength更新为分区的长度。
  • 最后,输出MaxLength的值。

下面是上述方法的实现:

C++
// C++ program to implement
// the above approach
 
#include 
using namespace std;
 
// Function to check if the subarray
// arr[i..j] is a sorted subarray or not
int isSortedparitions(int arr[],
                      int i, int j)
{
    // Traverse all elements of
    // the subarray arr[i...j]
    for (int k = i + 1; k <= j; k++) {
 
        // If the previous element of the
        // subarray exceeds current element
        if (arr[k] < arr[k - 1]) {
 
            // Return 0
            return 0;
        }
    }
 
    // Return 1
    return 1;
}
 
// Recursively partition the array
// into two equal halves
int partitionsArr(int arr[],
                  int i, int j)
{
    // If atmost one element is left
    // in the subarray arr[i..j]
    if (i >= j)
        return 1;
 
    // Checks if subarray arr[i..j] is
    // a sorted subarray or not
    bool flag = isSortedparitions(
        arr, i, j);
 
    // If the subarray arr[i...j]
    // is a sorted subarray
    if (flag) {
        return (j - i + 1);
    }
 
    // Stores middle element
    // of the subarray arr[i..j]
    int mid = (i + j) / 2;
 
    // Recursively partition the current
    // subarray arr[i..j] into equal halves
    int X = partitionsArr(arr, i, mid);
    int Y = partitionsArr(arr, mid + 1, j);
 
    return max(X, Y);
}
 
// Driver Code
int main()
{
 
    int arr[] = { 11, 12, 1, 2,
                  13, 14, 3, 4 };
    int N = sizeof(arr) / sizeof(arr[0]);
    cout << partitionsArr(
        arr, 0, N - 1);
 
    return 0;
}


Java
// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
  
// Function to check if the subarray
// arr[i..j] is a sorted subarray or not
static int isSortedparitions(int arr[],
                             int i, int j)
{
     
    // Traverse all elements of
    // the subarray arr[i...j]
    for(int k = i + 1; k <= j; k++)
    {
         
        // If the previous element of the
        // subarray exceeds current element
        if (arr[k] < arr[k - 1])
        {
             
            // Return 0
            return 0;
        }
    }
  
    // Return 1
    return 1;
}
  
// Recursively partition the array
// into two equal halves
static int partitionsArr(int arr[], int i,
                         int j)
{
     
    // If atmost one element is left
    // in the subarray arr[i..j]
    if (i >= j)
        return 1;
  
    // Checks if subarray arr[i..j] is
    // a sorted subarray or not
    int flag = (int)isSortedparitions(arr, i, j);
  
    // If the subarray arr[i...j]
    // is a sorted subarray
    if (flag != 0)
    {
        return (j - i + 1);
    }
  
    // Stores middle element
    // of the subarray arr[i..j]
    int mid = (i + j) / 2;
  
    // Recursively partition the current
    // subarray arr[i..j] into equal halves
    int X = partitionsArr(arr, i, mid);
    int Y = partitionsArr(arr, mid + 1, j);
  
    return Math.max(X, Y);
}
  
// Driver Code
public static void main(String[] args)
{
    int arr[] = { 11, 12, 1, 2,
                  13, 14, 3, 4 };
                   
    int N = arr.length;
     
    System.out.print(partitionsArr(
        arr, 0, N - 1));
}
}
 
// This code is contributed by susmitakundugoaldanga


Python3
# Python3 program to implement
# the above approach
 
# Function to check if the subarray
# arr[i..j] is a sorted subarray or not
def isSortedparitions(arr, i, j):
     
    # Traverse all elements of
    # the subarray arr[i...j]
    for k in range(i + 1, j + 1):
         
        # If the previous element of the
        # subarray exceeds current element
        if (arr[k] < arr[k - 1]):
             
            # Return 0
            return 0
             
    # Return 1
    return 1
 
# Recursively partition the array
# into two equal halves
def partitionsArr(arr, i, j):
     
    # If atmost one element is left
    # in the subarray arr[i..j]
    if (i >= j):
        return 1
 
    # Checks if subarray arr[i..j] is
    # a sorted subarray or not
    flag = int(isSortedparitions(arr, i, j))
 
    # If the subarray arr[i...j]
    # is a sorted subarray
    if (flag != 0):
        return (j - i + 1)
 
    # Stores middle element
    # of the subarray arr[i..j]
    mid = (i + j) // 2
 
    # Recursively partition the current
    # subarray arr[i..j] into equal halves
    X = partitionsArr(arr, i, mid);
    Y = partitionsArr(arr, mid + 1, j)
 
    return max(X, Y)
 
# Driver Code
if __name__ == '__main__':
     
    arr = [ 11, 12, 1, 2, 13, 14, 3, 4 ]
    N = len(arr)
 
    print(partitionsArr(arr, 0, N - 1))
 
# This code is contributed by Princi Singh


C#
// C# program to implement
// the above approach 
using System;
  
class GFG{
   
// Function to check if the subarray
// arr[i..j] is a sorted subarray or not
static int isSortedparitions(int[] arr,
                             int i, int j)
{
      
    // Traverse all elements of
    // the subarray arr[i...j]
    for(int k = i + 1; k <= j; k++)
    {
          
        // If the previous element of the
        // subarray exceeds current element
        if (arr[k] < arr[k - 1])
        {
              
            // Return 0
            return 0;
        }
    }
   
    // Return 1
    return 1;
}
   
// Recursively partition the array
// into two equal halves
static int partitionsArr(int[] arr, int i,
                         int j)
{
      
    // If atmost one element is left
    // in the subarray arr[i..j]
    if (i >= j)
        return 1;
   
    // Checks if subarray arr[i..j] is
    // a sorted subarray or not
    int flag = (int)isSortedparitions(arr, i, j);
   
    // If the subarray arr[i...j]
    // is a sorted subarray
    if (flag != 0)
    {
        return (j - i + 1);
    }
   
    // Stores middle element
    // of the subarray arr[i..j]
    int mid = (i + j) / 2;
   
    // Recursively partition the current
    // subarray arr[i..j] into equal halves
    int X = partitionsArr(arr, i, mid);
    int Y = partitionsArr(arr, mid + 1, j);
   
    return Math.Max(X, Y);
}
   
// Driver Code
public static void Main()
{
    int[] arr = { 11, 12, 1, 2,
                  13, 14, 3, 4 };
                    
    int N = arr.Length;
      
    Console.Write(partitionsArr(
        arr, 0, N - 1));
}
}
 
// This code is contributed by code_hunt


输出:
2










时间复杂度: O(N * log(N))
辅助空间: O(1)