常用排序算法

一、快速排序

思路

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列![在这里插入图片描述](https://img-blog.csdnimg.cn/01dc55478edd4ca09e2e848620878583.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDcxNzk2NQ==,size_16,color_FFFFFF,t_70)

代码

public static void quickSort(int l, int r, int[] arr) {
	if(l>=r) {
		return;
	}
	//一每次数组的第一个数为基准数
	int t = arr[l];
	int i = l;
	int j = r;
	while(i<j) {
		//找出右边比基准数小的数
		while(i<j&&arr[j]>=t) {
			j--;
		}
		arr[i] = arr[j];
		//找出左边比基准数大的数
		while(i<j&&arr[i]<=t) {
			i++;
		}
		arr[j] = arr[i];
	}
	//将基准数放到指定位置i
	arr[i] = t;
	
	//向左递归
	quickSort(l, i-1, arr);
	//向右递归
	quickSort(i+1, r, arr);
}

二、归并排序

思路

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

代码

//采用分治思想，对整个数组进行拆分
public static void merge(int[] arr, int l, int r, int[] temp) {
	if (l >= r) {
		return;
	} 
	int mid = (l+r)/2; //取数组的中间值
	merge(arr, l, mid, temp); //向左边拆分
	merge(arr, mid+1, r, temp); //向右边拆分
	combine(arr, l, mid, r, temp); //合并数组
}

public static void combine(int[] arr, int l, int mid, int r, int[] temp) {
	int i = l; 
	int j = mid+1;
	int t = l;
	//对两边的数组进行组合并排序
	while(i<=mid && j<=r) {
		if(arr[i] <= arr[j]) {
			temp[t++] = arr[i];
			i++;
		} else {
			temp[t++] = arr[j];
			j++;
		}
	}
	while(i<=mid) {
		temp[t++] = arr[i++];
	}
	while(j<=r) {
		temp[t++] = arr[j++];
	}
	//将temp得到的有序数组复制到arr中
	for(int k=l; k<=r; k++) {
		arr[k] = temp[k];
	}
}

三、堆排序

思路

1. 将待排序序列构造成一个大顶堆
2. 此时，整个序列的最大值就是堆顶的根节点
3. 将其与末尾元素进行交换，此时末尾就为最大值
4. 然后将剩余 n-1 个元素重新构造成一个堆，这样会得到 n 个元素的次小值。如此反复执行，便能得到一个有序序列了

代码

//堆排序
public static void heapSort(int[] arr) {
	int len = arr.length;
	for(int i = len/2-1; i >= 0; i--) {
		adjustHeap(arr, i, len);
	}
	
	for(int i = len-1; i>0; i--) {
		int t = arr[i];
		arr[i] = arr[0];
		arr[0] = t;
		adjustHeap(arr, 0, i);
	}
}

//调整堆
public static void adjustHeap(int[] arr, int index, int len) {
	int temp = arr[index];
	for(int k=index*2+1; k<len; k=2*k+1) {
		//判断右子树是否小于左子树
		if(k+1<len && arr[k]<arr[k+1]) {
			k++;
		}
		
		//如果子节点大于根节点，则交换
		if(temp < arr[k]) {
			int t = arr[k];
			arr[k] = arr[index];
			arr[index] = t;
			index = k;
		} else {
			break;
		}
	}
}

四、插入排序

//稳定排序
public class InsertSort {
	public static void main(String[] args) {
		int[] arr = {5, 3, 6, 7, 15, 8, 20, 16, 14, 19, 5, 5, 6};
		insertSort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	public static void insertSort(int[] arr) {
		//遍历每个元素，将元素插入到已经排完序的有序序列中，从第二个数开始遍历
		for(int i=1; i<arr.length; i++) {
			for(int j=i; j>0; j--) {
				if(arr[j] < arr[j-1]) {
					swap(j-1, j, arr);
				} else {
					break;
				}
			}
		}
	}

	private static void swap(int i, int j, int[] arr) {
		int t = arr[i];
		arr[i] = arr[j];
		arr[j] = t;
	}
}