快速排序

Quick Sort的基本思想：先经过一次排序，将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

看不懂的可以参考更认真的博客：https://blog.csdn.net/qq_26122557/article/details/79458649

package com.ldy.arithmetic.sort;

import java.util.Arrays;

public class QuickSort {
    public static void main(String[] args) {
        String[] strings={"f","c","a","i","b","d","e","g","h","d"};
        int[] ints={19,9,2,3,6,5,4,7,5,11};
//        QuickSortForString(strings,0,strings.length-1);
        QuickSortForInt(ints,0,ints.length-1);
        System.out.println(Arrays.toString(ints));
    }

    private static void QuickSortForString(String[] strings, int leftIndex, int rightIndex){
        int Si=leftIndex,Sj=rightIndex;
        if(leftIndex>rightIndex){
            return;
        }
        String temp=null;
        String pivot=strings[leftIndex];//设定阈值，将小于他的放在左边，大于他的放在右边。
        while(Si<Sj){
            while((strings[Sj].compareTo(pivot))>=0 && Si<Sj){
                Sj--;
            }
            while((strings[Si].compareTo(pivot))<=0 && Si<Sj){
                Si++;
            }
            if(Si<Sj){
                temp=strings[Sj];
                strings[Sj]=strings[Si];
                strings[Si]=temp;
//                System.out.println(Arrays.toString(strings));
            }
        }
        //将基准与Si位置或者Sj交换
        strings[leftIndex]=strings[Si];
        strings[Si]=pivot;
        //再对剩下的两个序列再进行排序
        QuickSortForString(strings,leftIndex,Sj-1);
        QuickSortForString(strings,Sj+1,rightIndex);
    }

    private static void QuickSortForInt(int[] ints,int leftIndex,int rightIndex) {
        int Si,Sj,temp,t;
        if(leftIndex>rightIndex){
            return;
        }
        Si=leftIndex;
        Sj=rightIndex;
        //temp就是基准位
        temp = ints[leftIndex];

        while (Si<Sj) {
            //先看右边，依次往左递减
            while (temp<=ints[Sj]&&Si<Sj) {
                Sj--;
            }
            //再看左边，依次往右递增
            while (temp>=ints[Si]&&Si<Sj) {
                Si++;
            }
            //如果满足条件则交换
            if (Si<Sj) {
                t = ints[Sj];
                ints[Sj] = ints[Si];
                ints[Si] = t;
            }
        }
        //最后将基准为与i和j相等位置的数字交换
        ints[leftIndex] = ints[Si];
        ints[Si] = temp;
        //递归调用左半数组
        QuickSortForInt(ints, leftIndex, Sj-1);
        //递归调用右半数组
        QuickSortForInt(ints, Sj+1, rightIndex);
    }
}

结果：