八大排序

• 排序的具体代码

public class Main {
	//冒泡,稳定,O(n^2)
	public static void maoPao(int arr[]) {
		int length = arr.length;
		for(int i=0;i<length-1;i++) {
			for(int j=0;j<length-i-1;j++) {
				if(arr[j]>arr[j+1]) {
					int swap = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = swap;
				}
			}
		}
	}
	
	//选择,不稳定,O(n^2)
	public static void xuanZe(int arr[]) {
		int length = arr.length;
		for(int i=0;i<length-1;i++) {
			int index = 0;
			for(int j=1;j<length-i;j++) {
				if(arr[j]>arr[index]) {
					index = j;
				}
			}
			int swap = arr[length-i-1];
			arr[length-i-1] = arr[index]; 
			arr[index] = swap;
		}
	}
	
	//插入排序,稳定,O(n^2)
	public static void chaRu(int arr[]) {
		for(int j=1;j<arr.length;j++) {
			int key = arr[j];
		     int i = j-1;
		      while(i>=0 && arr[i]>key){
		         arr[i+1] = arr[i];
		         i--;
		      }
		      arr[i+1] = key;
		  }
	}

	//快速排序,不稳定，O(NlogN)
	public static void kuaiSu(int arr[],int first,int last) {
		int left = first;
		int right = last;
		int refer = arr[last];
		if(first<last) {
			while(left<right) {
				while(left<right && refer >= arr[left]) {
					left++;
				}
				if(left<right) {
					arr[right] = arr[left];
				}
				while(left<right && refer <= arr[right]) {
					right--;
				}
				if(left<right) {
					arr[left] = arr[right];
				}
			}
			arr[right] = refer;
		}else {
			return;
		}
		if(first<right-1) {
			kuaiSu(arr,first,right-1);
		}
		if(right+1<last) {
			kuaiSu(arr,right+1,last);
		}
	}
	
	//归并排序,稳定,O(NlogN)
	public static void guiBing(int arr[], int low, int high) {
		if(low<high) {//递归结束条件
			int mid = low+(high-low)/2;//防止溢出
			//二路划分最小单元
			guiBing(arr, low, mid);
			guiBing(arr, mid+1, high);
			//实现归并
			int i = low;
			int j = mid+1;
			int temp[] = new int[high-low+1];
			int t = 0;
			//插入排序
			while(i<=mid && j<=high) {
				if(arr[i]<arr[j]) {
					temp[t++] = arr[i++];
				}else {
					temp[t++] = arr[j++];
				}
			}
			while(i<=mid) {
				temp[t++] = arr[i++];
			}
			while(j<=high) {
				temp[t++] = arr[j++];
			}
			for(int q=0;q<temp.length;q++) {
				arr[low+q] = temp[q];
			}	
		}
	}
	
	//堆排序,不稳定(最后的首尾结点交换导致不稳定),O(NlogN)
	public static void dui(int arr[]) {
		int len = arr.length-1;//12
		for(int i=len;i>0;i--) {
			for(int a=(i+1)/2-1;a>=0;a--) {//数组总长度/2-1可以获取到最后一个非叶子节点,这个是根据二叉树的N0 = N2 + 1;得来的
				//求出堆中最大值，并浮上堆顶
				int length = i+1;
				int left = -1;
				int right = -1;
				if (a*2+1 < length) {
					left = a*2+1;
				}
				if (a*2+2 < length) {
					right = a*2+2;
				}
				int swap_r = arr[a];
				if (left != -1) {
					if (arr[a] < arr[left]) {
						arr[a] = arr[left];
						arr[left] = swap_r;
						swap_r = arr[a];
					}
				}
				if (right != -1) {
					if (arr[a] < arr[right]) {
						arr[a] = arr[right];
						arr[right] = swap_r;
					}
				}
			}
			int swap = arr[0];
			arr[0] = arr[i];
			arr[i] = swap;
		}
	}
	
	//希尔排序,不稳定,O(NlogN)
	public static void xiEr(int[] arr) {
		// 增量gap，并逐步缩小增量
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			// 从第gap个元素，逐个对其所在组进行直接插入排序操作
			for (int i = gap; i < arr.length; i++) {
				int j = i;
				int key = arr[j];
				while (j - gap >= 0 && key < arr[j - gap]) {
					// 插入排序移动法
					arr[j] = arr[j - gap];
					j -= gap;
				}
				arr[j] = key;
			}
		}
	}
	
	//桶排序（代码略）
	//原理：就是假设有10个1-100的数，那么10个数按照位置放到1-100的桶中，然后遍历输出
}

• 时间复杂度