八大排序算法

1. 完全二叉树：要求数据从上到下从左到右构建。

1. 堆排序的步骤：
   1. 完全二叉树构建大顶堆（父节点的值大于左右孩子的值）。
   2. 堆顶元素和堆底元素进行互换，除堆底元素外，继续构建大顶堆。
   3. 不断重复第二步，直到整个序列有序。

1. 如何构建大顶堆（自底向上构建）：

package com.qcby.排序;
import java.util.Arrays;

public class HeapSort {
	public static void main(String[] args) {
		int[] arr= {71,448,36,12,0,1};
		sort(arr);
		System.out.println(Arrays.toString(arr));
	}
	public static void sort(int[] arr) {
		//自底向上构建大顶堆
		for(int i=arr.length-1;i>=0;i--) {
			adjust(arr,i,arr.length-1);
			//System.out.println(Arrays.toString(arr));
		}
		for(int j=arr.length-1;j>0;j--) {
			int temp=arr[0];
			arr[0]=arr[j];
			arr[j]=temp;
			//System.out.println(Arrays.toString(arr));
			adjust(arr,0,j-1);
			//System.out.println(Arrays.toString(arr));
		}
	}
	public static void adjust(int[] arr,int parent,int right) {
		//right指向要调整数组的最后一个数
		//自顶向下调整（可能会调整很多次要用循环）
		int child=2*parent+1;//指向孩子里面值最大的那一个孩子
		//用child表示循环继续的条件（有孩子才继续），可以简化代码
		//如果用parent要考虑的情况多，而且还有if嵌套
		while(child<=right) {
			//有左孩子
			//找最大孩子
			if(child+1<=right&&arr[child+1]>arr[child]) {
				//有右孩子，并且右孩子值最大
				child++;
			}
			//判断child和parent谁大
			if(arr[child]>arr[parent]) {
				int temp=arr[child];
				arr[child]=arr[parent];
				arr[parent]=temp;
				parent=child;
				child=2*parent+1;
			}
			else {
				break;
			}
		}
 }		
}

6 基数排序

先排序个位，再十位……

一个桶里，取出顺序，先进先出。从0桶开始，依次取出。

然后，十位，最后百位。

一共要进行几轮由最大数的最大位数决定。

求时间复杂度：

解：

每一轮先放入后取出，每一轮的时间复杂度为 O(n)。一共有 k 轮（由最大数的最大位数来决定），所以，时间复杂度为O(kn)。k 不可以省略，因为不确定数据会有多大，有非常非常大。

时间复杂度：O(kn)

package com.qcby.排序;
import java.util.Arrays;

public class RadixSort {
	public static void main(String[] args) {
		int[] arr= {556,2,15,755,678,0};
		sort(arr);
		System.out.println(Arrays.toString(arr));
		}
	public static void sort(int[] arr) {
		//找最大有几位
		int max=arr[0];
		for(int i=1;i<arr.length;i++) {
			if(arr[i]>max) {
				max=arr[i];
			}
		}
		int maxLen=(max+"").length();
		//定义桶
		int[][] bucket=new int[10][arr.length];//从0开始使用
                //声明数组时不提供初始值，数组中的每个元素都会被自动初始化为0
		int[] elementCount= new int[10];//从0开始使用
		int n=1;
		for(int i=0;i<maxLen;i++,n*=10) {
			//先放
			for(int j=0;j<arr.length;j++) {
				int element=arr[j]/n%10;
				int count=elementCount[element];
				bucket[element][count]=arr[j];
				elementCount[element]++;
			}
			//再从每个桶中取 从0桶开始取，每个桶从0位开始取
			int index=0;
			for(int m=0;m<10;m++) {
				//声明数组时不提供初始值，数组中的每个元素都会被自动初始化为0,不用比
				for(int k=0;k<elementCount[m];k++,index++) {
						arr[index]=bucket[m][k];
					}
				//归零
				elementCount[m]=0;
			}
		}
	}
}

7 归并排序

两个有序数组的合并：

定义 s1 和 s2，依次指向两个有序数据的第一个数（最小值），从中选择最小值，保存到新数组的第一个数，依次类推，直到其中一个数组的数据完全用完。然后，把剩下的数组的剩余数据直接保存到新数组里。

归并排序：

先拆分。拆分从中间位置拆开，直到数据独立为止。

后合并，合并过程中借助临时空间排序，然后再保持到原数组。

求时间复杂度：

解：

每一层合并时，s1和 s2 都要遍历整个数组，时间复杂度为 O(n)。

有多少层就会有几个O(n)。

求层数k：

第 1 层：1 个数组 2 ^ 0

第 2 层：1 个数组 2 ^ 1

第 3 层：1 个数组 2 ^ 2

:

第 k 层：n 个数组 2 ^ (k - 1)

n = 2 ^ (k - 1)

=> k = log2n+1

所以，时间复杂度：O(nlogn)

package com.qcby.排序;
import java.util.Arrays;

public class MergeSort {
	public static void main(String[] args) {
		int[] arr= {556,2,15,755,678,0};
		split(arr,0,arr.length-1);
		System.out.println(Arrays.toString(arr));
		}
	public static void split(int[] arr,int left,int right) {
                //只有一个数据就返回，结束递归
		if(left>=right) {
			return;
		}
		int mid=(right+left)/2;
		split(arr,left,mid);
		split(arr,mid+1,right);
		merge(arr,left,mid,right);
	}
	public static void merge(int[] arr,int left,int mid,int right) {
		int[]  temp=new int[right-left+1];
		int index=0;
		int s1=left;
		int s2=mid+1;
		while(s1<=mid&&s2<=right) {
			if(arr[s1]<arr[s2]) {
				temp[index]=arr[s1];
				index++;
				s1++;
			}
			else {
				temp[index]=arr[s2];
				index++;
				s2++;
			}
		}
		while(s1<=mid) {
			temp[index]=arr[s1];
			index++;
			s1++;
		}
		while(s2<=right) {
			temp[index]=arr[s2];
			index++;
			s2++;
		}
		//写回arr
		for(int i=0;i<temp.length;i++) {
			arr[left+i]=temp[i];
		}
	}
}

8 快速排序

package com.qcby.排序;
import java.util.Arrays;

public class QuickSort {
	public static void main(String[] args) {
		int[] arr= {4646,666,4564,123,65,0,0};
		sort(arr,0,arr.length-1);
		System.out.println(Arrays.toString(arr));
		}
	public static void sort(int[] arr,int left,int right) {
		if(left>=right) {
			return;
		}
		int base=arr[left];
		int i=left;
		int j=right;
		while(i<j) {
			while(j>i&&arr[j]>=base) {
                        //等号必需要有，不然会出错
				j--;
			}
			while(j>i&&arr[i]<=base) {
                        //等号必需要有，不然会出错
				i++;
			}
			int temp=arr[i];
			arr[i]=arr[j];
			arr[j]=temp;
		}
		arr[left]=arr[i];
		arr[i]=base;
		sort(arr,left,i-1);
		sort(arr,i+1,right);
	}
}