向量旋转算法（Java实现）

 

          向量旋转问题：给定一个 n维向量， 求 将它向左循环移动i位后的向量。比如：[1,2,3,4,5]向左循环移动3位后，变成[4,5,1,2,3]。为了简单起见，向量采用数组表示。

 

           本文讨论的内容参见《编程珠玑I》(第二版)的第二章。在那里，讨论了向量旋转的四种算法：

 

           1.基于数组移动的思路： 这个是比较简单的，即将要移动的i个元素复制到一个临时数组中，然后，将原数组的n-i个元素依次复制到前n-i个位置上，最后，将临时数组中的i个元素移动到原数组的末尾i个位置上。该思路实现简单，运行时间效率为O(n),空间效率是O(i)；当i较大时，会有较大的空间消耗。

 

           图示：[1,2,3,4,5] --->[4,5,3,4,5] ---> [4,5,1,2,3]

                                      |--->临时数组：[1,2,3]-------- >|⇑

 

           2.基于跳跃交换元素的思路：

       实际上，也是比较直观的。例如，[1,2,3,4,5]，I= 3.直观的想法， 4肯定要到1的位置上； 那么谁到4的位置上呢？这需要将数组想像成一个环形（类似循环队列），在逻辑上通常是取模操作。[1,2,3,4,5,1,2,3,4,5]，显然，2到4的位置。2 = (4+3) % 5.接着，5到2的位置；(5+3) % 5 = 3 到5的位置；(3+3)% 5 = 1到3的位置。这样形成了一个跳跃链：[1<4<2<5<3<1]

      即：arr[1] = arr[4]; arr[4] = arr[2]; arr[2] = arr[5]; arr[5] = arr[3]; arr[3] = arr[1].这样跳跃交换后，得到最终结果： [4,5,1,2,3]

 

          当n与I具有大于1的最大公约数时，情形略有所不同。例如，[1,2,3,4,5,6], I = 4.需要分两轮(轮数是n与i的最大公约数):

          S1:arr[1] = arr[5] , arr[5] = arr[3], arr[3] = arr[1] ,

          S2:arr[2] = arr[6], arr[6] = arr[4], arr[4] = arr[2].

      至此，也得到最终结果：[5,6,1,2,3,4]

 

 

           后面两种思路基于同一个观察结果：向量旋转实际上就是将 AB转换为BA的过程。

 

           3. 基于数组区域交换的思路：AB---> BA

           (1)若A与B长度相等，则将数组区域A和B交换即可；

           (2)若A的长度小于B，则将B分成两部分BlBr其中Br的长度与A相等。则AB= ABlBr. 交换数组区域A与Br,得到BrBlA，此时，A已经在最终位置。问题转换为：将向量BrBl左移 length(Br)位；即原问题的更小规模形式，可递归求解；

           (3)若A的长度大于B，则将A分成两部分AlAr，其中，Al的长度与B相等。则AB= AlArB. 交换数组区域 Al与B，得到BArAl，此时，B已经在最终位置上，问题转换为：将向量ArAl左移 length(Ar)位；即原问题的更小规模形式，可递归求解。

 

           图示：[1 2 3 4 5 6 7 89 10] ,  n=10, I = 3 ; 

           S1: A=[1,2,3] , B=[4,5,6,7,8,9,10] ; A < B.

           根据(2)---> [1 2 3 | 4 5 6 7 | 8 9 10] --->  [89 10 | 4 5 6 7 | 1 2 3]

       n = 7, I = 3; [1 2 3]已在最终位置；

           第一趟结果：[89 10 4 5 6 7 * 1 2 3] ; n = 7; I =3

 

            S2:A = [8,9,10] , B= [4,5,6,7] ; A < B

            根据(2)---> [8 9 10 | 4 | 5 6 7] ---> [5 6 7 | 4 | 8 9 10]

             n= 4, I = 3; [8,9,10] 已在最终位置；

            第二趟结果：[56 7 4 * 8 9 10 1 2 3] ; n = 4, I = 3

 

            S3:A=[5,6,7] , B = [4] ; A > B

            根据(3)---> [5 | 6,7 | 4] ---> [4 | 6,7 | 5]

       n = 3, i = 2 ; [4]已在最终位置。

           第三趟结果：[4 *67 5 * 8 9 10 1 2 3] ; n = 3, I = 2

 

             S4:A=[6,7] , B= [5] ; A > B

            根据(3)---> [6 | 7 | 5] ---> [5 | 7 | 6]

        n = 2, I = 1; [5]已在最终位置

             第四趟结果：[4 5 *7 6 * 8 9 10 1 2 3] ; n = 2, I = 1

 

             S5:A= [7] , B= [6] ; A=B

             根据(1)---> [6,7]算法结束。至此所有元素都在其位置上。

             第五趟结果：[4 5 6 78 9 10 1 2 3]

 

 

           4. 基于数组逆置的思路：一个非常优雅而简单的公式：(a^rb^r)^r=ba，类似于对偶律，可用数学归纳法证明。这意味着，只要将a部分逆置，然后将b部分逆置，最后将整个部分逆置，就得到了所期望的结果。算法简单，优雅，并且高效，不易出错；时间效率是O(n)，空间效率是O(1)。这说明，掌握一定的计算机科学知识和方法对于程序设计是非常重要的。

 

            图示：[1,2,3,4,5] --->[3,2,1,4,5] ---> [3,2,1,5,4] ---> [4,5,1,2,3]

 

       Java 实现代码：

 

       /** * VectorRotation @author shuqin1984 2011-04-18 * * 本程序主要实现四种向量旋转算法; * 向量旋转问题： 将给定 n 维向量最左边的 i 位依次移动到向量最右边. * 比如，[1,2,3,4,5] 左移 3 位， 变成 [4,5,1,2,3] * 数据结构与算法描述 * 1. 向量使用数组来表示； * 2. 四种算法如前所述，分别基于"移动数组元素", "跳跃交换元素", "交换数组区域", "数组逆置" 四种思路。 */package algorithm.vector;import java.util.Arrays;public class VectorRotation {private VectorRotation() { }/** * leftShift4: 基于移动数组元素的思路实现向量旋转. */public static int[] leftShift4(int[] arr, int i){int shiftBits = processParameters(arr, i);if (shiftBits == 0) {return arr;}int arrlen = arr.length;int[] temp = new int[shiftBits];for (int k=0; k < shiftBits; k++) {temp[k] = arr[k];}for (int k=shiftBits; k < arrlen; k++) {arr[k-shiftBits] = arr[k];}for (int k = 0; k < shiftBits; k++) {arr[k + arrlen-shiftBits] = temp[k];}return arr;}/** * leftShift3 : 基于跳跃交换元素求解向量旋转问题 */public static int[] leftShift3(int[] arr, int i){int shiftBits = processParameters(arr, i);if (shiftBits == 0) {return arr;}int arrlen = arr.length;for (int k=0; k < gcd(arr.length, shiftBits); k++) { int temp = arr[k];int foreIndex = k;int afterIndex = k + shiftBits;while (afterIndex != k) {arr[foreIndex] = arr[afterIndex];foreIndex = (foreIndex + shiftBits) % arrlen; afterIndex = (afterIndex + shiftBits) % arrlen;}arr[foreIndex] = temp;}return arr;}/* * gcd: 求给定两数的最大公约数 */private static int gcd(int m, int n){if (m < 0 || n < 0) {throw new IllegalArgumentException("参数错误，必须均是正整数!");}if (m % n == 0) {return n;} return gcd(n, m%n);}/** * leftShift2 : 基于交换数组区域求解向量旋转问题 */public static int[] leftShift2(int[] arr, int i) {int shiftBits = processParameters(arr, i);if (shiftBits == 0) {return arr;}int beginIndex = 0;int endIndex = arr.length-1;int varlength = endIndex - beginIndex + 1;while (true) {if (varlength == 2 * shiftBits) { // AB -> BA ; 所要左移的位数正好是数组长度的一半，只要将数组左右等长区域交换即可exchange(arr, beginIndex, beginIndex + shiftBits, shiftBits);break;} else if (varlength > 2 * shiftBits) { // ABlBr -> BrBlA ; 所要左移的位数小于数组长度的一半，将右边区域分成两份，并将其右半部分与左边区域交换exchange(arr, beginIndex, varlength-shiftBits, shiftBits);endIndex -= shiftBits;} else if (varlength < 2 * shiftBits) { // AlArB -> BArAl ; 所要左移的位数大于数组长度的一半，将左边区域分成两份，并将其左半部分与右边区域交换exchange(arr, beginIndex, beginIndex + shiftBits, varlength - shiftBits);beginIndex += varlength - shiftBits;shiftBits = 2 * shiftBits - varlength;}varlength = endIndex - beginIndex + 1;}return arr;}/* * exchange: 将指定的数组区域内容互换，具体来说， * arr[beginIndex1:beginIndex1+length-1] 与 arr[beginIndex2, beginIndex2+length-1] 的内容依次互换，即 * arr[beginIndex1] 与 arr[beginIndex2] 互换， ... arr[beginIndex1+length-1] 与 arr[beginIndex2+length-1] 互换. * 前置条件： 指定数组区域不能超过数组范围，且区域互不重叠 * */private static void exchange(int[] arr, int beginIndex1, int beginIndex2, int length){checkParametersForExchange(arr, beginIndex1, beginIndex2, length);for (int k=0; k < length; k++) {int temp = arr[k+beginIndex1];arr[k+beginIndex1] = arr[k+beginIndex2];arr[k+beginIndex2] = temp;}}private static void checkParametersForExchange(int[] arr, int beginIndex1, int beginIndex2, int length){if (beginIndex1 + length-1 >= arr.length || beginIndex2 + length-1 >= arr.length) {throw new IllegalArgumentException("参数错误，指定数组区域超过数组范围!");}if (Math.abs(beginIndex1 - beginIndex2) + 1 <= length) throw new IllegalArgumentException("参数错误，指定数组区域不能重叠!");}/** * leftShift: 基于数组逆置法求解向量旋转问题 */public static int[] leftShift(int[] arr, int i){int shiftBits = processParameters(arr, i);if (shiftBits == 0) {return arr;}reverse(arr, 0, shiftBits-1);reverse(arr, shiftBits, arr.length-1);reverse(arr, 0, arr.length-1);return arr;}/** * reverse: 将数组的指定区域逆置 * @param beginIndex 指定区域的起始下标 * @param endIndex 指定区域的终止下标(包含) */public static void reverse(int[] arr, int beginIndex, int endIndex){checkParameterForReverse(arr, beginIndex, endIndex);int length = endIndex - beginIndex + 1; for (int k=beginIndex; k < beginIndex + (length+1)/2; k++) { int temp = arr[k]; arr[k] = arr[beginIndex + endIndex -k]; arr[beginIndex + endIndex -k] = temp; }}private static void checkParameterForReverse(int[] arr, int beginIndex, int endIndex){if (beginIndex < 0 || endIndex < 0 || beginIndex >= arr.length || endIndex >= arr.length) { throw new IllegalArgumentException("指定区域 [" + beginIndex + "," + endIndex + "] 错误, 参数必须均为正整数，且不能超过数组长度 " + arr.length);}if (beginIndex > endIndex) {throw new IllegalArgumentException("指定区域 [" + beginIndex + "," + endIndex + "] 错误，第一个参数必须不大于第二个参数!");}}/* * processParameters: 进行参数处理，若不合法，抛出异常；若合法，返回实际需要移位的位数 */private static int processParameters(int[] arr, int i){if (i < 0) {throw new IllegalArgumentException("参数错误，指定移位位数必须是正整数！");}int shiftBits = i % arr.length;return shiftBits;}static class Tester {public static void testLeftShift(int[] arr, int i) {System.out.println("将向量 " + Arrays.toString(arr) + " 循环左移 " + i + " 位：/t");try {int[] copy = Arrays.copyOf(arr, arr.length);System.out.println(Arrays.toString(leftShift(copy, i)) + " /t*** leftShift ");copy = Arrays.copyOf(arr, arr.length);System.out.println(Arrays.toString(leftShift2(copy, i)) + " /t*** leftShift2 ");copy = Arrays.copyOf(arr, arr.length);System.out.println(Arrays.toString(leftShift3(copy, i)) + " /t*** leftShift3 ");copy = Arrays.copyOf(arr, arr.length);System.out.println(Arrays.toString(leftShift4(copy, i)) + " /t*** leftShift4 ");} catch (Exception e) {System.out.println(e.getMessage());}}public static void testExchange() {int[] arr = new int[] {1,2,3,4,5,6,7,8,9};for (int i = 1; i <= 6; i++) {int[] copy = Arrays.copyOf(arr, arr.length);try { exchange(copy, 2, 5, i); System.out.println("i = " + i + "/t" + Arrays.toString(copy));} catch (Exception e) {System.out.println(e.getMessage());}}}public static void testReverse() {int[] arr = new int[] {1,2,3,4,5,6,7,8,9};for (int i = 0; i < arr.length; i++) {int[] copy = Arrays.copyOf(arr, arr.length);try { reverse(copy, i, arr.length-i); System.out.println("i = " + i + "/t" + Arrays.toString(copy));} catch (Exception e) {System.out.println(e.getMessage());}}}public static void testGCD(){int n = 200, m = 100; while(n>=-10 && m >=-10) { try {System.out.println("[" + n + "," + m + "] 的最大公约数是 ：" + gcd(m, n)); } catch (Exception e) {System.out.println(e.getMessage());}n-= 5; m-=3;}}public static void main(String[] args){System.out.println("************* 最大公约数 **************");testGCD();System.out.println("************* 数组区域内容交换 ****************");testExchange(); System.out.println("************* 数组逆置 ****************");testReverse();System.out.println("************* 向量旋转 ****************");testLeftShift(new int[] {1,2,3,4,5,6,7,8,9,10}, 3);testLeftShift(new int[] {1,2,3,4,5,6,7,8,9,10}, 4);testLeftShift(new int[] {1,2,3,4,5,6,7,8,9,10}, 8);testLeftShift(new int[] {1,2,3,4,5,6,7,8,9,10}, 13);testLeftShift(new int[] {1,2,3,4,5,6,7,8,9,10}, 30);testLeftShift(new int[] {1,2,3,4,5,6,7,8,9,10}, 0);testLeftShift(new int[] {1,2,3,4,5,6,7,8,9,10}, -1); }}}