算法刷题—快速排序

什么是快速排序

快速排序（Quick Sort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可以分别对着两部分记录继续进行排序，以达到整个序列有序。

快排的中心思想是分治 

快速排序所采用的思想是分治的思想。所谓分治，就是指以一个数为基准，将序列中的其他数往它两边“扔”。以从小到大排序为例，比它小的都“扔”到它的左边，比它大的都“扔”到它的右边，然后左右两边再分别重复这个操作，不停地分，直至分到每一个分区的基准数的左边或者右边都只剩一个数为止。这时排序也就完成了。

算法步骤

其单趟排序的思路是：取区间中最左或最右边的元素为key，定义两个变量，这里假设是p和q，q从区间的最右边向左走，找到比key小的元素就停下。p从最左边向右走，找到比key大的元素就停下。然后交换p和q所指向的元素。下面是p与q单次交换的示意图：

 

 方法一:

package 排序.快速排序;

import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        int [] ints=new int[]{16,13,50,15,4,17,83,67,29,22,18};
        int[] intsSort = quickSort(ints,0,ints.length-1);
        System.out.println(Arrays.toString(intsSort));

    }
    public static int[] quickSort(int[] ints,int left,int right){
        if(left<right){
            int partitionIndex = partition(ints, left, right);
            System.out.println(partitionIndex);
            System.out.println("partitionIndex-------------");
            quickSort(ints,left,partitionIndex-1);
            quickSort(ints,partitionIndex+1,right);
        }
       return ints;
    }

    public static int partition(int[] arr,int left,int right){

        int key = left;//取最左边的元素做key
        while (left < right)//当左右没有相遇
        {
            while (left < right && arr[right] >= arr[key])//如果右比key小就退出循环
                right--;
            while (left < right && arr[left] <= arr[key])//如果左比key大就退出循环
                left++;
            swap(arr,left,right);//交换左右
        }
        swap(arr,key,left);//交换key和相遇位置的元素
        return left;//返回key的位置

    }

    public static void swap(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}


//        swap(arr, pivot, index - 1);

方法二:

package 排序.快速排序;

import java.util.Arrays;

public class Solution {
    public static void main(String[] args) {
        int [] ints=new int[]{16,13,50,15,4,17,83,67,29,22,18};
        int[] intsSort = quickSort(ints,0,ints.length-1);
        System.out.println(Arrays.toString(intsSort));

    }
    public static int[] quickSort(int[] ints,int left,int right){
        if(left<right){
            int partitionIndex = PartSort(ints, left, right);
            System.out.println(partitionIndex);
            System.out.println("partitionIndex-------------");
            quickSort(ints,left,partitionIndex-1);
            quickSort(ints,partitionIndex+1,right);
        }
       return ints;
    }

    public static int partition(int[] arr,int left,int right){

        int key = left;//取最左边的元素做key
        while (left < right)//当左右没有相遇
        {
            while (left < right && arr[right] >= arr[key])//如果右比key小就退出循环
                right--;
            while (left < right && arr[left] <= arr[key])//如果左比key大就退出循环
                left++;
            swap(arr,left,right);//交换左右
        }
        swap(arr,key,left);//交换key和相遇位置的元素
        return left;//返回key的位置

    }
    public static int PartSort(int[] arr,int left,int right){
        int povid=left;
        int index=left+1;
        for (int i = left; i <=right ; i++) {
            if(arr[i]<arr[povid]){
                System.out.println(povid+"-----povid---");
                System.out.println(arr[povid]);
                System.out.println(index+"-----index---");
                System.out.println(arr[index]);
                swap(arr,index,i);
                index++;
            }
        }
        swap(arr,povid,index-1);
        return index-1;
    }
    public static void swap(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
}


//        swap(arr, pivot, index - 1);