按给定大小分组反转数组-yiteyi-C++库

给定一个数组，反转由连续k个元素组成的每个子数组。

null

例如：

输入： arr=[1,2,3,4,5,6,7,8,9] k=3 输出： [3, 2, 1, 6, 5, 4, 9, 8, 7]

输入： arr=[1,2,3,4,5,6,7,8] k=5 输出： [5, 4, 3, 2, 1, 8, 7, 6]

输入： arr=[1,2,3,4,5,6] k=1 输出： [1, 2, 3, 4, 5, 6]

输入： arr=[1,2,3,4,5,6,7,8] k=10 输出： [8, 7, 6, 5, 4, 3, 2, 1]

建议：请在“上解决” 实践 “首先，在讨论解决方案之前。

方法考虑每个子数组的大小 K 从数组的开头开始，并将其反转。我们需要处理一些特殊情况。如果k不是n的倍数，其中n是数组的大小，对于最后一个组，我们将剩下少于k个元素，我们需要反转所有剩余的元素。如果 k=1 ，数组应保持不变。如果k>=n，我们反转数组中的所有元素。

下图是上述方法的试运行：

图片[1]-按给定大小分组反转数组-yiteyi-C++库

以下是上述方法的实施情况：

C++

                         // C++ program to reverse every sub-array formed by                       
                         // consecutive k elements                       
                         #include <iostream>                       
                         using                                     namespace                                     std;                       
           
                         // Function to reverse every sub-array formed by                       
                         // consecutive k elements                       
                         void                                     reverse(                                     int                                     arr[],                                     int                                     n,                                     int                                     k)                       
                         {                       
                                                 for                                     (                                     int                                     i = 0; i < n; i += k)                       
                                                 {                       
                                                 int                                     left = i;                       
           
                                                 // to handle case when k is not multiple of n                       
                                                 int                                     right = min(i + k - 1, n - 1);                       
           
                                                 // reverse the sub-array [left, right]                       
                                                 while                                     (left < right)                       
                                                 swap(arr[left++], arr[right--]);                       
           
                                                 }                       
                         }                       
           
                         // Driver code                       
                         int                                     main()                       
                         {                       
                                                 int                                     arr[] = {1, 2, 3, 4, 5, 6, 7, 8};                       
                                                 int                                     k = 3;                       
           
                                                 int                                     n =                                     sizeof                                     (arr) /                                     sizeof                                     (arr[0]);                       
           
                                                 reverse(arr, n, k);                       
           
                                                 for                                     (                                     int                                     i = 0; i < n; i++)                       
                                                 cout << arr[i] <<                                     " "                                     ;                       
           
                                                 return                                     0;                       
                         }                       

JAVA

                         // Java program to reverse every sub-array formed by                       
                         // consecutive k elements                       
                         class                                     GFG {                       
                                   
                                                 // Function to reverse every sub-array formed by                       
                                                 // consecutive k elements                       
                                                 static                                     void                                     reverse(                                     int                                     arr[],                                     int                                     n,                                     int                                     k)                       
                                                 {                       
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < n; i += k)                       
                                                 {                       
                                                 int                                     left = i;                       
                                   
                                                 // to handle case when k is not multiple                       
                                                 // of n                       
                                                 int                                     right = Math.min(i + k -                                     1                                     , n -                                     1                                     );                       
                                                 int                                     temp;                       
                                   
                                                 // reverse the sub-array [left, right]                       
                                                 while                                     (left < right)                       
                                                 {                       
                                                 temp=arr[left];                       
                                                 arr[left]=arr[right];                       
                                                 arr[right]=temp;                       
                                                 left+=                                     1                                     ;                       
                                                 right-=                                     1                                     ;                       
                                                 }                       
                                                 }                       
                                                 }                       
                                   
                                                 // Driver method                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                   
                                                 int                                     arr[] = {                                     1                                     ,                                     2                                     ,                                     3                                     ,                                     4                                     ,                                     5                                     ,                                     6                                     ,                                     7                                     ,                                     8                                     };                       
                                                 int                                     k =                                     3                                     ;                       
                                   
                                                 int                                     n = arr.length;                       
                                   
                                                 reverse(arr, n, k);                       
                                   
                                                 for                                     (                                     int                                     i =                                     0                                     ; i < n; i++)                       
                                                 System.out.print(arr[i] +                                     " "                                     );                       
                                                 }                       
                         }                       
           
                         // This code is contributed by Anant Agarwal.                       

