Java尚硅谷基础笔记-day4数组-数组常见算法

第三章数组

3.4 数组中涉及的常见算法

3.1 数组的概述
3.2 一维数组的使用
3.3 多维数组的使用
3.4 数组中涉及的常见算法
3.5 数组工具类的使用
3.6 数组使用中的常见异常

3.4 数组中涉及的常见算法

3.4.1数组元素的赋值

练习1：杨辉三角
使用二维数组打印一个 10 行杨辉三角

【提示】

第一行有 1 个元素, 第 n 行有 n 个元素
每一行的第一个元素和最后一个元素都是 1
从第三行开始, 对于非第一个元素和最后一个元素的元素。即：
yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];

public class arrayTest {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];yanghui[i][0]=1;yanghui[i][i]=1;for(int j=1;j<yanghui[i].length-1;j++) {yanghui[i][j]=yanghui[i-1][j]+yanghui[i-1][j-1];}}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( );}}
}

练习二：回形数

import java.util.Scanner;public class arrayTest {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 maxX=arr.length-1;int maxY=arr.length-1;int minX=0;int minY=0;int count=1;while(minX<maxX) {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 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();}   }
}

3.4.2 数组元素得最大值，最小值，平均值和总和

练习1：定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，
然后求出所有元素的最大值，最小值，和值，平均值，并输出出来。
要求：所有随机数都是两位数。

int[]arr=new int[10];
for(int i=0;i<arr.length;i++) {arr[i]=(int)(Math.random()*90+10);
}
for(int i=0;i<arr.length;i++) {System.out.println(arr[i]);
}
int max=arr[0];
int min=arr[0];
int sum=0;
for(int i=0;i<arr.length;i++) {sum+=arr[i];if(arr[i]>max) {max=arr[i];}if(arr[i]<max) {max=arr[i];}
}
double avg=sum/arr.length;
System.out.println(max);
System.out.println(min);
System.out.println(sum);
System.out.println(avg);

3.4.3 数组的复制，反转和查找
数组的复制

//1.错误的复制 arr1=arr2 赋值
int[]arr1=new int[] {1,2,3,4,5,6};
int[]arr2=new int[6];
for(int i=0;i<arr1.length;i++) {System.out.print(arr1[i]+"\t");
}
System.out.println( );
arr2=arr1;
for(int i=0;i<arr2.length;i++) {if (i%2==0) {arr2[i]=0;}
}
for(int i=0;i<arr1.length;i++) {System.out.print(arr1[i]+"\t");
}
//输出：1   2   3   4   5   6
//输出：0   2   0   4   0   6
//改变arr2值，可以改变arr1，这是因为arr2和arr1指向同一个地址

将arr1保存的数组地址值赋给了arr2，使得arr1和arr2共同指向堆空间中的同一个数组实体

//数组的复制
int[] arr1, arr2;
arr1 = new int[] { 2, 3, 5, 7, 11, 13, 17, 19 };
//复制array1数组给array2
arr2 = new int[arr1.length];
for(int i=0;i<arr2.length;i++) {arr2[i]=arr1[i];
}

通过new的方式，给arr2在堆空间中新开辟了数组的空间。将arr1数组中的元素一个一个赋值到arr2数组中

数组的反转

//方法一
String[]arr1=new String[] {"aa","bb","cc","nn","vv","xx","zz"};
for(int i=0;i<arr1.length/2;i++) {String temp=arr1[i];arr1[i]=arr1[arr1.length-1-i];arr1[arr1.length-1-i]=temp;
}
for(int i=0;i<arr1.length;i++) {System.out.print(arr1[i]+"\t");
}
//方法二:
String[]arr1=new String[] {"aa","bb","cc","nn","vv","xx","zz"};
for(int i=0,j=arr1.length-1;i<j;i++,j--) {String temp=arr1[i];arr1[i]=arr1[j];arr1[j]=temp;
}

数组的查找

线性查找
方式一

//线性查找
String[]arr1=new String[] {"aa","bb","cc","nn","vv","xx","zz"};
String dest="bb";
boolean isFlag=true;
for(int i=0;i<arr1.length;i++) {if(arr1[i].equals(dest)) {System.out.print("找到了指定元素，位置为："+i);isFlag=false;break;}
}
if(isFlag) {System.out.print("没有找到");
}

方式二

