数组常见算法代码总结

一、数组排序

1.快速排序法

思路：使用sort()方法进行快速排序

代码实现：

	int[] numbers = {11,9,3,14,12,16,15,19};
	//快速排序
	Arrays.sort(numbers);
	System.out.println(Arrays.toString(numbers));
    //输出：[3, 9, 11, 12, 14, 15, 16, 19]

2.冒泡排序法（优化前）

思路：从第一个元素开始，依次比较相邻的两个元素，如果顺序不对则进行交换，继续比较相邻元素，直到最后一个元素，这样一轮下来，最大的元素就会被交换到最后的位置。重复以上步骤，每次比较的元素减少1，直到整个数组有序。

代码实现：

public static void main(String[] args) {
		//冒泡排序法
		int[] numbers = {2,20,3,1,11,9,6};
		
		System.out.println(Arrays.toString(numbers));
		/*
		 * N个数字来排序，
		 * 俩俩比较小(大)靠前，
		 * 总共比较N-1轮每轮，
		 * 比较N-1-i次
		 */
		
		//比较n-1轮
		for(int i = 0;i<numbers.length-1;i++) {
			//每轮比较n-1-i
			for(int k = 0;k<numbers.length-1-i;k++) {
				//相邻比较
				if(numbers[k]>numbers[k+1]) {
					numbers[k] = numbers[k]^numbers[k+1];
					numbers[k+1] = numbers[k]^numbers[k+1];
					numbers[k] = numbers[k]^numbers[k+1];
				}
				
			}
			
		}
		System.out.println(Arrays.toString(numbers));
	}

3.冒泡排序法（优化后）

思路：如果在一轮比较中没有进行排序，那么就说明数组已经有序，可以提前结束排序，这样可以减少排序的次数，提高排序效率。

代码实现：

	public static void main(String[] args) {
		// 冒泡排序法
		int[] numbers = { 2, 20, 3, 1, 11, 9, 6 };
		System.out.println(Arrays.toString(numbers));
		/*
		 * N个数字来排序， 俩俩比较小(大)靠前， 总共比较N-1轮每轮， 比较N-1-i次
		 */
		int counter = 0;
		// 比较n-1轮
		for (int i = 0; i < numbers.length - 1; i++) {
			// 是否已经处于"有序"状态
			// true代表有序
			// false代表无序
			boolean isSorted = true;
			// 每轮比较n-1-i
			for (int k = 0; k < numbers.length - 1 - i; k++) {
				counter++;
				// 相邻比较
				if (numbers[k] < numbers[k + 1]) {
					//交换
					numbers[k] = numbers[k] ^ numbers[k + 1];
					numbers[k + 1] = numbers[k] ^ numbers[k + 1];
					numbers[k] = numbers[k] ^ numbers[k + 1];
					isSorted = false;
				}
			}
			if(isSorted) {
				break;
			}
		}
		System.out.println("总共比较了"+counter+"次");
		System.out.println(Arrays.toString(numbers));
	}

二、无序数组查找

思路：从数组的第一个元素开始(或者从最后一个元素开始向前遍历，也可以双指针查找)，逐个比较每个元素与目标元素是否相等。如果找到目标元素，返回该元素的下标值，如果遍历完数组都没有找到该元素，则返回-1。

代码实现：

public static void main(String[] args) {
		//双指针查找
		String[] singerArray = { "李荣浩", "王菲", "王源" ,"张杰"};		
		

			String target = "王菲";
			int index = -1;//目标元素下标，默认为-1，代表不存在
			for(int i = 0,k=singerArray.length-1;i<=k;i++,k--) {
				//从头开始比较
				if(singerArray[i].equals(target)) {
					index = i;
					break;
				}
				//从尾开始比较
				if(singerArray[k].equals(target)) {
					index = k;
					break;
				}		
			}
			System.out.println(index);

		
	}

三、有序数组查找（二分）

