面试必备——八大排序(JAVA)

直接插入排序

public void sort(int[] nums){
	for(int i = 1; i < nums.length;i++){
		int tmp = nums[i];
		int j;
		for(j = i; j>=0 && tmp < nums[j-1];j--){
				nums[j] = nums[j-1];
		}
		num[j] = tmp;
	}
}

平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
O(n²)	O(n²)	O(n²)	O(1)	稳定

希尔排序

public void sort(int[] a)
{
	int h = 1;
	int len = a.length;
	while( h < len / 3) h = h * 3 + 1;
	for(;h>=1;h/=3)
	{
		for(int i = 0; i < len-h; i+=h)
		{
			for(int j = i+h; j > 0; j-=h)
			{
				if( a[j] < a[j-h])
				{
					int tmp = a[j];
					a[j] = a[j-h];
					a[j-h] = tmp;
				}
			}
		}
	}
}

平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
O(nlog2 n)	O(nlog2 n)	O(nlog2 n)	O(1)	不稳定

选择排序

public void sort(int[] a)
{
	for(int i = 0; i < a.length; i++)
	{
		int min = i;
		for(int j = i+1; j < a.length; j++)
		{
			if(a[min]>a[j])
			{
				min = j;
			}
		}
		if(min!=i)
		{
			int tmp = a[min];
			a[min] = a[i];
			a[i] = tmp;
		}
	}
}

平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
O(n²)	O(n²)	O(n²)	O(1)	不稳定

堆排序

public static void sort(int[] a){
	int len = a.length - 1;
	int beginIndex = (len - 1) / 2;
	for(int i = beginIndex; i >= 0; i--)
	maxHeapify(i,len);

	for(int i = len; i > 0; i--)
	{
		swap(a,0,i);
		maxHeapify(a,0,i-1);
	}
}
private void swap(int[] a,int i, int j)
{
	int tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}
private void maxHeapify(int[] a,int index, int len)
{
	int li = index * 2 + 1;
	int ri = li + 1;
	int cMax = li;
	if(li > len) return;
	if(ri <= len && array[ri] > array[li])
		cMax = ri;
	if(array[cMax] > array[index])
	{
		swap(a,cMax,index);
		maxHeapify(a,cMax,len);
	}
}

平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
𝑂(𝑛log2𝑛)	𝑂(𝑛log2𝑛)	𝑂(𝑛log2𝑛)	O(1)	不稳定

冒泡排序

public static void sort(int[] a)
{
	for(int i = 0; i < a.length - 1; i++)
	{
		for(int j = 0; j < a.length - 1 - i; j++)
		{
			if(a[j] > a[j+1])
			{
				int tmp = a[j];
				a[j] = a[j+1];
				a[j+1] = tmp;
			}
		}
	}
}

平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
O(n²)	O(n)	O(n²)	O(1)	稳定

快速排序

public static void sort(int[] a,int low,int high)
{
	if(low >= high)
	{
		return;
	}
	int left = low;
	int right = high;
	int pivot = a[low];
	while(left < right)
	{
		while(left < right && a[right] >= pivot)
			right--;
		while(left < right && a[left] <= pivot)
			left++;
		if(left<right){
			int tmp = a[left];
			a[left] = a[right];
			a[right] = tmp;
		}
	}
	a[low] = a[i];
	a[i] = pivot;
	sort(a,low,left-1);
	sort(a,left+1,high);
}

平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
O(nlogn)	O(nlogn)	O(n²)	O(nlogn)	不稳定

快排改进（三向快速排序）

public static void sort(int[] a,int lo,int hi)
{
	if(lo >= hi)
	{
		return;
	}
	int v = a[lo], lt = lo, i = lo + 1, gt = hi;
	while(i <= gt)
	{
		if(a[i] < v)
		{
			swap(a,i++,lt++)
		}
		else if(a[i] > v)
		{
			swap(a,i,gt--);
		}else 
		{
			i++;
		}
	}
	sort(a, lo, lt - 1);
	sort(a, gt + 1, hi);
}
private static void swap(int[] a, int i, int j)
{
	int t = a[i];
	a[i] = a[j];
	a[j] = t;
}

平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
O(nlogn)	O(nlogn)	O(n²)	O(1)	不稳定

归并排序

public static sort(int[] a,int low,int high){
	int mid = (low + high) / 2;
	if(low < high){
		sort(a, low, mid);
		sort(a, mid + 1, high);
		merge(a, low, mid, high);
	}
	return a;
}
public static void merge(int[] a, int low, int mid, int high)
{
	int[] tmp = new int[high - low + 1];
	int i = low;
	int j = mid + 1;
	int k = 0;
	
	while(i <= mid && j <= high){
		if(a[i] < a[j]){
			tmp[k++] = a[i++];
		}else{
			tmp[k++] = a[j++];
		}
	}
	while(i <= mid){
		tmp[k++] = a[i++];
	}
	while(j <= high){
		tmp[k++] = a[j++];
	}

	for(int x = 0;x < tmp.length; x++)
	{
		a[x+low] = tmp[x];
	}
}

平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
𝑂(𝑛log2𝑛)	𝑂(𝑛log2𝑛)	𝑂(𝑛log2𝑛)	O(n)	稳定

基数排序

private static void sort(int[] a)
{
//找出最大的数字，并且取得最大数字的位数
	int max = 0;
	for(int i = 0; i < a.length; i++)
	{
		if(max < a[i])
			max = a[i];
	}
	int maxDigit = 1;
	while(max / 10 > 0){
		maxDigit++;
		max /= 10;
	}
	
	int[][] buckets = new int[10][a.length];
	int base = 10;

	for(int i = 0; i < maxDigit; i++)
	{
		int[] bktLen = new int[10];

		for(int j = 0; j < a.length; j++)
		{
			int whichBucket = (a[j]%base)/(base/10);
			buckets[whichBucket][bktLen[whichBucket]] = arr[j];
			bktLen[whichBucket]++;
		}
		int k = 0;
		for(int b = 0; b < buckets.length; b++){
			for(int p = 0; p < bktLen[b]; p++){
				a[k++] = buckets[b][p];
			}
		}
		base *= 10;
	}
}

平均时间复杂度	最好情况	最坏情况	空间复杂度	稳定性
O(d*(n+r))	O(d*(n+r))	O(d*(n+r))	O(n+r)	稳定