Python3

                         # Python 3 program to reverse every                       
                         # sub-array formed by consecutive k                       
                         # elements                       
           
                         # Function to reverse every sub-array                       
                         # formed by consecutive k elements                       
                         def                                     reverse(arr, n, k):                       
                                                 i                                     =                                     0                       
                                   
                                                 while                                     (i<n):                       
                                   
                                                 left                                     =                                     i                       
           
                                                 # To handle case when k is not                       
                                                 # multiple of n                       
                                                 right                                     =                                     min                                     (i                                     +                                     k                                     -                                     1                                     , n                                     -                                     1                                     )                       
           
                                                 # Reverse the sub-array [left, right]                       
                                                 while                                     (left < right):                       
                                   
                                                 arr[left], arr[right]                                     =                                     arr[right], arr[left]                       
                                                 left                                     +                                     =                                     1                                     ;                       
                                                 right                                     -                                     =                                     1                       
                                                 i                                     +                                     =                                     k                       
                                   
                         # Driver code                       
                         arr                                     =                                     [                                     1                                     ,                                     2                                     ,                                     3                                     ,                                     4                                     ,                                     5                                     ,                                     6                                     ,                       
                                                 7                                     ,                                     8                                     ]                       
           
                         k                                     =                                     3                       
                         n                                     =                                     len                                     (arr)                       
                         reverse(arr, n, k)                       
           
                         for                                     i                                     in                                     range                                     (                                     0                                     , n):                       
                                                 print                                     (arr[i], end                                     =                                     " "                                     )                       
                                   
                         # This code is contributed by Smitha Dinesh Semwal                       

C#

                         // C# program to reverse every sub-array                       
                         // formed by consecutive k elements                       
                         using                                     System;                       
           
                         class                                     GFG                       
                         {                       
           
                         // Function to reverse every sub-array                       
                         // formed by consecutive k elements                       
                         public                                     static                                     void                                     reverse(                                     int                                     [] arr,                       
                                                 int                                     n,                                     int                                     k)                       
                         {                       
                                                 for                                     (                                     int                                     i = 0; i < n; i += k)                       
                                                 {                       
                                                 int                                     left = i;                       
           
                                                 // to handle case when k is                       
                                                 // not multiple of n                       
                                                 int                                     right = Math.Min(i + k - 1, n - 1);                       
                                                 int                                     temp;                       
           
                                                 // reverse the sub-array [left, right]                       
                                                 while                                     (left < right)                       
                                                 {                       
                                                 temp = arr[left];                       
                                                 arr[left] = arr[right];                       
                                                 arr[right] = temp;                       
                                                 left += 1;                       
                                                 right -= 1;                       
                                                 }                       
                                                 }                       
                         }                       
           
                         // Driver Code                       
                         public                                     static                                     void                                     Main(                                     string                                     [] args)                       
                         {                       
                                                 int                                     [] arr =                                     new                                     int                                     [] {1, 2, 3, 4,                       
                                                 5, 6, 7, 8};                       
                                                 int                                     k = 3;                       
           
                                                 int                                     n = arr.Length;                       
           
                                                 reverse(arr, n, k);                       
           
                                                 for                                     (                                     int                                     i = 0; i < n; i++)                       
                                                 {                       
                                                 Console.Write(arr[i] +                                     " "                                     );                       
                                                 }                       
                         }                       
                         }                       
           
                         // This code is contributed                       
                         // by Shrikant13                       

