数组常见算法代码总结

一、数组排序（优化）

1.1基本思路

采用冒泡排序的基本思想，就是把小的元素往前移或者把大的元素往后移。 相邻的两个元素进行比较，交换也发生在这两个元素之间，若两个元素相等，则不会交换。

1.2代码实现

	//无序数组   冒泡排序
	int[] number= {3,6,2,15,19,22,2,11};

	for(int i=0,n=number.length;i<n-1;i++) {
		boolean isSorted=true;
		//每轮比较n-1-i
		for(int k=0;k<n-1-i;k++) {
			//相邻比较
			if(number[k]>number[k+1]) {
				//交换
				number[k]=number[k]^number[k+1];
				number[k+1]=number[k]^number[k+1];
				number[k]=number[k]^number[k+1];
				isSorted=false;
			}
		} 
			if(isSorted) {
					break;
		}
	}
	System.out.println(Arrays.toString(number));

二、无序数组查找

2.1基本思路

采用双指针的思想，即从头、尾部同时开始进行比较，查询速率快

2.2代码实现

	//无序数组中指定元素的查找
	//双指针
	int[] array= {
			8,12,3,4,16,32,17,12,16,3	
		};
	try(Scanner in=new Scanner(System.in)){
		int target1=in.nextInt();//目标元素
		int index1=-1;//目标元素下标，默认为-1，代表不存在
		for(int i=0,k=array.length-1;i<=k;i++,k--) {
			//从头开始比较
			if(array[i]==target1) {
				index1=i;
				break;
			}
			//从尾开始比较
			if(array[k]==target1) {
				index1=k;
				break;
			}
		}
		System.out.println(index1);
	}

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

3.1基本思路

采用二分查找的基本思想，将查找的值和数组的中间值作比较（要求这个数组必须有序）如果被查找的值小于中间值，就在中间值左侧数组继续查找；如果大于中间值，就在中间值右侧数组中查找；否则中间值就是要找的元素。

3.2代码实现

	//二分查找
	int[] arr= {
			1,2,3,4,5,6,7,8,9
	};
	int target=3;
	int index=-1;
	//数组的‘首’和‘尾’
	int low=0,high=arr.length-1 ;
	 while(low<high) {
			 //计算当前“中间位”下标
		 int mid=(low+high)/2;
		 //判断中间位下标的元素是否与目标元素相等
		 if(arr[mid]==target) {
			 index=mid;
			 break;
		 }else if(arr[mid]<target) {
			 low=mid+1;
		 }else if(arr[mid]>target) {
			 high=mid-1;
		 }
	 }
	System.out.println(index);

四、数组乱序

4.1基本思路

采用逆序循环产生随机下标，随机下标的元素通过异或来进行交换

4.2代码实现

//随机乱序算法
	int[] numbers= {
			13,14,15,16,17,18,21,22
	};
	for(int i=numbers.length-1;i>0;i--) {
		//产生随机下标
		int dex=(int)(Math.random()*i);
		numbers[dex]=numbers[dex]^numbers[i];
		numbers[i]=numbers[dex]^numbers[i];
		numbers[dex]=numbers[dex]^numbers[i];
	}
	System.out.println(Arrays.toString(numbers));

五、数组旋转

5.1基本思路

数组旋转可以分为向左旋转和向右旋转，向左旋转即正序循环遍历交换相邻两个元素，向右旋转即逆序循环遍历交换相邻两个元素，外层循环控制旋转的位数

5.2代码实现

    int[] number= {
			1,2,3,4,5,6,7
	};
	//数组向右旋转若干位
	//外层循环：控制旋转的位数，循环三次代表旋转三位
	for(int i=0;i<3;i++) {
	    //每次向右旋转一位，将尾元素不断交换，交换至数组头部
	    //遍历的方向：从尾部开始(逆序)
		for(int k=number.length-1;k>0;k--) {
			number[k]=number[k]^number[k-1];
			number[k-1]=number[k]^number[k-1];
			number[k]=number[k]^number[k-1]; 
		}
	}
	
	//数组向左旋转若干位
	//外层循环：控制旋转的位数，循环三次代表旋转三位
	for(int i=0;i<3;i++) {
		//每次向左旋转一次，将头元素放在尾元素位置上
		//遍历的方向：从头部开始(正序)
		for(int k=0;k<number.length-1;k++) {
			number[k]=number[k]^number[k+1];
			number[k+1]=number[k]^number[k+1];
			number[k]=number[k]^number[k+1];
		}
	}
	System.out.println(Arrays.toString(number));