最近继续重温下数据结构中的排序,其实之前在三月份得时候也有复习过了一遍,其实前人已经总结得很不错了,这次重新再过一遍,重新手写一下代码:
以下代码的swap代码都是基于如下代码:
使用位运算,更快更有逼格~
private static swap(int [] arr, int i, int j) {
arr[i] = arr[i] ^ arr[j];
arr[j] = arr[i] ^ arr[j];
arr[i] = arr[i] ^ arr[j];
}
冒泡排序:
- 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
- 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤,除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
public static void bubbleSort (int [] array) {
for (int i = array.length - 1; i > 0; i--) {
boolean flag = true;
for (int j = 0; j < i; j++) {
if (array[j] > array[j+1]) {
swap(arr,j,j+1);
flag = false;
}
}
if (flag) break;
}
}
选择排序:
- 在序列中找到最小(大)元素,放到序列的起始位置作为已排序序列;
- 再从剩余未排序元素中继续寻找最小(大)元素,放到已排序序列的末尾。
public void selectSort(int [] arr) {
for (int i = 0; i < arr.length; i++) {
int minIndex = i;
for (int j = i + 1; j < arr.length; j++) {
minIndex = arr[j] < arr[minIndex] ? j : minIndex;
}
swap(arr,i,minIdex);
}
}
插入排序
- 将第一待排序序列第一个元素看做一个有序序列,把第二个元素到最后一个元素当成是未排序序列。
- 从头到尾依次扫描未排序序列,将扫描到的每个元素插入有序序列的适当位置。(如果待插入的元素与有序序列中的某个元素相等,则将待插入元素插入到相等元素的后面。)
public static void insertSort(int [] arr) {
for (int i = 1; i < arr.length; i++) {
int tmp = arr[i];
for (int j = i - 1; j >= 0 && tmp < arr[j]; j--) {
arr[j+1] = arr[j];
}
arr[j+1] = tmp;
}
}
希尔排序
希尔排序是更高效的插入排序,它把数组分成几块,每一块进行一个插入排序;
而分块的依据在于增量的选择分好块之后,从gap开始到n,每一组和自己组内的元素进行插入排序;
这里以gap为2为例。
public void shellSort(int [] arr) {
//增量序列,这里为2
for (gap = arr.length; gap > 0; gap /= 2){
//从数组第gap个元素开始
for (int i = gap; i < gap; i++) {
int tmp = arr[i],j;
//每个元素与自己组内的数据进行直接插入排序
for (j = i - gap; j >= 0 && tmp < arr[j]; j-= gap) {
arr[j+gap] = arr[j];
}
arr[j] = tmp;
}
}
}
快速排序
原始快速排序:
static void quickSort(int [] arr) {
if (arr == null || arr.length <= 1){
return;
}
quick(arr,0,arr.length - 1);
}
static void quick(int [] arr, int L, int R){
if (L >= R) return;
int p = partition(arr,L,R);
quick(arr,L,p - 1);
quick(arr,p + 1,R);
}
// 返回pivot,使得左边都小于切分数,右边都大于切分数
static int partition(int [] arr, int L, int R) {
//获取第一个为切分元素
int num = arr[L];
int pivot = L;
for (int i = L + 1; i <= R; i++) {
if (arr[i] < num) {
swap(arr,i,++pivot);
}
}
swap(arr,L,pivot);
return pivot;
}
这种情况的快速排序有两种弊端,一是每次选第一个为切分元素,如果是最小值或者最大值,这样比较不好,还有就是说上面那种在partition中的时候只有一个指针,如果排序的数组重复元素很多的情况下,还是会使得划分极其的不均匀。
改进版快速排序(推荐):(注意区分与上面的不同)
- 写一个切分方法partition
- 然后每一次切分完成后递归调用quick方法,缩小区间。
static void quickSort(int [] arr) {
if (arr.length <= 1) return;
quick(arr,0,arr.length - 1);
}
static void quick(int [] arr,int L, int R) {
if (L >= R) return;
// 随机选取
swap(arr,L,L+(int)(Math.random()*(R - L + 1)));
int p = partition(arr,L,R);
quick(arr, L, p - 1);
quick(arr, p + 1, R);
}
static int partition(int [] arr,int L, int R) {
int num = arr[L];
//两个节点
int less = L + 1, more = R;
while (true) {
while (less < R && arr[less] < num) less++;
while (more > L) && arr[more] > num) more--;
if (less >= more) break;
swap(arr, less++, more--);
}
//最后跟L交换的是more
swap(arr,L,more);
return more;
}
堆排序
堆排序的过程是一个反复调整堆的过程:
- 利用数组建立一个大根堆(父亲比孩子的值大);
- 把堆顶元素和堆尾元素互换;
- 把堆(无序区)的尺寸缩小1,并下沉;
- 重复步骤,直到堆的大小为1;
private void HeapSort(int [] arr) {
int N = arr.length - 1;
for (int i = N / 2; i >= 1; i--) {
sink(arr,i,N);
}
while (N > 1){
swap(arr,1,N--);
sink(arr,1,N);
}
}
//下沉
private void sink(int [] arr,int k,int N) {
while (2 * k <= N) {
int j = 2 * k;
//与两个子节点中最大的节点进行交换
if (j < N && arr[j] < arr[j+1]) j++;
if (arr[k] >= arr[j]) {
break;
}
// 下沉
swap(arr,k,j)
k = j;
}
}
归并排序
归并排序采用分治的思想,这里用递归实现,首先先递归拆分子序列,然后将两个已经有序的子序列合并成一个有序序列,需要准备一个额外的数组(temp),使其大小为原来数组长度,该空间用来存放合并后的序列。
关键代码是 merge那一部分
private void mergeSort(int [] arr) {
//创建临时数组
int temp[] = new int[arr.length];
sort(arr,0,arr.length - 1,temp);
}
private void sort(int []arr,int l,int r,int [] temp) {
if (l < r){
int mid = (l + r) / 2;
//递归,左边归并排序,使得左子序列有序
sort(arr,l,mid,temp);
//右边归并排序,使得右子序列有序
sort(arr,mid+1,r,temp);
//将两个有序子数组合并操作
merge(arr,l,mid,r,temp);
}
}
//关键代码
private void merge(int []arr,int l,int mid,int r,int [] temp) {
int i = l;
int j = mid + 1;
// 临时变量
int t = 0;
while (i <= mid && j<= r) {
if (arr[i] <= arr[j]) {
temp[t++] = arr[i++];
} else {
temp[t++] = arr[j++];
}
}
//将左边剩余元素填充进temp中
while (i <= mid) {
temp[t++] = arr[i++];
}
//将右边剩余元素填充进temp中
while (j <= r) {
temp[t++] = arr[j++];
}
//将temp中的元素全部拷贝到原数组中
t = 0;
while (l <= r) {
arr[l++] = temp[t++];
}
}
这里七个排序算是比较常见的排序方式了,要好好熟悉,尤其是快排、堆排,平时刷题偶尔也可以用到,比如说快排的partition可以用来求无序数组中的第K大的数字,堆排序用来做优先队列可以用来求最大值最小值等等。
end~