插入排序
直接插入排序
整个区间被分为
- 有序区间
- 无序区间
每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入
public static void insertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
// 有序区间: [0, i)
// 无序区间: [i, array.length)
int v = array[i]; // 无序区间的第一个数
int j = i - 1;
// 不写 array[j] == v 是保证排序的稳定性
for (; j >= 0 && array[j] > v; j--) {
array[j + 1] = array[j];
}
array[j + 1] = v;
}
}
性能分析
折半插入排序
在有序区间选择数据应该插入的位置时，因为区间的有序性，可以利用折半查找的思想
public static void bsInsertSort(int[] array) {
for (int i = 1; i < array.length; i++) {
int v = array[i];
int left = 0;
int right = i;
// [left, right)
// 需要考虑稳定性
while (left < right) {
int m = (left + right) / 2;
if (v >= array[m]) {
left = m + 1;
} else {
right = m;
}
}
// 搬移
for (int j = i; j > left; j--) {
array[j] = array[j - 1];
}
array[left] = v;
}
}
希尔排序
- 希尔排序是对直接插入排序的优化。
- 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很
快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
public static void shellSort(int[] array) {
int gap = array.length;
while (gap > 1) {
insertSortGap(array, gap);
gap = (gap / 3) + 1; // OR gap = gap / 2;
}
insertSortGap(array, 1);
}
private static void insertSortGap(int[] array, int gap) {
for (int i = 1; i < array.length; i++) {
int v = array[i];
int j = i - gap;
for (; j >= 0 && array[j] > v; j -= gap) {
array[j + gap] = array[j];
}
array[j + gap] = v;
}
}
性能分析
选择排序
直接选择排序
每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。
public static void selectSort(int[]arr){
//每次选最小放到无序区间最前面
for(int i=0;i<arr.length-1;i++){
int minindex=i;
for(int j=i+1;j<arr.length;j++){
if(arr[minindex]>arr[j]){
minindex=j;
}
}
int k=arr[minindex];
arr[minindex]=arr[i];
arr[i]=k;
}
}
性能分析
public static void selectSort(int[] array) {
// 每次选最大的放到无序区间的最后
for (int i = 0; i < array.length - 1; i++) {
// 无序 [0, array.length - i)
// 有序 [array.length - i, array.length)
int maxIndex = 0;
for (int j = 1; j < array.length - i; j++) {
if (array[j] > array[maxIndex]) {
maxIndex = j;
}
}
swap(array, maxIndex, array.length - i - 1);
}
}
双向选择排序
每一次从无序区间选出最小 + 最大的元素，存放在无序区间的最前和最后，直到全部待排序的数据元素排完 。
public static void selectSort2(int[]arr){
int begin=0;
int end=arr.length-1;
while(begin<end){
int min=begin;
int max=end;
for(int j=begin+1;j<=end;j++){
if(arr[j]<arr[min]){
min=j;
}
if(arr[j]>arr[max]){
max=j;
}
}
swap(arr,min,begin);
if(max==begin){
max=min;
}
swap(arr,max,end);
begin++;end--;
}
}
private static void swap(int[] arr, int a, int b) {
int k=arr[a];
arr[a]=arr[b];
arr[b]=k;
}
堆排序
升序建大堆，降序建小堆。
//堆排序
public static void heapSort(int []arr){
creatHeapBig(arr);
for(int i=0;i<arr.length-1;i++){
swap(arr,0,arr.length-i-1);
shiftDownBig(arr,0,arr.length-i-1);
}
}
private static void creatHeapBig(int[] arr) {
for(int i=(arr.length-2)/2;i>=0;i--){
shiftDownBig(arr,i,arr.length);
}
}
private static void shiftDownBig(int[] arr, int i, int size) {
int left = 2 * i + 1;
while (left < size) {
int right = left + 1;
int max = left;
if (right < size) {
if (arr[max] < arr[right]) {
max = right;
}
}
if (arr[i] < arr[max]) {
swap(arr, max, i);
i = max;
left = 2 * i + 1;
} else {
break;
}
}
}
冒泡排序
两两交换，每趟会固定好一个最大或最小数的位置。
public static void bubbleSort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
boolean isSorted = true;
for (int j = 0; j < array.length - i - 1; j++) {
// 相等不交换，保证稳定性
if (array[j] > array[j + 1]) {
swap(array, j, j + 1);
isSorted = false;
}
}
if (isSorted) {
break;
}
}
}
快速排序
- 从待排序区间选择一个数，作为基准值(pivot)；
- Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的
（可以包含相等的）放到基准值的右边； - 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区
间的长度 == 0，代表没有数据。
public static void quickSort(int[]arr){
quick(arr,0,arr.length-1);
}
private static void quick(int[] arr, int left, int right) {
if(left>=right)return;
int partitionId=partition1(arr,left,right);
quick(arr,left,partitionId-1);
quick(arr,partitionId+1,right);
}
private static int partition1(int[] arr, int left, int right) {
//必须先从右边开始找
int i=left;
int j=right;
int k=arr[left];
while(i<j){
while(i<j&&arr[j]>=k)
j--;
while(i<j&&arr[i]<=k)
i++;
swap(arr,i,j);
}
swap(arr,i,left);
return i;
}
//挖坑法
public static int partition2(int arr[],int left,int right){
int i=left;
int j=right;
int k=arr[left];
while(i<j){
while(i<j&&arr[j]>=k)
j--;
arr[i]=arr[j];
while(i<j&&arr[i]<=k)
i++;
arr[j]=arr[i];
}
arr[i]=k;
return i;
}
//前后遍历法
private static int partition(int[] array, int left, int right) {
int d = left + 1;
int pivot = array[left];
for (int i = left + 1; i <= right; i++) {
if (array[i] < pivot) {
swap(array, i, d);
d++;
}
}
swap(array, d - 1, left);
return d - 1;
}
- 在待排序区间选择一个基准值
- 选择左边或者右边
- 随机选取
- 几数取中法
- 做 partition，使得小的数在左，大的数在右
- hoare
- 挖坑
- 前后遍历
- 将基准值相等的也选择出来（了解）
- 分治处理左右两个小区间，直到小区间数目小于一个阈值，使用插入排序
归并排序（处理海量数据）
归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and
Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使
子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
public static void mergeSort(int[] array) {
mergeSortInternal(array, 0, array.length);
}
// 待排序区间为 [low, high)
private static void mergeSortInternal(int[] array, int low, int high) {
if (low >= high - 1) {
return;
}
int mid = (low + high) / 2;
mergeSortInternal(array, low, mid);
mergeSortInternal(array, mid, high);
merge(array, low, mid, high);
}
//就是合并两个有序数组的原理
private static void merge(int[] array, int low, int mid, int high) {
int i = low;
int j = mid;
int length = high - low;
int[] extra = new int[length];
int k = 0;
// 选择小的放入 extra
while (i < mid && j < high) {
// 加入等于，保证稳定性
if (array[i] <= array[j]) {
extra[k++] = array[i++];
} else {
extra[k++] = array[j++];
}
}
// 将属于元素放入 extra
while (i < mid) {
extra[k++] = array[i++];
}
while (j < high) {
extra[k++] = array[j++];
}
// 从 extra 搬移回 array
for (int t = 0; t < length; t++) {
// 需要搬移回原位置，从 low 开始
array[low + t] = extra[t];
}
}
总结
来源：CSDN
作者：仙女_玉玉
链接：https://blog.csdn.net/weixin_43688527/article/details/104301853