爪哇2博客
爪哇2博客

将数组旋转K个位置

在本教程中,我们将看到如何将数组旋转到K个位置。

问题:

N = 6和k = 2
如果Arr [] = {1,2,3,4,5,6}并且k = 2
则旋转数组将为{5,6,1,2,3,4}

解:

有多种方法可以解决此问题。

方法1:

将每个数字移动1位,然后进行k次。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
上市 静态的 整型[] rotateBruteForce(整型[] nums, 整型 k) {
对于 (整型 i = 0; i < k; i++) {
对于 (整型 j = nums.长度 - 1; j > 0; j-) {
//将每个数字移动1位
整型 温度 = nums[j];
nums[j] = nums[j - 1];
nums[j - 1] = 温度;
}
系统..打印(“阵列旋转后”+(i+1)+“ 步”);
打印Array(nums);
系统..打印();
}
返回 nums;
}
 

时间复杂度:o(n * k)
其中n是元素数,k表示位置偏移。
空间复杂度:o(1)

方法二:

您可以使用o(n)中的临时数组旋转数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
上市 静态的 整型[] 回转ExtraSpace(整型[] nums, 整型 k)
    {
        整型 n=nums.长度;
        如果(k > n)
            k=k%n;
 
        整型[] 结果 = 整型[n];
 
        对于(整型 i=0; i < k; i++){
            结果[i] = nums[n-k+i];
        }
 
        整型 指数=0;
        对于(整型 i=k; i<n; i++){
            结果[i] = nums[指数++];
        }
        返回 结果;
    }
 

时间复杂度:o(n)
空间复杂度:o(n)

方法3:

这是最优化的方法。
此方法的算法如下:

  • 反转整个数组。
  • 反转前k个元素
  • 反向休息n-k个元素。
例如:
让’s说Array是{1,2,3,4,5,6,7,8}
您想旋转k位置。
它将按以下方式工作:
  • 旋转整个阵列。因此数组变成:{8,7,6,5,4,3,2,1}
  • 反转前k个元素,因此数组变为:{7,8,6,5,4,3,2,1}
  • 反转其余元素,因此数组变成了:{7,8,1,2,3,4,5,6}
爪哇代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
上市 静态的 整型[] 旋转优化(整型[] nums,整型 k)
    {
        整型 n=nums.长度;
        如果(k > n)
            k=k%n;
        nums=逆转(nums,0,n-1);
        nums=逆转(nums,0,k-1);
        nums=逆转(nums,k,n-1);
        返回 nums;
    }
    上市 静态的 整型[] 逆转(整型[] nums,整型 开始,整型 结束)
    {
 
         (开始 <= 结束 ) {
            整型 温度=nums[开始];
            nums[开始]=nums[结束];
            nums[结束]=温度;
            开始++;
            结束-;
        }
        返回 nums;
    }
 

时间复杂度:o(n)
空间复杂度:o(1)

完整的Java程序以K个位置旋转数组:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
组织.Arpit.爪哇2blog;
 
