快速排序算法(Java)

问题？快速排序算法(Java)，时间复杂度，空间复杂度，优缺点，稳定性

一、基本概念

快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

二、特点

1.时间复杂度

最好情况:O(n²)    最好情况:O(n²)

2.空间复杂度

O(1)

4.优点:效率高，移动数据量少，空间复杂度低

5.缺点:不稳定

三、实现

工具类：

package com.itcast.util;

public class SortUtil {

	public static void SystmSort(int data[]){
		System.out.print("\n{");
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]);
			if(i!=data.length-1){
				System.out.print(",");
			}
		}
		System.out.print("}");
	}
}

快速排序:

package com.itcast.QuickSort;

import com.itcast.util.SortUtil;

public class QuickSort1 {
	public static void quickSort(int[] data, int start, int end) {  
        // 设置关键数据key为要排序数组的第一个元素，  
        // 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小  
        int key = data[start];  
        // 设置数组左边的索引，往右移动比key大的数  
        int i = start;  
        // 设置数组右边的索引，往左移动比key小的数  
        int j = end;  
        // 如果左边索引比右边索引小，则还有数据没有排序  
        while (i < j) {  
            while (data[j] > key && j > i) {  
                j--;  
            }  
            data[i] = data[j];  
  
            while (data[i] < key && i < j) {  
                i++;  
            }  
            data[j] = data[i];  
        }  
        // 此时 i==j  
        data[i] = key;  
  
        // 递归调用  
        if (i - 1 > start) {  
            // 递归调用，把key前面的完成排序  
            quickSort(data, start, i - 1);  
        }  
        if (i + 1 < end) {  
            // 递归调用，把key后面的完成排序  
            quickSort(data, i + 1, end);  
        }  
    }
	
	public static void main(String[] args) {
		long startTime = System.currentTimeMillis();
		int data[] = {2,3,1,5,6};
		SortUtil.SystmSort(data);
		quickSort(data, 0, data.length-1);
		SortUtil.SystmSort(data);
		long endTime = System.currentTimeMillis();
		System.out.println("\n"+(endTime-startTime)+"MS");
	}
}