申明：
内容来源于老师的课堂笔记，这只是我的整理以及一些额外补充。
五、数组
了解点：
1、数组是多个数据的集合，必须是同一类型的数据。
2、数组是一种引用/对象数据类型
3、数据的存储结构：
1）线性表：顺序表、链表、栈、队列
2）树形结构：二叉树、平衡二叉树、红黑树
3）图形结构：有向图、无向图
4、涉及排序算法、检索算法
5、创建数组时需要在内存中开辟指定大小的空间，在内存中的空间是连续的。
6、动态创建和静态创建（创建时确不确定数组中数据的区别）
7、数组的内存机制
数组是一种引用内存，数组引用变量只是一个引用，数组元素和数组变量在内存里是分开存放的。
实际的数组对象（即数组元素）被存放在堆内存（heap）中，数组的引用变量（即数组对象）被存储在栈内存中。
8、规则和不规则二维数组
掌握点：
1、Arrays方法（toString：输出数组信息，可重写；fill：填充指定值；sort：自然排序，可设置正序或逆序；equals：判断数组值和顺序是否相等）
2、数组扩充
1）原理：创建一个新数组，将原有数组移到新数组中，指针指向新数组
2）System.arraycopy();
3）Arrays.copyOf();
重点：十大经典排序算法
摘自： 排序算法总结 | 菜鸟教程 (runoob.com)
排序算法 平均时间复杂度 冒泡排序 O(n^2) 选择排序 O(n^2) 插入排序 O(n^2) 希尔排序 O(n^1.5) 快速排序 O(N*logN) 归并排序 O(N*logN) 堆排序 O(N*logN) 基数排序 O(d(n+r))
1-3、冒泡、选择、插入排序
不再赘述，简单的二重循环。
4、快速排序
基本思想：（分治）
- 先从数列中取出一个数作为key值；
- 将比这个数小的数全部放在它的左边，大于或等于它的数全部放在它的右边；
- 对左右两个小数列重复第二步，直至各区间只有1个数。
- 时间复杂度：key值的选取可以有多种形式，例如中间数或者随机数，分别会对算法的复杂度产生不同的影响。
- 代码实现：
public static void quickSort(int a[],int l,int r){ if(l>=r) return; int i = l; int j = r; int key = a[l];//选择第一个数为key while(i<j){ while(i<j && a[j]>=key)//从右向左找第一个小于key的值 j--; if(i<j){ a[i] = a[j]; i++; } while(i<j && a[i]<key)//从左向右找第一个大于key的值 i++; if(i<j){ a[j] = a[i]; j--; } } //i == j a[i] = key; quickSort(a, l, i-1);//递归调用 quickSort(a, i+1, r);//递归调用 }
5、基数排序
BinSort
基本思想：
BinSort想法非常简单，首先创建数组A[MaxValue]；然后将每个数放到相应的位置上（例如17放在下标17的数组位置）；最后遍历数组，即为排序后的结果。
- 问题： 当序列中存在较大值时，BinSort 的排序方法会浪费大量的空间开销。
RadixSort
- 基本思想： 基数排序是在BinSort的基础上，通过基数的限制来减少空间的开销。
- 过程：
（1）首先确定基数为10，数组的长度也就是10.每个数34都会在这10个数中寻找自己的位置。
（2）不同于BinSort会直接将数34放在数组的下标34处，基数排序是将34分开为3和4，第一轮排序根据最末位放在数组的下标4处，第二轮排序根据倒数第二位放在数组的下标3处，然后遍历数组即可。
相当于先对个位数排序，将个位数有序的数组再对十位数排序。
代码实现：
public static void RadixSort(int A[],int temp[],int n,int k,int r,int cnt[]){ //A:原数组 //temp:临时数组 //n:序列的数字个数 //k:最大的位数2 //r:基数10 //cnt:存储bin[i]的个数 for(int i=0 , rtok=1; i<k ; i++ ,rtok = rtok*r){ //初始化 for(int j=0;j<r;j++){ cnt[j] = 0; } //计算每个箱子的数字个数 for(int j=0;j<n;j++){ cnt[(A[j]/rtok)%r]++; } //cnt[j]的个数修改为前j个箱子一共有几个数字 for(int j=1;j<r;j++){ cnt[j] = cnt[j-1] + cnt[j]; } for(int j = n-1;j>=0;j--){ //重点理解 cnt[(A[j]/rtok)%r]--; temp[cnt[(A[j]/rtok)%r]] = A[j]; } for(int j=0;j<n;j++){ A[j] = temp[j]; } } }
6、堆排序
堆结构与树结构相似
摘自：【算法】排序算法之堆排序 - 知乎 (zhihu.com)
1. 堆的性质
① 是一棵完全二叉树
② 每个节点的值都大于或等于其子节点的值，为最大堆；反之为最小堆。2. 堆的存储
一般用数组来表示堆，下标为 i 的结点的父结点下标为(i-1)/2；其左右子结点分别为 (2i + 1)、(2i + 2)
3. 堆的操作
在堆的数据结构中，堆中的最大值总是位于根节点(在优先队列中使用堆的话堆中的最小值位于根节点)。堆中定义以下几种操作：
① 最大堆调整（Max_Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点
② 创建最大堆（Build_Max_Heap）：将堆所有数据重新排序
③ 堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算4. 实现逻辑
① 先将初始的R[0…n-1]建立成最大堆，此时是无序堆，而堆顶是最大元素。
② 再将堆顶R[0]和无序区的最后一个记录R[n-1]交换，由此得到新的无序区R[0…n-2]和有序区R[n-1]，且满足R[0…n-2].keys ≤ R[n-1].key
③ 由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。
④ 直到无序区只有一个元素为止。5.算法实现
import java.util.Arrays; public class HeapSort { private int[] arr; public HeapSort(int[] arr){ this.arr = arr; } /** * 堆排序的主要入口方法，共两步。 */ public void sort(){ /* * 第一步：将数组堆化 * beginIndex = 第一个非叶子节点。 * 从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。 * 叶子节点可以看作已符合堆要求的节点，根节点就是它自己且自己以下值为最大。 */ int len = arr.length - 1; int beginIndex = (len - 1) >> 1; for(int i = beginIndex; i >= 0; i--){ maxHeapify(i, len); } /* * 第二步：对堆化数据排序 * 每次都是移出最顶层的根节点A[0]，与最尾部节点位置调换，同时遍历长度 - 1。 * 然后从新整理被换到根节点的末尾元素，使其符合堆的特性。 * 直至未排序的堆长度为 0。 */ for(int i = len; i > 0; i--){ swap(0, i); maxHeapify(0, i - 1); } } private void swap(int i,int j){ int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } /** * 调整索引为 index 处的数据，使其符合堆的特性。 * * @param index 需要堆化处理的数据的索引 * @param len 未排序的堆（数组）的长度 */ private void maxHeapify(int index,int len){ int li = (index << 1) + 1; // 左子节点索引 int ri = li + 1; // 右子节点索引 int cMax = li; // 子节点值最大索引，默认左子节点。 if(li > len) return; // 左子节点索引超出计算范围，直接返回。 if(ri <= len && arr[ri] > arr[li]) // 先判断左右子节点，哪个较大。 cMax = ri; if(arr[cMax] > arr[index]){ swap(cMax, index); // 如果父节点被子节点调换， maxHeapify(cMax, len); // 则需要继续判断换下后的父节点是否符合堆的特性。 } } /** * 测试用例 * * 输出： * [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9] */ public static void main(String[] args) { int[] arr = new int[]{3,5,3,0,8,6,1,5,8,6,2,4,9,4,7,0,1,8,9,7,3,1,2,5,9,7,4,0,2,6}; new HeapSort(arr).sort(); System.out.println(Arrays.toString(arr)); }
7、归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法的一个非常典型的应用。……通过先递归的分解数列，再合并数列就完成了归并排序。
主要是使用递归来将数组分成小段排序，再一段一段合起来排序，直到排完。
代码实现：
public static void merge_sort(int a[],int first,int last,int temp[]){ if(first < last){ int middle = (first + last)/2; merge_sort(a,first,middle,temp);//左半部分排好序 merge_sort(a,middle+1,last,temp);//右半部分排好序 mergeArray(a,first,middle,last,temp); //合并左右部分 } } //合并 ：将两个序列a[first-middle],a[middle+1-end]合并 public static void mergeArray(int a[],int first,int middle,int end,int temp[]){ int i = first; int m = middle; int j = middle+1; int n = end; int k = 0; while(i<=m && j<=n){ if(a[i] <= a[j]){ temp[k] = a[i]; k++; i++; }else{ temp[k] = a[j]; k++; j++; } } while(i<=m){ temp[k] = a[i]; k++; i++; } while(j<=n){ temp[k] = a[j]; k++; j++; } for(int ii=0;ii<k;ii++){ a[first + ii] = temp[ii]; } }
245
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
