java学习之快速排序

转载至：https://www.cnblogs.com/hjy9420/p/5032309.html

先上代码…

public class QuickSort {
	public static void quickSort(int arr[]) {
		quickSort(arr,0,arr.length-1);
	}
	
	
	private static void quickSort(int[] arr, int low, int high) {
		// 10,8,7,20,15
		int start = low;
		int end = high;
		int key = arr[low];
		while(end > start) {
			while(end>start && arr[end] >= key)
				//从右往左找， 找到一个比key小的
				end--;
			if(arr[end]<key) {
				int temp = arr[end];
				arr[end] = arr[start];
				arr[start] = temp;
			}
			  
			while(end>start && arr[start] <= key)
				//从左往右找，找到一个比key大的
				start++;
			
			if(arr[start]> key) {
				int temp = arr[start];
				arr[start] = arr[end];
				arr[end] = temp;
			}		
		}
		
		if(start > low) 
			quickSort(arr,low,start-1);
		if(end < high)
			quickSort(arr,end+1,high);
		
	}


	public static void main(String[] args) {
		int [] arr = {57,88,60,42,83,73,48,85};
		quickSort(arr);
		for (int i : arr) {
			System.out.print(i+" ");
		}
	}
}

	//快速排序    交换过程
		1. 字母代表：s->start   e->end	
		2. 选取第一个arr[start]作为一个哨兵(key)，可以理解为挖了一个坑，我们进行填坑，（记得也在哪看过，
比较深刻，就记得了），填的方法就是先从右侧（末尾end）往左侧（开始start）找一个比key小的值，找到
后arr[end]（end此时指向找的值，像第一次的48）与arr[start]进行交换，也就是填坑...  
		3. 从右端（末端）找到后，再从左端（首端）开始找一个比key大的值，找到后再让arr[end]和arr[start]
（start此时指向的是找到的值，如第一次的88）进行交换....  然后重复步骤2，3
		4. 这样一直下去，直到start == end，进行将start end 左右分开，递归调用quicksort()方法，最终实现排
序....  
	if(start > low) 
			quickSort(arr,low,start-1);
	if(end < high)
			quickSort(arr,end+1,high);
			
    /*	
     *   57
     *      88 60 42 83 73 48 85
     *   s                 e  e
     *   48 88 60 42 83 73    85
     *   s  s              e
     *   48    60 42 83 73 88 85
     *      s      e  e  e  e       
     *   48 42 60    83 73 88 85
     *       s  s  e               
     *   48 42 57 60 83 73 88 85
     *         es  
     *   left :  48 42
     *   		  s  e
     *   		42 48 
     *   		   se
     *   		42
     *   		se
     *   right: 60 83 73 88 85
     *   		se           e
     *   
     * 2->right:  83 73 88 85
     *            s   e  e e
     *            73 83 88 85
     *            s  se
     * right:  88 85
     *            s   e
     *            85 88
     *            s  se
     *            88
     *            se
     *            
     *   
     *   
	*/