摘要：Java实现基于数组的向量旋转的四种算法。包括：基于数组移动的思路；基于跳跃交换元素的思路； 基于数组区域交换的思路：AB---> BA；基于数组逆置的思路。
难度： 初级。
向量旋转问题：给定一个 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. 基于数组逆置的思路
一个非常优雅而简单的公式：(arbr)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);
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