前提：数组必须有序!

思路：首先，在查找目标元素时，先定义一个开始下标low和一个结束下标high,开始下标low为0，结束下标high为数组的长度-1；然后，当开始下标low小于等于结束下标high时，计算中间元素的下标mid，如果中间元素=目标元素，则查找成功，退出；如果目标元素大于中间元素，那么当前数组的后半部分就作为搜索的新数组，开始下表low变为中间元素下标+1;如果目标元素小于中间元素，那么当前数组的前半部分就作为搜索的新数组，结束下标high变为中间元素mid下标-1。

代码实现：

		int[] array = {1,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59};
		int target = 37;//目标元素
		int index = -1;//目标元素的下标，默认为-1，代表不存在
		
		// low和high分 别代表搜索数组的开始下标与结束下标
		//默认搜索数组是整个数组
		int low = 0,high = array.length-1;
		
		while(low<=high) {
			//计算“中间元素”的下标
			int mid = (low+high)/2;
			if(target==array[mid]) {
				//如果"中位元素"等于”目标元素"，查找成功，退出
				index=mid;
				break;
			}else if(target>array[mid]){
				// 如果"中位元素"小于“目标元素”，当前数组的后半部分作为新的搜索数组
				low=mid+1;
			}else if(target<array[mid]) {
				// 如果"中位元素"大于“目标元素”，当前数组的后半部分作为新的搜索数组

				high=mid-1;
			}
		}
		System.out.printf("目标值%d在数组中的下标为：%d",target,index);
	}

四、数组乱序

思路：从数组的最后一个元素开始，向前循环，然后产生一个数组长度范围内的随机下标，再将这个随机下标与循环时的最后一位元素进行交换，从而实现数组的乱序。

代码实现：

public static void main(String[] args) {
		int[] numbers = {11,12,13,14,15,16,17};
		System.out.println(Arrays.toString(numbers));
		
		System.out.println();
		
        //从数组的最后一个元素开始，向前循环
		for(int i = numbers.length-1;i>0;i--) {
            
            //产生一个数组长度范围内的随机数
			int index = (int)(Math.random()*i);
			
            //将这个随机数与循环时的最后一个元素进行交换
			numbers[i] =numbers[index]^numbers[i];
			numbers[index] =numbers[index]^numbers[i];
			numbers[i] =numbers[index]^numbers[i];
			
		}
		System.out.println(Arrays.toString(numbers));
	}

五、数组旋转

向右旋转的思路：数组元素向右旋转实际上是把元素向左交换，是逆时针方向

向左旋转的思路：数组元素向左旋转实际上是把元素向右交换，是顺时针方向

向左旋转代码实现：

	public static void main(String[] args) {
		int[] numbers = {1,2,3,4,5,6,7};
		
		//向左旋转
		//循环3次
		for(int k = 0;k<3;k++) {
			//每次向左旋转一位
			for(int i = 0;i<numbers.length-1;i++) {
				numbers[i] = numbers[i]^numbers[i+1];
				numbers[i+1] = numbers[i]^numbers[i+1];
				numbers[i] = numbers[i]^numbers[i+1];
			}			
		}	
		System.out.println(Arrays.toString(numbers));
	}

输出：

[4, 5, 6, 7, 1, 2, 3]

向右旋转代码实现：

	public static void main(String[] args) {
		int[] numbers = {1,2,3,4,5,6,7};
		//向右旋转
		//循环3次
		for(int k = 0;k<3;k++) {
			//每次向右旋转一位
			for(int i = numbers.length-1;i>0;i--) {
				numbers[i] = numbers[i]^numbers[i-1];
				numbers[i-1] = numbers[i]^numbers[i-1];
				numbers[i] = numbers[i]^numbers[i-1];				
			}			
		}	
		System.out.println(Arrays.toString(numbers));
	}

输出：

[4, 5, 6, 7, 1, 2, 3]