目录
1.选择排序
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
public static void selectionSort(int[] arr){ // 起始状态 : 有序区间[0..i) // 无序区间[i....n) for (int i = 0; i < arr.length - 1; i++) { // min指向的当前无序区间的最小值,min是下标 int min = i; for (int j = i + 1; j < arr.length; j++) { if(arr[j] < arr[min]){ min = j; } } // 此时min一定指向无序区间最小值下标，换到无序区间的最开始位置 swap(arr,i,min); } }
2. 插入排序
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
public static void insertionSort(int[] arr){ // 无序区间[i...n) // 有序区间[0...i) // i指向当前无序区间的第一个元素 for (int i = 1; i < arr.length; i++) { for (int j = i; j - 1 >= 0 && arr[j] < arr[j - 1]; j--) { // 简化写法 swap(arr,j,j - 1); // j - 1 要保证不为负数 因此j > 0，而不是 j >= 0 // if(arr[j] < arr[j - 1]){ // swap(arr,j,j - 1); // } } } }
3.希尔排序
是对直接插入排序的优化。
// 希尔排序（插入排序的优化），不稳定
public static void shellSort(int[] arr) {
int gap = arr.length >> 1;
while (gap > 1) {
// 先按照gap分组，组内使用插入排序
insertionSortByGap(arr,gap);
gap = gap >> 1;
}
// 当gap == 1时，整个数组接近于有序，此时来一个插入排序
insertionSortByGap(arr,1);
}
// 按照gap分组，组内的插入排序
private static void insertionSortByGap(int[] arr, int gap) {
for (int i = gap; i < arr.length; i++) {
for (int j = i; j - gap >= 0 && arr[j] < arr[j - gap] ; j -= gap) {
swap(arr,j,j - gap);
}
}
}4.归并排序
归并排序（ MERGE-SORT ）是建立在归并操作上的一种有效的排序算法 ,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
public static void mergeSort(int[] arr){
mergeSortInternal(arr,0,arr.length - 1);
}
// 在arr[l...r]进行归并排序
private static void mergeSortInternal(int[] arr, int l, int r) {
// base case
// if(l > r){
// return;
// }
// mid = (l + r) / 2
int mid = l + ((r - l) >> 1);
// 先将原数组一分为二，在子数组上先进行归并排序
mergeSortInternal(arr,l,mid);
mergeSortInternal(arr,mid + 1,r);
// 此时两个子数组已经有序,将这两个子数组合并为原数组
merge(arr,l,mid,r);
}
private static void merge(int[] arr, int l, int mid, int r) {
// 本身就是插入排序
// 创建一个大小为r - l + 1的与原数组长度一样的临时数组aux
int[] aux = new int[r - l + 1];
// arraycopy:原数组，原数组开始copy的第一个下标，目标数组，目标数组copy的第一个下标，copy的长度
System.arraycopy(arr,l,aux,0,r - l + 1);
// 两个子数组的开始索引
int i = l,j = mid + 1;
// k表示当前原数组合并到哪个位置
// 时间复杂度O(n)
for (int k = l; k <= r; k++) {
if (i > mid) {
// 子数组1全部拷贝完毕，将子数组2的所有内容写回arr
arr[k] = aux[j - l];
j ++;
}else if (j > r) {
// 子数组2全部拷贝完毕，将子数组1的剩余内容写回arr
arr[k] = aux[i - l];
i ++;
}else if (aux[i - l] <= aux[j - l]) {
// 稳定性 <=
arr[k] = aux[i - l];
i ++;
}else {
arr[k] = aux[j - l];
j ++;
}
}
}5.快速排序
// 挖坑法快速排序 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
// 时间复杂度：O(N*logN)
public static void quickSortHole(int[] arr){
quickSortHoleInternal(arr,0, arr.length - 1);
}
// 默认挖坑法快速排序
private static void quickSortHoleInternal(int[] arr,int left,int right){
// base case
if(left > right){
return;
}
int p = partitionByHole(arr,left,right);
// 继续在两个子区间上进行快速排序
quickSortHoleInternal(arr,left,p - 1);
quickSortHoleInternal(arr,p + 1,right);
}
// 时间复杂度n
private static int partitionByHole(int[] arr, int left, int right) {
// 渐进有序（极端情况完全有序）的数组，快速排序性能会退化为O(n*n)
// 原因：每次取最左边的值，假设这个值是最小的，那么j要一直减到left（二叉树会变成单支树）
// 解决：①三数取中法(课本中的方法)，②随机数法
int randomIndex = random.nextInt(left,right);
swap(arr,left,randomIndex);
int pivot = arr[left];
int i = left,j = right;
while (i < j) {
// 先让j从后向前扫描碰到第一个 < pivot的元素终止
while (i < j && arr[j] >= pivot) {
j --;
}
arr[i] = arr[j];
// 再让i从前向后扫描碰到第一个 > pivot的元素终止,
while (i < j && arr[i] <= pivot) {
i ++;
}
arr[j] = arr[i];
}
// 回填分区点
arr[j] = pivot;
return j;
}
/**
* 三路快排
* 在一次操作中将所有重复元素一次放在最终位置
* 最后只需要递归的在小于和大于v的子区间快排即可
* @param arr
*/
public static void quickSort3(int[] arr) {
quickSortInternal3(arr,0,arr.length - 1);
}
/**
* 三路快排
* @param arr
* @param l
* @param r
*/
private static void quickSortInternal3(int[] arr, int l, int r) {
if (r - l <= 64) {
insertionSort(arr,l,r);
return;
}
int randomIndex = (int) (Math.random() * (r - l + 1)) + l;
swap(arr,l,randomIndex);
int v = arr[l];
// arr[l + 1...lt] < v
int lt = l;
// arr[gt...r] > v
int gt = r + 1;
// arr[lt + 1..i) == v,i指向当前要处理的元素
int i = l + 1;
// 终止条件i和gt重合
while (i < gt) {
if (arr[i] < v) {
swap(arr,lt + 1,i);
lt ++;
i ++;
}else if (arr[i] > v) {
// 此时不需要i++，因为gt-1这个未处理的元素换到i位置
swap(arr,gt - 1,i);
gt --;
}else {
// 此处arr[i] == v
i ++;
}
}
swap(arr,l,lt);
// 交换后arr[l..lt - 1] < v ; arr[gt..r] >v
quickSortInternal3(arr,l,lt - 1);
quickSortInternal3(arr,gt,r);
}
// 算法4的分区快排
public static void quickSort(int[] arr) {
quickSortInternal(arr,0,arr.length - 1);
}
private static void quickSortInternal(int[] arr, int l, int r) {
if (r - l <= 64) {
insertionSort(arr,l,r);
return;
}
int p = partition(arr,l,r);
quickSortInternal(arr,l,p - 1);
quickSortInternal(arr,p + 1,r);
}
private static int partition(int[] arr, int l, int r) {
int randomIndex = random.nextInt(l,r);
swap(arr,l,randomIndex);
int v = arr[l];
// arr[l + 1..j] < v
int j = l;
// arr[j + 1..i) >= v
for (int i = l + 1; i <= r ; i++) {
if (arr[i] < v) {
swap(arr,j + 1,i);
j ++;
}
}
swap(arr,j,l);
return j;
}
// 挖坑法快排
public static void quickSortHole(int[] arr) {
quickSortHoleInternal(arr,0,arr.length - 1);
}
/**
* 在arr[l....r]进行快速排序
* @param arr
* @param l
* @param r
*/
private static void quickSortHoleInternal(int[] arr, int l, int r) {
// base case
// 优化1.小数组使用插入排序
if (r - l <= 64) {
insertionSort(arr,l,r);
return;
}
int p = partitionByHole(arr,l,r);
// 继续在两个子区间上进行快速排序
quickSortHoleInternal(arr,l,p - 1);
quickSortHoleInternal(arr,p + 1,r);
}
// 非递归的快排
public static void quickSortNonRecursion(int[] arr) {
// 借助栈
Deque<Integer> stack = new ArrayDeque<>();
stack.push(arr.length - 1);
stack.push(0);
while (!stack.isEmpty()) {
int l = stack.pop();
int r = stack.pop();
if (l >= r) {
// 当前这个子数组已经处理完毕
continue;
}
int p = partitionByHole(arr,l,r);
// 先将右半区间压入栈中
stack.push(r);
stack.push(p + 1);
// 继续处理左半区间
stack.push(p - 1);
stack.push(l);
}
}
private static int partitionByHole(int[] arr, int l, int r) {
// 优化2.每次分区选择随机数作为分区点 : 避免快排在近乎有序的数组上退化为O(n^2)的复杂度
int randomIndex = random.nextInt(l,r);
swap(arr,l,randomIndex);
int pivot = arr[l];
int i = l,j = r;
while (i < j) {
// 先让j从后向前扫描碰到第一个 < pivot的元素终止
while (i < j && arr[j] >= pivot) {
j --;
}
arr[i] = arr[j];
// 再让i从前向后扫描碰到第一个 > pivot的元素终止
while (i < j && arr[i] <= pivot) {
i ++;
}
arr[j] = arr[i];
}
// 回填分区点
arr[j] = pivot;
return j;
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