上市 旋转ArrayMain {
 
    上市 静态的 虚空 主要([] args)
    {
        整型 nums[]={1,2,3,4,5,6,7,8};
 
        系统..打印(“通过将一个元素移位1并旋转k次来旋转数组”);
        整型[] 结果1=rotateBruteForce(nums,2);
        系统..打印(“最终旋转数组:”);
        打印Array(结果1);
        系统..打印();
        系统..打印(“ ===============================”);
        系统..打印(“使用额外的空间旋转数组”);
 
        整型 nums2[]={10,20,30,40,50,60};
        整型[] 结果2=回转ExtraSpace(nums2,5);
        打印Array(结果2);
        系统..打印();
        系统..打印(“ ===============================”);
        系统..打印(“旋转阵列最优化的方法”);
        整型 nums3[]={1,2,3,4,5,6,7,8,9,10};
        整型[] 结果3=旋转优化(nums3,4);
        打印Array(结果3);
    }
 
    上市 静态的 整型[] rotateBruteForce(整型[] nums, 整型 k) {
        整型 n=nums.长度;
        如果(k > n)
            k=k%n;
        对于 (整型 i = 0; i < k; i++) {
            对于 (整型 j = n - 1; j > 0; j-) {
                //将每个数字移动1位
                整型 温度 = nums[j];
                nums[j] = nums[j - 1];
                nums[j - 1] = 温度;
            }
        系统..打印(“阵列旋转后”+(i+1)+“ 步”);
            打印Array(nums);
            系统..打印();
        }
        返回 nums;
    }
 
    上市 静态的 整型[] 回转ExtraSpace(整型[] nums, 整型 k)
    {
        整型 n=nums.长度;
        如果(k > n)
            k=k%n;
 
        整型[] 结果 = 整型[n];
 
        对于(整型 i=0; i < k; i++){
            结果[i] = nums[n-k+i];
        }
 
        整型 指数=0;
        对于(整型 i=k; i<n; i++){
            结果[i] = nums[指数++];
        }
        返回 结果;
    }
 
    上市 静态的 整型[] 旋转优化(整型[] nums,整型 k)
    {
        整型 n=nums.长度;
        如果(k > n)
            k=k%n;
        nums=逆转(nums,0,n-1);
        nums=逆转(nums,0,k-1);
        nums=逆转(nums,k,n-1);
        返回 nums;
    }
    上市 静态的 整型[] 逆转(整型[] nums,整型 开始,整型 结束)
    {
 
         (开始 <= 结束 ) {
            整型 温度=nums[开始];
            nums[开始]=nums[结束];
            nums[结束]=温度;
            开始++;
            结束-;
        }
        返回 nums;
    }
 
    上市 静态的 虚空 打印Array(整型 []rr)
    {
        对于 (整型 i = 0; i < rr.长度; i++) {
            系统..打印(rr[i]+);
        }
    }
}
 

当您运行上述程序时,将获得以下输出:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
旋转 数组 通过 转移 元素 通过 1 k
数组 回转 1
8 1 2 3 4 5 6 7
数组 回转 2
7 8 1 2 3 4 5 6
最后 旋转的 数组 :
7 8 1 2 3 4 5 6
================================
旋转 数组 使用 额外 空间
20 30 40 50 60 10
================================
旋转 数组 优化 方法
7 8 9 10 1 2 3 4 5 6
 


导入联系人

您可能还喜欢:

分享这个

作者

关注作者

相关文章

  • 3月28日

    对0、1和2的数组进行排序

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何对0、1和2s的数组进行排序。我们已经看到了有关对数组中的0s和1s进行排序的文章。问题给定一个包含零的数组,[…]

  • 3月04

    通过跳转检查是否有可能到达给定数组的末尾

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。问题给定一个具有正整数作为元素的数组,该数组指示可以从数组中任何位置进行跳转的最大长度。检查是否可以[…]

  • 2月17日

    检查数组元素是否连续

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何检查数组元素是否连续。问题给定一个数组,我们需要检查数组是否包含连续的元素。例如:输入:array [] = {5,3,4,[…]

  • 11月1日

    在数组中找到局部最小值

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何在数组中找到局部最小值。问题如果一个元素小于其相邻元素,则它是局部最小值。 整型 [] rr = {10,5,3,[…]

  • 10月22日

    爪哇中的滑动窗口最大值

    在这篇文章中,我们将看到有关Java问题中滑动窗口最大值的问题给定一个整数数组和一个整数k,请从所有大小为K的连续子数组中找到max的元素。例如:Input:int [] rr = {2 ,6,-1,2,4,1,-6,5} 整型 k = 3输出:[[]的每个子数组分别为6,6,4,4,4,5,5…]

  • 10月20日

    计算排序数组中每个元素的出现次数(或频率)

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何计算已排序数组中每个元素的出现次数(或出现频率)问题给定一个包含重复项的整数排序数组。找出每个[…]

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


成为朋友

©2020 爪哇2博客