数据结构与算法的初步学习---基础排序篇之快速排序

快速排序（Quicksort）

        1.插入排序的原理（摘自百度百科）        

        快速排序算法通过多次比较和交换来实现排序，其排序流程如下： 

        (1)首先设定一个分界值，通过该分界值将数组分成左右两部分。 

        (2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于分界值，而右边部分中各元素都大于或等于分界值。 

        (3)然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。 

        (4)重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。

        2.快速排序的过程图解

        假定待排序序列为arr=（3，4，2，1，5，3）如果采用快速排序对其进行升序（由小到大）排序，则整个排序过程如下所示：

        

        快速排序主要有三个参数，left 为区间的开始地址，right 为区间的结束地址，key 为当前分界值。

key=arr[left]，然后设置两个变量，left指向数组的最左部，right 指向数组的最右部。
 

分界值

左指针

右指针

已排序

        1）第一次排序：
        将left++，直到出现左边的值大于分界值，停止移动，再将right--，直到出现右边的值小于分界值，停止移动，交换二者

        

3	4	2	1	5	3

	3	4	2	1	5	3
交换二者
	3	1	2	4	5	3

	3	4	2	1	5	3
指针重合，与key值交换
	2	1	3	4	5	3

        2）第二次排序

        

2	1	3	4	5	3

	2	1	3	4	5	3
指针重合，与key值交换
	1	2	3	4	5	3

1	2	3	4	5	3

	1	2	3	4	5	3
交换二者
	1	2	3	4	3	5

1	2	3	4	3	5
1	2	3	3	4	5

        3.快速排序代码 

public static int[] qsort(int arr[],int start,int end) {        
    int pivot = arr[start];        
    int i = start;        
    int j = end;        
    while (i<j) {            
        while ((i<j)&&(arr[j]>pivot)) {                
            j--;            
        }            
        while ((i<j)&&(arr[i]<pivot)) {                
            i++;            
        }            
        if ((arr[i]==arr[j])&&(i<j)) {                
            i++;            
        } else {                
            int temp = arr[i];                
            arr[i] = arr[j];                
            arr[j] = temp;            
        }        
    }        
    if (i-1>start) arr=qsort(arr,start,i-1);        
    if (j+1<end) arr=qsort(arr,j+1,end);        
    return (arr);    
}  

        4.代码的优化

public class QuickSort1 {
    public static void main(String[] args) {
        int[] arr=new int[]{3,4,2,1,5,3};
        quickSort1(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));

    }
    public static void quickSort1(int[] arr, int left, int right) {

        if (left>right){
            return;//当左边大于右边时，直接退出
        }
        int key=arr[left];//选取最左边的数字作为基准数字
        int l=left;//记录下最左边数字，因为需要下标变动,所以需要第三个变量承载
        int r=right;
        while (l<r){
            //让右边开始先一步移动
            while (l<r && arr[r]>=key){
                r--;
            }
            if (l<r){
                arr[l]=arr[r];
            }
            while (l<r && arr[l]<=key){
                l++;
            }
            if (l<r){
                arr[r]=arr[l];
            }
        }
        arr[r]=key;

        //开始左边递归
        quickSort1(arr,left,l-1);//减去一的目的是将基准数字不在下一次排序之内
        //开始右边递归
        quickSort1(arr,r+1,right);
    }
}

    6.竞赛快排

void quick_sort(int q[], int l, int r)
{
    if (l >= r) return;

    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while (i < j)
    {
        do i ++ ; while (q[i] < x);
        do j -- ; while (q[j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r);
}

 本博文当作初学数据结构与算法萌新的学习笔记，可能会有欠缺错漏之处，欢迎指正，大家一起进步吧！