【算法系列-1】排序

1-冒泡排序

/**
 * 正宗的冒泡排序
 * 2012-12-17
 * 冒泡排序（BubbleSort）的基本概念是：
 * 依次比较相邻的两个数，将小数放在前面，大数放在后面。
 * 即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。
 * 然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。
 * 在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，
 * 一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。
 * 如此下去，重复以上过程，直至最终完成排序。
 * 评：每次选出一个最大的放在最后的位置？依此循环：最大 第二大 第三大 ...
 */

public class BubbleSort {
	public int[] bubbleSort(int[] array){
		for(int i=0; i<array.length -1; i++){
			for(int j=0; j<array.length -1 -i; j++){
				int temp =0;
				if(array[j] > array[j + 1]){
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		
		return array;
	}

时间复杂度：

冒泡排序总的平均时间复杂度为 O(n2)

空间复杂度：

2-快速排序

总体思路：
挖坑填数+分治法
具体步骤：
1.先挖第一个坑作为基准数key(一般为数组的第一个元素)
2.从后往前查找小于基准数的值a[j],a[i]=a[j],i++
3.从前往后查找大于基准数的值a[i],a[j]=a[i],j-- 
4.当i>=j时，回填:a[i]=key,此时a[i]左边的数都小于它，
  a[i]右边的数都大于它
5.分治算法，以a[i]为分区点-左右分区，重复2-3-4动作，
  直到每个分区只剩一个元素时退出

/**
 * @author         
 * @version        V1.0  
 * @Date           2018年2月1日 下午7:47:48 
 * @Email
 * @Description:   
 * 总体思路：
 * 挖坑填数+分治法
 * 具体步骤：
 * 1.先挖第一个坑作为基准数key(一般为数组的第一个元素)
 * 2.从后往前查找小于基准数的值a[j],a[i]=a[j],i++
 * 3.从前往后查找大于基准数的值a[i],a[j]=a[i],j-- 
 * 4.当i>=j时，回填:a[i]=key,此时a[i]左边的数都小于它，
 *   a[i]右边的数都大于它
 * 5.分治算法，以a[i]为分区点-左右分区，重复2-3-4动作，
 * 	 直到每个分区只剩一个元素时退出
 */

public class Test {
	
	public void quickSort(int[] arr, int left, int right){
		if(null == arr || arr.length == 0)
			return;
		
		if(left > right)
			return;
		
		int i = left;
		int j = right;
		int key = arr[left];  //挖第一个坑
		
		
		
		while(i < j){
			/**
			 *1. 从后向前查找一个小于key的数填坑
			 */
			while(i < j && arr[j] >= key){
				j--;
			}
			

			if(i < j){
				arr[i] = arr[j];
				i++;
			}
			
			
			/**
			 *2. 从前往后查找一个大于key的数继续填坑
			 */
			while(i < j && arr[i] <= key){
				i++;
			}
			
			if(i < j){
				arr[j] = arr[i];
				j--;
			}
			
			
//			System.out.println("i-->" + i + ", j-->" +j);
			
		}
		
		/**
		 * 3.回填
		 * 此时a[i]左边的数都小于a[i],a[i]右边的数都大于a[i]，
		 * 根据a[i]的索引左右分区
		 */
		arr[i] = key;
		System.out.printf("left:%3d, Index:%3d, right:%3d", left, i, right);
		System.out.println();
		
		/**
		 * 4.分治算法
		 */
		quickSort(arr, left, i-1);
		quickSort(arr, i+1, right);
		
	}
	
	public static void main(String[] args) {
		Test test = new Test();
		int[] arr = {72, 6, 57,88, 60, 42, 83, 73, 48, 85};
		
		test.quickSort(arr, 0, 9);
		for(int d : arr){
			System.out.printf("%4d", d);
		}
		System.out.println();
	}
	
	

}

时间复杂度：

快速排序之所以比较快，是因为相比冒泡排序，每次交换是跳跃式的。每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样只能在相邻的数之间进行交换，交换的距离就大得多了。因此总的比较和交换次数就少了，速度自然就提高了。当然在最坏的情况下，仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的，都是O(N2)，它的平均时间复杂度为O(NlogN)。

【参考】

http://blog.csdn.net/MoreWindows/article/details/6684558
白话经典算法系列之六 快速排序 快速搞定