数组常见算法代码总结

目录

数组排序（优化）

无序数组查找

有序数组查找（二分）

数组乱序

数组旋转

---

数组排序（优化）

思路：冒泡排序 算法是一种简单的算法，它主要是通过不断交换相邻元素，使得数组中最大元素通过交换移动到最后位置，然后重复上面操作将第二大元素移动到最大元素前一个位置，等等最后完成数组的有序。

口诀：N个数字来排序y
        两两比较小（大）靠前
        总共比较N-1轮
        每轮比较N-1-i次

通过两个for循环，第一个for控制比较轮数，第二个for控制每轮比较次数

代码：

import java.util.Arrays;

public class MaoPaoPaixu {
	public static void main(String[] args) {
		int[] n1= {31,7,54,86,2,64,34,5,10};//无序数组
		System.out.println("原数组："+Arrays.toString(n1));
		int counter=0;
		for(int i=0,n=n1.length;i<n-1;i++) {
			boolean isSorted=true;//默认有序
			for(int k=0;k<n-1-i;k++) {
				counter++;
				if(n1[k]>n1[k+1]) {
					n1[k]=n1[k]^n1[k+1];
					n1[k+1]=n1[k]^n1[k+1];
					n1[k]=n1[k]^n1[k+1];
					isSorted=false;
					//System.out.println(Arrays.toString(n1));
				}
			}
			if(isSorted) {
				break;
			}
		}
		System.out.println("总共比较次数："+counter);
		System.out.println("有序数组："+Arrays.toString(n1));
	}

}

无序数组查找

思路：方法1是通过Arrays工具类的方法先对数组排序，在调用binarySearch二分查找来找到目标元素

方法2是单指针查找，通过for遍历数组中的每一个元素，在通过与目标元素比较是否相等来查找元素

方法3是双指针查找，通过两个变量从数组的首部和尾部一起查找，再通过均与目标元素比较是否相等来查找，相比单指针比较提高效率

代码：

import java.util.Arrays;

public class Wuxushuzu {
	public static void main(String[] args) {
		int[] n1 = { 31, 7, 54, 86, 2, 64, 34, 5, 10 };// 无序数组
		int target = 54;
		int index = -1;

//		//方法1
//		Arrays.sort(n1);//先排序
//		int ret=Arrays.binarySearch(n1, target);//调用二分查找算法
//		System.out.println(ret);

//		//方法2
//		for(int i=0;i<n1.length;i++) {//单指针查找
//			if(n1[i]==target) {
//				index=i;
//				break;
//			}
//		}
//		System.out.println(index);
		

		// 方法3
		for (int i = 0, k = n1.length - 1; i <= k; i++, k--) {//双指针查找
			if (n1[i] == target) {
				index = i;
				break;
			}
			if (n1[k] == target) {
				index = k;
				break;
			}
		}
		System.out.println(index);
	}
}

有序数组查找（二分）

思路：应用二分查找需要使数组按升序排序，指定low 和 high 来表示低位和高位元素，

1、计算中间元素mid,

2、将中间元素与目标元素进行比较，如果中间元素等于目标元素，则返回中间索引位置，

3、如果中间元素大于目标元素，则目标元素位于前半部分，高位则等于中间减1，

4、如果中间元素小于目标元素，则目标元素位于后半部分，低位则等于中间加1，

最后重复1，2步骤

代码：

public class erfenchazhao {
	public static void main(String[] args) {
		int[] n= {1,2,3,4,5,6,7,8,9};
		int target=9;
		int ret=binary(n,target);
		System.out.println(ret);
	}
	
	public static int binary(int[] n,int target) {
		int low=0,high=n.length-1;
		while(low<=high) {
			int mid=(low+high)>>1;
			if(n[mid]==target) {
				return mid;
			}else if(n[mid]>target) {
				high=mid-1;
			}else if(n[mid]<target) {
				low=mid+1;
			}
		}
		//找不到返回-1
		return -1;
	}
}

数组乱序

思路：利用random随机选一个位于数组长度之内的索引，将该索引处的元素值与其他位置的值进行交换，打乱顺序，可以在外层使用for来控制打乱次数

代码：

import java.util.Arrays;

public class Shuzuluanxu {
	public static void main(String[] args) {
		int[] arr = { 1, 2, 3, 4, 5, 6 };
        System.out.println("原数组："+Arrays.toString(arr));
		for (int k = 1; k <= 3; k++) {// 乱序次数
			for (int i = arr.length - 1; i > 0; i--) {
				int rand = (int) (Math.random() * i);
				arr[rand] = arr[rand] ^ arr[i];
				arr[i] = arr[rand] ^ arr[i];
				arr[rand] = arr[rand] ^ arr[i];
			}
		}
		System.out.println("乱序后："+Arrays.toString(arr));
	}

}

数组旋转

思路：左旋：是将数组元素左旋转，实质是将头元素通过不断向右交换，交换至数组尾部

右旋：是将数组元素右旋转，实质是将尾元素通过不断向左交换，交换至数组头部

代码：

import java.util.Arrays;

public class shuzuxuanzhuan {

	public static void main(String[] args) {
		int[] n= {1,2,3,4,5,6,7,8};
		System.out.println("原数组："+Arrays.toString(n));
		right(n);
		//left(n);
		System.out.println("右旋后："+Arrays.toString(n));
		//System.out.println("左旋后："+Arrays.toString(n));
	}
	
	public static void left(int[] n) {
		//左旋
		for(int k=1;k<=3;k++) {
			for(int i=0;i<n.length-1;i++) {
				n[i]=n[i]^n[i+1];
				n[i+1]=n[i]^n[i+1];
				n[i]=n[i]^n[i+1];
			}
		}
	}

	public static void right(int[] n) {
		//右旋
		for(int k=1;k<=3;k++) {
			for(int i=n.length-1;i>0;i--) {
				n[i]=n[i]^n[i-1];
				n[i-1]=n[i]^n[i-1];
				n[i]=n[i]^n[i-1];
			}
		}
	}
}