数组中涉及到的常见算法

1.数组中涉及到的常见的算法

• 数组元素的赋值(杨辉三角、回形数等)
• 求数值型数组中元素的最大值、最小值、平均数、总和等
• 数组的复制、反转、查找(线性查找、二分查找等)
• 数组元素的排序算法(面试题重点)

• 1.1数组元素的赋值(杨辉三角、回形数等)

测试用例：

//使用二维数组打印一个10行的杨辉三角
public class YangHui_Test {
	public static void main(String[] args) {
		//1.声明并初始化数组
		int[][] arr = new int[10][];	
		//因为行数为10，每列的元素个数不确定，所以需要使用第二维不确定的动态初始化
		
		//2.根据杨辉三角的构型，找出行与列的关系，并为第二维开辟列空间(给数组元素赋值)
		for(int i = 0;i < arr.length;i++) {
			arr[i] = new int[i + 1];
		}
		
		//3.使用嵌套for循环，遍历二维数组中的每一个元素
		for(int i = 0;i < arr.length;i++) {	//外层数组元素个数
			for(int j = 0;j < arr[i].length;j++) {	//内层数组元素个数
				//3.1 第一行和第二行和每行的第一列和最后一列都是元素1
				if(i == 0 || i == 1 || j == 0 || j == arr[i].length - 1) {
					arr[i][j] = 1;
					System.out.print(arr[i][j] + "\t");
				//3.2 其余位置元素值为上一行元素的前一位和上一行元素的前一位的前一位相加而成
				}else {
					arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
					System.out.print(arr[i][j] + "\t");
				}
			}
			//每一个内层循环结束，打印一层杨辉三角，追加换行
			 System.out.println();
		}
	}
}

1.2求数值型数组中元素的最大值、最小值、平均数、总和等
测试用例：
/*定义一个int型的一维数组，包含10个元素，分别赋一些随机数，然后求出这些元素的最大值，最小值，和值

• 平均值。

• 要求:所有随机数都是两位数 (10,100)

• */
  public class ManyArray2_Test {
  public static void main(String[] args) {
  int[] arr = new int[10];
  int maxNumber;
  int minNumber;
  for(int i = 0;i < arr.length;i++) {
  arr[i] = (int)(Math.random() * 90 + 10);
  System.out.print(arr[i] + " ");
  }
  System.out.println();

   maxNumber = arr[0];
   minNumber = arr[0];
   int sum = 0;
   for(int i = 0;i < arr.length;i++) {
   	if(arr[i] > maxNumber) {
   		maxNumber = arr[i];
   	}
   	if(arr[i] < minNumber) {
   		minNumber = arr[i];
   	}
   	sum += arr[i];
   }
   System.out.println("随机数最大值为: " + maxNumber);
   System.out.println("随机数最小值为: " + minNumber);
   System.out.println("随机数和为: " + sum);
   System.out.println("随机数平均值为: " + sum / arr.length);
  

  }
  }

1.3数组的复制、反转、查找(线性查找、二分查找等)

测试用例：

/*算法的考察:(1).数组的复制，
			 (2).反转
			 (3).查找(线性查找，二分查找) 
 * */
