十大排序算法

十大排序算法

比较常用的是前八种，对于冒泡排序和堆排序要能写代码，堆排序和归并排序能说出思想，能写最好，其他排序要知道是怎么个过程，真正开发中不会自己手写排序算法。
面试的时候如果写不出来，也要跟面试官说说思想！

1. 选择排序

1.1 直接选择排序

1.2 堆排序

堆排序是一种选择排序，它的最好，最坏，平均时间复杂度均为O(nlogn)，它也是不稳定排序。

堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。

i为索引：
parent(i) = (i - 1) / 2;
leftChild(i) = i * 2 + 1;
rightChild(i) = i * 2 + 2;
len / 2 - 1 第一个非叶子节点下标。

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

整体主要由构造初始堆 + 交换堆顶元素和末尾元素并重建堆两部分组成。
其中构建初始堆经推导复杂度为O(n)，在交换并重建堆的过程中，需交换n-1次，而重建堆的过程中，根据完全二叉树的性质，[log2(n-1),log2(n-2)…1]逐步递减，近似为nlogn。所以堆排序时间复杂度一般认为就是O(nlogn)级。

class Solution {
	public int[] sortArray(int[] nums) {
		// 用堆排序实现
		int n = nums.length;
		heapify(nums);
		for(int i = nums.length - 1; i >= 0;) {
			swap(nums, 0, i);
			i--;
			siftDown(nums, 0, i);
		}
		return nums;
	}

	public void heapify(int[] nums) {
		for(int i = nums.length / 2 - 1; i >= 0; i--) {
			siftDown(nums, i, nums.length - 1);
		}
	}

	public void siftDown(int[] nums, int i, int end) {
		while(i * 2 + 1 <= end) {
			int k = i * 2 + 1;
			if(k + 1 <= end && nums[k] < nums[k + 1]) {
				k++;
			}
			if(nums[i] < nums[k]) {
				swap(nums, i, k);
			}
			i = k;
		}
	}	
	
	public void swap(int[] nums, int i, int j) {
		int t = nums[i];
		nums[i] = nums[j];
		nums[j] = t;
	}
}

2. 交换排序

2.1 冒泡排序

public class BubbleSortTest {
	public static void main(String[] args) {
		int[] arr = new int[]{43,32,76,-98,0,64,33,-21,32,99} ;
		
		for(int i=0;i<arr.length-1;i++){
			int swap = 0 ;
			for(int j=0;j<arr.length-1-i;j++){
				if(arr[j]>arr[j+1]){
					int temp = arr[j] ;
					arr[j] = arr[j+1] ;
					arr[j+1] = temp ;
					swap = 1 ;
				}
			}
			if(swap==0){
				break ;
			}
		}
	}
}

排序思想：（按升序）

1. 比较相邻的元素，如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素的元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较为止。

复杂度分析：

       若待排序的元素为正序，则只需要进行一趟排序，比较次数为(n-1)次，移动元素次数为0，若待排序的元素为逆序，则需要进行n-1趟排序，比较的次数为（n^2-n)/2，移动次数为3*（n ^2-n）/2----因为交换两个数据需要三步，因此冒泡排序的时间复杂度为O(n ^2)。由于移动的元素比较多，所以属于内排序中速度较慢的一种。

       因为冒泡排序算法只进行元素间的顺序移动，所以是一个稳定的算法。
空间复杂度为O(1)

2.2 快速排序

public class QuickSort {
	public static void main(String[] args) {
		int[] arr = {49,38,65,97,23,22,76,1,5,8,2,0,-1,22} ;
		quickSort(arr,0,arr.length-1) ;
		System.out.println("排序后：");
		for(int i:arr){
			System.out.println(i);
		}
	}
	
	private static void quickSort(int[] arr,int low,int high){
		if(low<high){
			// 找寻基准数据的正确索引
			int index = getIndex(arr,low,high) ;
			quickSort(arr,low,index-1) ;
			quickSort(arr,index+1,high) ;
		}
	}
	
	private static int getIndex(int[] arr,int low,int high){
		// 基准数据
		int tmp = arr[low] ;
		while(low<high){
			while(low<high&&arr[high]>=tmp){
				high-- ;
			}
			arr[low] = arr[high] ;
			while(low<high&&arr[low]<tmp){
				low++ ;
			}
			arr[high] = arr[low] ;
		}
		arr[low] = tmp ;
		return low ;
	}
}

排序思想：（按升序）

1. 从数列中挑出一个元素，称为"基准"（pivot），
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准
   值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，
   该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数
   列排序。

复杂度分析：
       最好的情况是每次划分对一个对象进行定位后，该对象的左子序列与右子序列的长度相同，然后将两个长度减半的子序列进行排序，时间复杂度为O(nlogn)，空间复杂度是O(logn)
       最坏的情况下是已经拍好序的序列，时间复杂度为O(n ^2),空间复杂度为O(n)，

        平均时间复杂度是O(nlogn)、空间复杂度也为O(logn)

       快速排序是一种不稳定的排序算法

3. 插入排序

3.1 直接插入排序

3.2 折半插入排序

3.3 Shell排序

4. 归并排序

5. 基数排序