数组中涉及的常见算法

一、数组元素的赋值

杨辉三角

package com.test.Test;

public class YangHuiTest {
	public static void main(String[] args) {
		int[][] yangHui = new int[10][];

		for (int i = 0; i < yangHui.length; i++) {
			yangHui[i] = new int[i + 1];
			
			//每行的首末元素赋值为1
			yangHui[i][0] = 1;
			yangHui[i][i] = 1;
			
			//从第二行开始，每个非首末元素是上一行同列元素与上一行左侧一列元素之和
			if (i > 1) {
				for (int j = 1; j < yangHui[i].length - 1; j++) {
					yangHui[i][j] = yangHui[i - 1][j - 1] + yangHui[i - 1][j];
				}
			}
		}
		
		//双重循环遍历输出
		for (int i = 0; i < yangHui.length; i++) {
			for (int j = 0; j < yangHui[i].length; j++) {
				System.out.print(yangHui[i][j] + " ");
			}
			System.out.println();
		}
	}
}

输出结果：

回形数格式方阵的实现

从键盘输入一个整数（1~20）
则以该数字为矩阵的大小，把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。例如： 输入数字2，则程序输出： 1 2
4 3
输入数字3，则程序输出： 1 2 3
8 9 4
7 6 5
输入数字4， 则程序输出：
1    2   3   4
12 13 14  5
11 16 15  6
10  9   8   7

//方法一
class RectangleTest {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.println("输入一个数字");
		int len = scanner.nextInt();
		int[][] arr = new int[len][len];

		int s = len * len;
		/*
		 * k = 1:向右 k = 2:向下 k = 3:向左 k = 4:向上
		 */
		int k = 1;
		int i = 0, j = 0;
		for (int m = 1; m <= s; m++) {				//一共要填写s = len*len个数据
			if (k == 1) {							//首先往右走
				if (j < len && arr[i][j] == 0) {	//在一行中向右走还没有走到头并且该位置还没有赋过值
					arr[i][j++] = m;				//赋值，j++再往右走一步
				} else {							
					k = 2;							//如果走到一行的最右边，k=2转向下走
					i++;							//向下走行数加一
					j--;							//因为执行了j++，所以要回退一下
					m--;							//因为j++的缘故，m在for循环又加了1，所以也要回退，再次进入下一次的for循环
				}
			} else if (k == 2) {
				if (i < len && arr[i][j] == 0) {
					arr[i++][j] = m;
				} else {
					k = 3;
					i--;							//向下走到底，回退一步
					j--;							//该往左走
					m--;
				}
			} else if (k == 3) {
				if (j >= 0 && arr[i][j] == 0) {
					arr[i][j--] = m;
				} else {
					k = 4;
					i--;							//向左走到头，该往上走
					j++;							//向左走到头，该向右回退一步
					m--;
				}
			} else if (k == 4) {
				if (i >= 0 && arr[i][j] == 0) {
					arr[i--][j] = m;
				} else {
					k = 1;
					i++;							//向上走到头，该向下回退一步
					j++;							//向上走到头，该往右走
					m--;
				}
			}
		}

		// 遍历
		for (int m = 0; m < arr.length; m++) {
			for (int n = 0; n < arr[m].length; n++) {
				System.out.print(arr[m][n] + "\t");
			}
			System.out.println();
		}
	}
}

//方法二
class RectangleTest1 {

	public static void main(String[] args) {
		int n = 7;
		int[][] arr = new int[n][n];

		int count = 0; // 要显示的数据
		int maxX = n - 1; // x轴的最大下标
		int maxY = n - 1; // Y轴的最大下标
		int minX = 0; // x轴的最小下标
		int minY = 0; // Y轴的最小下标
		while (minX <= maxX) {						//相当于一个“回”字，四个for循环一圈一圈的赋值
			for (int x = minX; x <= maxX; x++) {
				arr[minY][x] = ++count;
			}
			minY++;
			for (int y = minY; y <= maxY; y++) {
				arr[y][maxX] = ++count;
			}
			maxX--;
			for (int x = maxX; x >= minX; x--) {
				arr[maxY][x] = ++count;
			}
			maxY--;
			for (int y = maxY; y >= minY; y--) {
				arr[y][minX] = ++count;
			}
			minX++;
		}

		for (int i = 0; i < arr.length; i++) {
			for (int j = 0; j < arr.length; j++) {
				String space = (arr[i][j] + "").length() == 1 ? "0" : "";
				System.out.print(space + arr[i][j] + " ");
			}
			System.out.println();
		}
	}
}

二、数值型数组

定义一个int类型的一维数组，包含10个随机值元素，要求所有的随机数都是两位数。

public class Test4 {
	public static void main(String[] args) {
		/*
		 * Math.random()				:[0.0,1)
		 * Math.random() * 90			:[0.0,90.0)
		 * (int)(Math.random() * 90)	:[0,89]
		 * (int)(Math.random() * 90+10)	:[10,99]
		 * 
		 * 公式：获取[a,b]范围的随机数：(int)(Math.random() * (b-1+1) + a) 	
		 * */
		int[] arr = new int[10];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = (int)(Math.random() * (99 - 10 + 1) + 10);	
		}
	}
}