//线性查找
String[]arr1=new String[] {"aa","bb","cc","nn","vv","xx","zz"};
String dest="bb";
int i;
for(int i=0;i<arr1.length;i++) {if(arr1[i].equals(dest)) {System.out.print("找到了指定元素，位置为："+i);break;}
}
if(i==arr1.length) {System.out.print("没有找到");
}

二分法：判断区间依次减半
前提：数组有序

int[]arr1=new int[] {-2,4,8,23,35,45,55,67,87,98};
int dest=55;
boolean isFlag=true;
int start=0;
int end=arr1.length-1;
while(start<=end) {int mid=(start+end)/2;if(dest==arr1[mid]) {System.out.print("找到了指定元素，位置为："+mid);isFlag=false;break;}else if(dest<arr1[mid]) {end=mid-1;}else {start=mid+1;}
}
if(isFlag) {System.out.print("没有找到");
}

3.4.4 数组的排序
排序算法
衡量排序算法的优劣：1.时间复杂度2.空间复杂度 3.稳定性
十大排序算法：
选择排序：直接选择排序，堆排序
交换排序：冒泡排序，快速排序
插入排序：直接插入排序，折半插入排序，Shell排序
归并排序
桶式排序
基数排序
冒泡排序
时间复杂度： O(n^2)
排序思想：

比较相邻的元素。如果第一个比第二个大（升序），就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步
做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要
比较为止。

int[]arr1=new int[] {-2,56,8,2,35,30,55,67,124,98};for(int i=1;i<arr1.length-1;i++) {for(int j=0;j<arr1.length-i;j++) {if(arr1[j]>arr1[j+1]) {int temp=arr1[j];arr1[j]=arr1[j+1];arr1[j+1]=temp;}}}
for(int i=0;i<arr1.length;i++) {System.out.print(arr1[i]+"\t");
}

快速排序
时间复杂度： O(nlogn）
排序思想：

从数列中挑出一个元素，称为"基准"（pivot），
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准
值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，
该基准就处于数列的中间位置。这个称为分区（partition）操作。
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数
列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好
了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代
（iteration）中，它至少会把一个元素摆到它最后的位置去。

public class arrayTest {public  static void main(String[] args) {int[]arr1=new int[] {20,80,14,-2,56,8,2,35,20,30,10,67};   int low=0;int high=arr1.length-1;Quick_short(arr1,low,high);for(int i=0;i<arr1.length;i++) {System.out.print(arr1[i]+"\t");}}//进行分区，大于arr[pivot]的在右边，小于其的在左边public static int partition(int[] arr, int low, int high) {        int pivot=low;int temp=arr[pivot];while(low<high) {while(low<high&&arr[high]>temp) {//如果右边的值一直比temp大，则high一直往中间推。当<=时，暂停high--;}//暂停之后将值赋给arr[low]，开始从左边继续看if(low<high) {arr[low]=arr[high];low++;}while(low<high&&arr[low]<temp) {//如果左边的值一直比temp小，则low一直往中间推。当>=时，暂停low++;}//暂停之后将值赋给arr[high]，开始从右边继续看if(low<high) {arr[high]=arr[low];high--;}       }//退出循环：low=high，交换low所在位置和pivot的值，并且返回此时low的值arr[low]=temp;return low;//返回arr[pivot]所在位置    }//递归过程public static int[] Quick_short(int[] arr,int s,int t) {if(s<t) {int i=partition(arr,s,t);Quick_short(arr,i+1,t);Quick_short(arr,s,i-1);}return arr;        }
}

分区部分的图解过程：

堆排序
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。（大于或等于：大顶堆，小于或等于：小顶堆）
算法描述（大顶堆）：
int arr=new int[]{30,60,8,40,70,12,10}
步骤1：将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；

步骤2：将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
步骤3：无序区(R1,R2,……Rn-1)重新建堆。然后再次将R[1]与Rn-1交换，再将(R1,R2….Rn-2)重新建堆。不断重复此过程，直到重新建堆元素为一个。

归并排序
将已有序的子序列合并，得到完全有序的序列；即先使用每个子序列有序，再使得子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
算法描述：
步骤1：把长度为n的输入序列分成两个长度为n/2的子序列；
步骤2：对这两个子序列分别采用归并排序；
步骤3：将两个排序好的子序列合并成一个最终的排序序列。