Java中数组常见算法代码总结

数组基础知识;

什么是数组：

        数组是一种线性数据结构，是一个使用连续的内存空间存放相同的数据类型的集合容器，与其他容器相比，数组的区别主要在于性能与保存基本类型的能力。

        在Java中，数组是一种效率最高的存储和随机访问对象的方式，但是为了保持空间的连续性，在数组中插入、删除数据时，都需要移动后面数据。但是，由于数组是定长的，一旦声明之后就不可以改变长度，所以如果长度声明过大或者过小都会造成问题。

一维数组的几种创建方式

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

元素类型[] 数组名 = {元素，元素，……};

数组的常用算法代码总结

1.数组排序：

        通过方法进行排序，通过Arrays.sort()方法可直接进行排序，但其只能将数组排列为升序数组

int[] array = new int[]{1,3,4,8,2,7,5,6,10};
		Arrays.sort(array);

        通过冒泡排序进行排序

        基本思想：

用数组的第一个元素和第二个元素进行比较，将大的放到后面。然后用第二个和第三个比较，大的放后面，以此类推，直到最后一个元素，这个过程称为一轮。在一轮结束后，最大的元素已经放在最后一位了，然后开始第二趟，第二趟结束后第二大的元素就被放到倒数第二个位置，就这样持续直到所有元素有序为止（最后一个元素不用比较，所以轮数为数组长度-1）

int[] array = new int[]{1,3,4,8,2,7,5,6,10};
		
		for(int i=0;i<array.length-1;i++) {//控制循环的轮数，该数组有9个数，即只需要比较8轮

			for(int k=0;k<array.length-i-1;k++) {//控制比较后的，交换的次数
				if(array[k]>array[k+1]) {  //决定排列后的数组为升序(当k位置的数大于k+1位置的时候交换)或降序状态：
					//通过不断异或交换位置，也可使用中间变量
					array[k] = array[k] ^ array[k+1];
					array[k+1] = array[k] ^ array[k+1];
					array[k] = array[k] ^ array[k+1];
				}
				
			}
		}

选择排序

基本思想：与冒泡排序相似，通过每次从头至尾取一个数，找最大的，依次排序

int[] array = new int[]{1,3,4,8,2,7,5,6,10};
		
		for(int i=0;i<array.length-1;i++) {
			for(int k=i+1;k<array.length;k++) {
				if(array[i]>array[k]) {
					int temp = array[i];
					array[i] = array[k];
					array[k] = temp;
				}
			}
		}

还有插入排序，快速排序等

2.无序数组查找目标值：

        因为数组是无序的所以，只能从头部或者尾部，或者双指针（头部和尾部）逐个匹配，当与目标值相等时，即输出其下标

        从头查找

int[] array = new int[]{1,3,4,8,2,7,5,6,10};
		int target = 5;
		for(int i=0;i<array.length;i++) {
			if(array[i]==target) {
				System.out.println("目标值在该数组的下标为："+i);
				break;
			}
		}

        从尾查找

		int[] array = new int[]{1,3,4,8,2,7,5,6,10};
		int target = 5;
		for(int i=array.length-1;i>=0;i--) {
			if(array[i]==target) {
				System.out.println("目标值在该数组的下标为："+i);
				break;
			}
		}

        双指针查找

int[] array = new int[]{1,3,4,8,2,7,5,6,10};
		int target = 5;
		for(int i=array.length-1,k=0;i>=k;i--,k++) {
			if(array[i]==target) {
				System.out.println("目标值在该数组的下标为："+i);
				break;
			}
			if(array[k]==target) {
				System.out.println("目标值在该数组的下标为："+i);
				break;
			}
		}

3.有序数组查找

通过Arrays.binarySearch（）方法直接可返回目标值在数组中的下标，

若未查找到，则返回一个小于0的负整数

int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 10};
		int target = 5;
		Arrays.binarySearch(array, target);

        手写二分查找

int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 10};
		int target = 5;
		int low=0,high=array.length-1;
		while(low<=high) {
			int mid = (low+high)>>1;//相当于折半或除2
			if(target==array[mid]) {
				System.out.println(mid);
				break;
			}else if(array[mid]>target){
				high=mid-1;
			}else {
				low=mid+1;
			}
		}

4.数组乱序

        通过产生随机下标与当前位置的数值交换乱序

int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 10};
		for(int i=array.length-1;i>0;i--) {
			int index= (int) (Math.random()*i);
			array[i] = array[i] ^ array[index];
			array[index] = array[i] ^ array[index];
			array[i] = array[i] ^ array[index];
		}

5.数组旋转

左旋：

	int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 10};
		for(int i=0;i<3;i++) {  //控制旋转次数
			
			for(int k=0;k<array.length-1;k++) {//一次旋转需交换的次数
				//通过不断交换，移动位置
				array[k] = array[k] ^ array[k+1];
				array[k+1] = array[k] ^ array[k+1];
				array[k] = array[k] ^ array[k+1];
			}
		}

右旋：

	int[] array = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 10};
		for(int i=0;i<3;i++) {  //控制旋转次数
			
			for(int k=array.length-1;k>0;k--) {//一次旋转需交换的次数
				//通过不断交换，移动位置
				array[k] = array[k] ^ array[k-1];
				array[k-1] = array[k] ^ array[k-1];
				array[k] = array[k] ^ array[k-1];
			}
		}