PHP

                         <?php                       
                         // PHP program to reverse every sub-array                       
                         // formed by consecutive k elements                       
                                   
                         // Function to reverse every sub-array                       
                         // formed by consecutive k elements                       
                         function                                     reverse(                                     $arr                                     ,                                     $n                                     ,                                     $k                                     )                       
                         {                       
                                                 for                                     (                                     $i                                     = 0;                                     $i                                     <                                     $n                                     ;                                     $i                                     +=                                     $k                                     )                       
                                                 {                       
                                                 $left                                     =                                     $i                                     ;                       
           
                                                 // to handle case when k is not                       
                                                 // multiple of n                       
                                                 $right                                     = min(                                     $i                                     +                                     $k                                     - 1,                                     $n                                     - 1);                       
                                                 $temp                                     ;                       
                                   
                                                 // reverse the sub-array [left, right]                       
                                                 while                                     (                                     $left                                     <                                     $right                                     )                       
                                                 {                       
                                                 $temp                                     =                                     $arr                                     [                                     $left                                     ];                       
                                                 $arr                                     [                                     $left                                     ] =                                     $arr                                     [                                     $right                                     ];                       
                                                 $arr                                     [                                     $right                                     ] =                                     $temp                                     ;                       
                                                 $left                                     += 1;                       
                                                 $right                                     -= 1;                       
                                                 }                       
                                                 }                       
                                                 return                                     $arr                                     ;                       
                         }                       
           
                         // Driver Code                       
                         $arr                                     =                                     array                                     (1, 2, 3, 4, 5, 6, 7, 8);                       
                         $k                                     = 3;                       
           
                         $n                                     = sizeof(                                     $arr                                     );                       
           
                         $arr1                                     = reverse(                                     $arr                                     ,                                     $n                                     ,                                     $k                                     );                       
           
                         for                                     (                                     $i                                     = 0;                                     $i                                     <                                     $n                                     ;                                     $i                                     ++)                       
                                                 echo                                     $arr1                                     [                                     $i                                     ] .                                     " "                                     ;                       
           
                         // This code is contributed                       
                         // by Akanksha Rai                       
                         ?>                       

Javascript

                         <script>                       
           
                         // Javascript program to reverse every sub-array                       
                         // formed by consecutive k elements                       
                                   
                         // Function to reverse every sub-array                       
                         // formed by consecutive k elements                       
                         function                                     reverse(arr, n, k)                       
                         {                       
                                                 for                                     (let i = 0; i < n; i += k)                       
                                                 {                       
                                                 let left = i;                       
           
                                                 // To handle case when k is not                       
                                                 // multiple of n                       
                                                 let right = Math.min(i + k - 1, n - 1);                       
                                                 let temp;                       
                                   
                                                 // Reverse the sub-array [left, right]                       
                                                 while                                     (left < right)                       
                                                 {                       
                                                 temp = arr[left];                       
                                                 arr[left] = arr[right];                       
                                                 arr[right] = temp;                       
                                                 left += 1;                       
                                                 right -= 1;                       
                                                 }                       
                                                 }                       
                                                 return                                     arr;                       
                         }                       
           
                         // Driver Code                       
                         let arr =                                     new                                     Array(1, 2, 3, 4, 5, 6, 7, 8);                       
                         let k = 3;                       
                         let n = arr.length;                       
                         let arr1 = reverse(arr, n, k);                       
           
                         for                                     (let i = 0; i < n; i++)                       
                                                 document.write(arr1[i] +                                     " "                                     );                       
           
                         // This code is contributed by saurabh jaiswal                       
           
                         </script>                       

输出：

3 2 1 6 5 4 8 7

时间复杂性 上述溶液的浓度为O（n）。 辅助空间 程序使用的是O（1）。

本文由 阿迪蒂亚·戈尔 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章