求最大值

		int max = 0;
		for (int i = 1; i < arr.length; i++) {
			if (arr[i] > arr[max]) {
				max = i;
			}
		}
		System.out.println("最大值：" + arr[max]);

求最小值

		int min = 0;
		for (int i = 1; i < arr.length; i++) {
			if (arr[i] < arr[max]) {
				max = i;
			}
		}
		System.out.println("最小值：" + arr[max]);

求平均数

		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		System.out.println("平均值：" + sum/10);

求总和

		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
		}
		System.out.println("总和：" + sum);

三、数组的复制、反转、查找

复制

	public static void main(String[] args) {
		int[] arr1, arr2;
		
		arr1 = new int[]{1,2,3,4};
		
		arr2 = new int[arr1.length];
		for (int i = 0; i < arr2.length; i++) {
			arr2[i] = arr1[i];
		}
		
	}

反转

		for (int i = 0; i < arr2.length/2; i++) {
			int temp = arr2[i];
			arr2[i] = arr2[arr2.length - 1 -i];
			arr2[arr2.length -1 -i] = temp;
		}

线性查找

		boolean isFlag = true;
		
		for (int i = 0; i < arr2.length; i++) {
			if (arr2[i] == 3) {
				System.out.println("查找到元素3");
				isFlag = false;
				break;
			}
		}
		if (isFlag) {
			System.out.println("未找到元素！");
		}

二分查找

		//二分查找必须是有序数组
		int[] array = new int[]{-22,3,4,7,33,56};
		boolean Flag = true;
		int findEle = 7;
		int left = 0;
		int right = array.length - 1;
		while(left <= right){
			int middle = (left + right) / 2;
			if (array[middle] == findEle) {
				System.out.println("找到元素：" + findEle);
				Flag = false;
				break;
			}else if (array[middle] > findEle) {
				right = middle - 1;
			}else {
				left = middle + 1;
			}
		}
		if (Flag) {
			System.out.println("未找到元素！");
		}

四、数组元素的排序算法

冒泡排序

public class BubbleSortTest {
	public static void main(String[] args) {
		int[] array = new int[]{22,-4,555,-44,23,57,1,5,66};
		System.out.println("原始数组：");
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
		
		//冒泡排序
		for (int i = 0; i < array.length - 1; i++) {			//最后一个元素没必要排序，属所以length-1
			for (int j = 0; j < array.length - 1 - i; j++) {	//已经排序好的无需再比较，所以length-1-i
				if (array[j] > array[j+1]) {
					int temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		
		System.out.println("\n冒泡排序：");
		for (int i = 0; i < array.length; i++) {
			System.out.print(array[i] + " ");
		}
	}
}

输出结果：

快速排序

public class QuickSortTest {
	public static void main(String[] args) {
		int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
		System.out.println("排序之前：" + java.util.Arrays.toString(data));
		quickSort(data);
		System.out.println("快速排序之后：" + java.util.Arrays.toString(data));
	}

	private static void quickSort(int[] data) {
		subSort(data,0,data.length-1);			//分而治之
	}

	private static void subSort(int[] data, int start, int end) {
		if (start < end) {		//start、end记录数组开头和结尾
			int base = data[start];		//以第一个元素为参照
			int left = start;			//left指向第一个元素
			int right = end + 1;		//right指向末尾元素的后一个位置
			while(true){
				while(left < end && data[++left] <= base)		//从第二个元素开始与base比较，从左往右找比base大的值，然后left记录该值位置
					;
				while(right > start && data[--right] >= base)	//从最后一个元素开始与base比较，从右往左找比base小的元素，然后right记录该值位置
					;	
				if (left < right) {
					swap(data, left, right);
				}else {
					break;
				}
			}
			swap(data, start, right);							//交换base的值，放在中间合适位置
			
			subSort(data, start, right-1);						//一分为二的左部分数组递归调用快速排序
			subSort(data, right+1, end);						//一分为二的右部分数组递归调用快速排序
		}
		
	}

	private static void swap(int[] data, int i, int j) {
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
		
	}
}

五、Arrays工具类的使用

java.util.Arrays是操作数组的工具类，定义了很多操作数组的方法。

public class ArraysTest {
	public static void main(String[] args) {
		//1.boolean equals(int[] a,int[] b):判断两个数组是否相等。
		int[] arr1 = new int[]{1,2,3,4};
		int[] arr2 = new int[]{1,3,2,4};
		boolean isEquals = Arrays.equals(arr1, arr2);
		System.out.println(isEquals);
		
		//2.String toString(int[] a):输出数组信息。
		System.out.println(Arrays.toString(arr1));
		
		//3.void fill(int[] a,int val):将指定值填充到数组之中。
		Arrays.fill(arr1,10);
		System.out.println(Arrays.toString(arr1));		

		//4.void sort(int[] a):对数组进行排序。
		Arrays.sort(arr2);
		System.out.println(Arrays.toString(arr2));
		
		//5.int binarySearch(int[] a,int key)
		int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
		int index = Arrays.binarySearch(arr3, 210);
		if(index >= 0){
			System.out.println(index);
		}else{
			System.out.println("未找到");
		}
	}
}