复习——几种排序实现

这篇文章是复习所有排序的，参考了 http://www.cnblogs.com/huangxincheng/archive/2011/11/16/2251196.html ，在此表示感谢

一：冒泡

冒泡一般想着每一轮都会有一个数到最终的位置，可以是最大也可以是最小，性质都一样

public static void bubbleSort(List<Integer> arr){
		for(int i=0;i<arr.size()-1;i++){
			for(int j=arr.size()-1;j>i;j--){
				if(arr.get(j-1) > arr.get(j)){
					int temp = arr.get(j-1);
					arr.set(j-1, arr.get(j));
					arr.set(j, temp);
				}
			}
		}
	}

40	20	30	10	50
10	40	20	30	50
10	20	40	30	50
10	20	30	40	50
10	20	30	40	50

i指向arr+i处，j指向arr+j处进行循环，共同比对n+(n-1)+...+1 = O(n^2),当本身即排序时，可以为O(n)，可以加一个flag标记，当交互次数小于等于0时即跳出

二：快排

快排的思想是：一个串，选取一个基础值base，将大于base全放在base的右侧，小于base的放在左侧，这样一轮下来base到了固定的位置上并且将一个大串分成了两个小串，用递归的思想继续做下去

延伸：这种思想可以用来选取一个数组中的前k个大的数~~

private int division(List<Integer> list,int left,int right){
		int base = list.get(left);
		while(right > left){
			while(right > left && list.get(right) >= base){
				right -= 1;
			}
			list.set(left, list.get(right));
			while(right > left && list.get(left) <= base){
				left += 1;
			}
			list.set(right, list.get(left));
		}
		list.set(left, base);
		return left;
	}
	
	public void quickSort(List<Integer> list,int left,int right){
		if(left < right){
			
			int i = division(list, left, right);
			quickSort(list, left, i-1);
			quickSort(list, i+1, right);
		}
	}

时间复杂度：平均O(nlogn)，最差O(n^2)

三：直接选择排序

思想：直接选择排序其实非常简单，就是从前向后遍历，每一轮都选择剩余数中最小的值放在前端

public static List<Integer> selectionSort(List<Integer> list){
		if(list == null)
			return null;
		for(int i=0;i<list.size()-1;i++){
			int minIndex = i;
			for(int j=i+1;j<list.size()-1;j++){
				if(list.get(j) < list.get(minIndex)){
					 minIndex = j;
				}
			}
			if(list.get(minIndex) < list.get(i)){
				int temp = list.get(minIndex);
				list.set(minIndex, list.get(i));
				list.set(i, temp);
			}
		}
		return list;
	}

40	20	30	10	50
10	20	30	40	50
10	20	30	40	50
10	20	30	40	50
10	20	30	40	50

时间复杂度是O(n^2)

四：堆排序

堆排序一般分为大堆和小堆，堆一般除了用于排序之外也用于选取top K值，上文中说了快排也是可以选取top K的

所谓大堆：指根节点比所有的子节点大的堆，小堆相反，图示如下：

static void heapAdjust(int[] arr,int parent,int length){
		if (arr == null) {
			return;
		}
		int temp = arr[parent];
		int child = 2*parent+1;
		while(child < length){
			if(child+1 < length && arr[child] < arr[child+1]){
				child += 1;
			}
			
			if(temp > arr[child]){
				break;
			}
			
			arr[parent] = arr[child];
			parent = child;
			child = 2*parent + 1;
		}
		arr[parent] = temp;
	}
	
	public static void heapSort(int[] arr,int top){
		if(arr == null || top > arr.length || top <0){
			return;
		}
		for(int i=arr.length/2-1;i>=0;i--){
			heapAdjust(arr, i, arr.length);
		}
		
		for(int i=arr.length-1;i>=arr.length-top;i--){
			System.out.println("arr[0] = "+arr[0]);
			int temp = arr[0];
			arr[0] = arr[i];
			arr[i] = temp;
			heapAdjust(arr, 0, i);
		}
	}

堆排序时间复杂度O(nlogn)

五：插入排序

思想，插入排序就是将一个数组分为两段，以段是有序的，另一段是无序的，然后每次从无序段里选取一个数与有序段中的数字依次比较，插入合适的位置

public static void insertSort(int[] arr){
		if(arr == null){
			return;
		}
		for(int i = 1;i < arr.length;i++){
			int temp = arr[i];
			int j;
			for(j = i-1;j>=0 && temp < arr[j];j--){
					arr[j+1] = arr[j];
			}
			arr[j+1] = temp;
		}
	}

时间复杂度：最好情况下O（n）,最坏O（n^2）

六：希尔排序

思想：希尔排序和插入排序本质是相同的，只是将一个大的数组按照一定的规则step(初始值为arr.length/2)来分割成多个小数组

随着step的逐步减小(默认为每次缩小一半)，最终step减为1的时候则对整个数组进行插入排序，不过此时的数组已经基本有序

public static void shellSort(int[] arr){
		int step = arr.length/2;
		while(step >= 1){
			for(int i = step;i<arr.length;i++){
				int j;
				int temp = arr[i];
				for(j = i-step;j>=0 && temp<arr[j];j-=step){
					arr[j+step] = arr[j];
				}
				arr[j+step] = temp;
			}
			step /= 2;
		}
	}

时间复杂度：平均为O(n^3/2)

七：归并排序

思想：归并排序的思想简单说起来就是大的分成小的，无限分下去，然后对小的进行排序，然后再合并这些小的

public static void mergeSort(int[] arr,int[] tempArr,int left,int right){
		if(left<right){
			//取分割的位置
			int middle = (left + right)/2;
			mergeSort(arr, tempArr, left, middle);
			mergeSort(arr, tempArr, middle+1, right);
			merge(arr, tempArr, left, middle+1, right);
		}
	}
	
	/**
	 * 
	* <p>Title: merge</p>
	* <p>Description: </p>
	* <p>描述：我们借用零时数组进行合并</p>
	* @param arr
	* @param left
	* @param middle
	* @param right
	 */
	public static void merge(int[] arr,int[] tempArr,int left,int middle,int right){
		int leftEnd = middle-1;
		int rightStart = middle;
		int tempLength = right-left+1;
		int tempIndex = left;
		
		while(left <= leftEnd && rightStart <= right){
			if(arr[left] < arr[rightStart]){
				tempArr[tempIndex++] = arr[left++];
			}
			else {
				tempArr[tempIndex++] = arr[rightStart++];
			}
		}
		
		while(left <= leftEnd){
			tempArr[tempIndex++] = arr[left++];
		}
		
		while(rightStart <= right){
			tempArr[tempIndex++] = arr[rightStart++];
		}
		
		for(int i=0;i<tempLength;i++){
			arr[right] = tempArr[right];
			right--;
		}
	}

时间复杂度：O(nlogn)

空间复杂度：O(n)