- 1、数组元素的赋值(杨辉三角、回形数等)
- 1.1、杨辉三角
- 2、最大值、最小值、平均数、总和
- 3、复制、反转、查找(线性查找、二分法查找)
- 3.1、数组的赋值
- 3.2、数组的复制
- 3.3、数组的反转
- 3.4、数组的查找
- 3.4.1 线性查找
- 3.4.2 二分法查找
- 4、数组元素的排序算法
- 4.1 排序算法
- 4.2 冒泡排序
- 4.3 快速排序
- 4.4 排序算法性能对比
- 5、Arrays工具类的使用
- 第一行有 1 个元素, 第 n 行有 n 个元素
- 每一行的第一个元素和最后一个元素都是 1
- 从第三行开始, 对于非第一个元素和最后一个元素的元素。即:yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
public class YangHuiTest {
public static void main(String[] args) {
//1.声明并初始化二维数组
int[][] yangHui = new int[10][];
//2.给数组的元素赋值
for(int i = 0;i < yangHui.length;i++){
yangHui[i] = new int[i + 1];
//2.1 给首末元素赋值
yangHui[i][0] = yangHui[i][i] = 1;
//2.2 给每行的非首末元素赋值
for(int j = 1;j < yangHui[i].length - 1;j++){
yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
}
}
//3.遍历二维数组
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();
}
}
}
2、最大值、最小值、平均数、总和
- 最大值:遍历判断,if(maxValue < arr[i]) maxValue = arr[i];
- 最小值:遍历判断,if(minValue > arr[i]) minValue = arr[i];
- 总和:遍历求和,sum += arr[i];
- 平均数:遍历求和后,sum / arr.length;
- array2 = array1;
- 将array1保存的数组的地址值赋给了array2,使得array1和array2共同指向堆空间中的同一个数组实体。
- array2 = new int[array1.length]; array2[i] = array1[i];
- 通过new的方式,给array2在堆空间中新开辟了数组的空间。将array1数组中的元素值一个一个的赋值到array2数组中。
String[] arr = new String[]{"JJ","DD","MM","BB","GG","AA"};
for(int i = 0;i < arr.length / 2;i++){
String temp = arr[i];
arr[i] = arr[arr.length - i -1];
arr[arr.length - i -1] = temp;
}
3.4、数组的查找
3.4.1 线性查找
- 普遍适用;
- 通过遍历的方式,一个一个的数据进行比较、查找;
- 必须是一个有序数组;
- 每次比较中间值,折半的方式检索;中间值和要查找的值做比较,根据判断结果修改下次遍历的起止位置;
int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
int dest1 = 34;
int head = 0;//初始的首索引
int end = arr2.length - 1;//初始的末索引
boolean isFlag1 = true;
while(head <= end){
int middle = (head + end)/2;
if(dest1 == arr2[middle]){
System.out.println("找到了指定的元素,位置为:" + middle);
isFlag1 = false;
break;
}else if(arr2[middle] > dest1){
end = middle - 1;
}else{//arr2[middle] < dest1
head = middle + 1;
}
}
if(isFlag1){
System.out.println("很遗憾,没有找到的啦!");
}
4、数组元素的排序算法
4.1 排序算法
-
排序的目的是快速查找;
- 1)衡量排序算法的优劣:时间复杂度(次数)、空间复杂度(内存)、稳定性(相等值次序不变);
- 2)排序的分类:内部排序 与 外部排序(需要借助于磁盘);
-
十大内部排序算法:
- 选择排序:直接选择排序、 堆排序
- 交换排序:冒泡排序、 快速排序
- 插入排序:直接插入排序、 折半插入排序、 Shell排序
- 归并排序
- 桶式排序
- 基数排序
-
算法的5大特征:
-
- 输入( Input):有0个或多个输入数据,这些输入必须有清楚的描述和定义;
- 输出( Output):至少有1个或多个输出结果,不可以没有输出结果;
- 有穷性(有限性, Finiteness):算法在有限的步骤之后会自动结束而不会无限循环,并且每一个步骤可以在可接受的时间内完成;
- 确定性(明确性, Definiteness):算法中的每一步都有确定的含义,不会出现二义性;
- 可行性(有效性, Effectiveness):算法的每一步都是清楚且可行的,能让用户用纸笔计算而求出答案;
-
说明:满足确定性的算法也称为:确定性算法。 现在人们也关注更广泛的概念, 例如考虑各种非确定性的算法, 如并行算法、 概率算法等。 另外, 人们也关注并不要求终止的计算描述, 这种描述有时被称为过程(procedure) 。
- 依次比较两个元素,如果他们的顺序错误就把他们交换过来。
- 排序思想:
- 比较相邻的元素。如果第一个比第二个大(升序),就交换他们两个。
- 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤,除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较为止。
int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99};
//冒泡排序
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];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
4.3 快速排序
- 采用了分治法的思想;20世纪十大算法之一,是迄今为止所有内排序算法中速度最快的一种。冒泡排序的升级版,交换排序的一种。快速排序的时间复杂度为O(nlog(n))。
- 排序思想:
- 从数列中挑出一个元素,称为"基准"(pivot);
- 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
- 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
- 递归的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递归下去,但是这个算法总会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。
public class QuickSort {
private static void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
private static void subSort(int[] data, int start, int end) {
if (start < end) {
int base = data[start];
int low = start;
int high = end + 1;
while (true) {
while (low < end && data[++low] - base <= 0)
;
while (high > start && data[--high] - base >= 0)
;
if (low < high) {
swap(data, low, high);
} else {
break;
}
}
swap(data, start, high);
subSort(data, start, high - 1);//递归调用
subSort(data, high + 1, end);
}
}
public static void quickSort(int[] data){
subSort(data,0,data.length-1);
}
public static void main(String[] args) {
int[] data = { 9, -16, 30, 23, -30, -49, 25, 21, 30 };
System.out.println("排序之前:n" + java.util.Arrays.toString(data));
quickSort(data);
System.out.println("排序之后:n" + java.util.Arrays.toString(data));
}
}
4.4 排序算法性能对比
- 排序算法的选择:
- 若n较小(如n≤50),可采用直接插入或直接选择排序。
- 若文件初始状态基本有序(指正序),则应选用直接插入、 冒泡或随机的快速排序为宜;
- 若n较大,则应采用时间复杂度为O(nlgn)的排序方法: 快速排序、 堆排序或归并排序。
- 判断两个数组是否相等:boolean equals(int[] a,int[] b)
- 输出数组信息:String toString(int[] a)
- 将指定值填充到数组之中:void fill(int[] a,int val)
- 对数组进行排序:void sort(int[] a)
- 对排序后的数组进行二分法检索指定的值:int binarySearch(int[] a,int key)
int [] numbers = {5,900,1,5,77,30,64,700};
Arrays.sort(numbers);
for(int i = 0; i < numbers.length; i++){
System.out.println(numbers[i]);
}