public class ArrayTest1_Test {
	public static void main(String[] args) {
		//(1).数组的复制(在堆内存中开辟空间创建一个新的数组)
		//1.声明两数组变量
		int[] arr1,arr2;
		
		//2.array1初始化为8个素数：2,3,5,7,11,13,17,19。
		arr1 = new int[]{2,3,5,7,11,13,17,19,20};
		
		//3.用new关键字为arr2在堆内存中开辟空间，创建大小和arr1相等的数组对象
		arr2 = new int[arr1.length];
		
		//4.通过对数组元素进行遍历，每次都将arr1的对应位置元素值给到对应位置上的arr2(真正的复制)
		for(int i = 0;i < arr1.length;i++) {
			arr2 [i] = arr1[i];
			System.out.print(arr2[i] + "\t");	
			//输出arr2
		}
		System.out.println();
		
		//(2).数组的反转
		//方式1
		//1.对数组进行遍历并且进行反转(反转一半就完成操作)，如果长度为arr1.length那么就是反转两遍，就等于它本身
		for(int i = 0;i < arr1.length / 2;i++) {
			int temp = arr1[i];
			arr1[i] = arr1[arr1.length - 1 - i];
			arr1[arr1.length - 1 - i] = temp;
		}
		//2.对反转之后数组进行遍历输出,查看交换效果
		for(int i = 0;i < arr1.length;i++) {
			System.out.print(arr1[i] + "\t");
		}
		System.out.println();
		
		//方式2
		//1.定义两变量i,j，一个从头开始遍历，一个从尾开始遍历，每交换一次，同时进行自增和自建操作
		for(int i = 0,j = arr1.length - 1;i < j;i++,j--) {
			int temp = arr1[i];
			arr1[i] = arr1[j];
			arr1[j] = temp;
		}
		
		//2.对反转之后数组进行遍历输出,查看交换效果
		for(int i = 0;i < arr1.length;i++) {
			System.out.print(arr1[i] + "\t");
		}
		System.out.println();
		
		//(3).查找(搜索)
		//3.1线性查找: 
		int aimNumber = 13;	//目标查找元素
		boolean isFlag = true;	//表征符号
		for(int i = 0;i <  arr1.length;i++) {
			if(arr1[i] == aimNumber) {	//寻找目标元素是否存在
				System.out.println(aimNumber + " 存在,位置为" + i);
				isFlag = false;	//表征符号改变
				break;
			}
		}
		if(isFlag) {	//整个循环内都没有找到指定元素
			System.out.println(aimNumber + " 不存在 ");
		}
		
		
		//3.2二分法查找(熟悉)
		//前提:所要查找的数组必须有序。
		int[] arr = new int[] {-58,-46,-27,-15,0,5,18,26,51,86};
		int aimNumber1 = 26;
		int head = 0;
		int tail = arr.length - 1;
		boolean isFlag1 = true;
		int mid;
		while(head <= tail) {
			mid = (head + tail) / 2;
			if(arr[mid] == aimNumber1) {
				System.out.println(aimNumber1 + "存在");
				isFlag1 = false;
				break;
			}else if(aimNumber1 < arr[mid]) {
				tail  = mid - 1;
			}else {
				head = mid + 1;
			}
		}
		if(isFlag1) {
			System.out.println(aimNumber1 + "不存在");
		}
	}
}

1.4数组元素的排序算法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xrZz4SVi-1595142736560)(C:\Users\DDH\Desktop\捕获.PNG)]

• 分类:内部排序和外部排序

  ​ 内部排序：整个排序的过程不需要借助外部存储器(如磁盘等)，所有排序操作都在内存中完成。

  ​ 外部排序： 参与排序的数据非常多，数据量非常大，计算机无法把真个排序过程放在内存中完成，必须借助于外部存储器(如磁盘)。外部排序最常见的就是多路归并排序。可以认为外部排序是由多次内部排序组成。

十大内部排序算法:

• 选择排序：直接选择排序、堆排序(思想)
• 交换排序：冒泡排序、快速排序(会手写)
• 插入排序：直接插入排序、折半插入排序、Shell排序
• 归并排序(思想)
• 桶式排序
• 基数排序

冒泡排序的实现:

/*数组的冒泡排序的实现:
 * */
public class BubbleSort_Test {
	public static void main(String[] args) {
		int[] arr = new int[] {8,6,4,5,7,1,3,2,9};
		for(int i = 0;i < arr.length - 1;i++){	//控制轮数
			for(int j = 0;j < arr.length - 1 -i;j++) {	//控制内部比较次数
				if(arr[j] > arr[j + 1]) {	//每轮比较找出较大值放到本轮循环尾部
					int temp = arr[j + 1];
					arr[j + 1] = arr[j];
					arr[j] = temp;
				}
			}
		}
		for(int i = 0;i < arr.length;i++) {
			System.out.print(arr[i] + "\t");
		}
	}
}