快速排序

//最近用冒泡排序写了个逻辑，突然发现每次程序一跑到那里就卡住了，感觉是冒泡排序太费程序了吧应该

//就在网上看了下快速排序的方法

//形象的就是网上说的那个排运动员身高的举例子说明：

//说有10个运动员没按身高排成了一列

 A (2.00米)  B (1.00米)    C (1.55米）   D (1.83米)    E (1.62米)   F (3.00米)   G (0.5米)   H (1.56米)   I(5.90米)     J(4.1米)

//然后让他们从小到大排列，于是就请来了 甲  乙  两个人来干这个事！甲 跑到列的最左边 乙 跑到列的最右边

//他俩规定好了一个人为基准 就是著名的A运动员身高2米:

 A (2.00米)  B (1.00米)  C (1.55米）D (1.83米)E (1.62米)F (3.00米)G (0.5米)H (1.56米)  I(5.90米) G(4.1米)甲        乙

//然后甲对乙说你从你那边往我这边找比A（2米）矮的人过来，然后乙就开始从第十个（G）开始向甲的方向开始

//找比A（2米）矮的人，然后找到了第8个(H)1.56米，他就说找到了，然后给甲扔了过去，

 A (2.00米) H (1.56米) B (1.00米)  C (1.55米）D (1.83米)E (1.62米)F (3.00米)G (0.5米)  I(5.90米) G(4.1米)甲      乙  

//然后乙说 你也从你那边开始找比A（2米）高的人过来，然后甲就开始从左边开始找比A高的人，然后他找到了F（3米），然后给乙丢了过去：

 A (2.00米) H (1.56米) B (1.00米)  C (1.55米）D (1.83米)E (1.62米) G (0.5米)F (3.00米) I(5.90米) G(4.1米)     甲 乙  

//然后甲说，又该你了找吧，比A矮的，然后乙开始找，找到了G（1.5米），给甲丢了过去：

 A (2.00米) H (1.56米) B (1.00米)  C (1.55米）D (1.83米)E (1.62米)G (0.5米) F (3.00米) I(5.90米) G(4.1米)     甲乙   

//然后乙对甲说，该你了，甲刚要开始找，发现乙就在前面，顿时笑了说，行了这一轮结束了，先把A弄过来吧，然后就把A弄过来了：

 H (1.56米) B (1.00米)  C (1.55米）D (1.83米)E (1.62米)G (0.5米) A (2.00米) F (3.00米) I(5.90米) G(4.1米)     甲乙   

//这时候A的左边全是比A矮的 右边全是比A高的，

//然后，甲乙把从A开始分开成两组，一组一组的开始按照刚才这个方法开始找去了，乐此不疲，知道不能再分组了为止!

//这是目前我所理解的快速排序！下面这是我改的网上的代码，他本来是排数组的，我正好要排list的值就改了下，挺好用的！

import java.util.ArrayList;

import java.util.List;

public class paiXu {

    public void quick_sort(List< String> arrays, int lenght) {
       if (null == arrays || lenght < 1) {
           System.out.println("input error!");
           return;
       }
       _quick_sort(arrays, 0, lenght - 1);

   }

   public void _quick_sort(List< String> arrays, int start, int end) {
       if(start>=end){
           return;
       }
       
       int i = start;
       int j = end;
       long value = Long.parseLong(arrays.get(i));
       boolean flag = true;
       while (i != j) {
           if (flag) {
               if (value > Long.parseLong(arrays.get(j))) {
                   swap(arrays, i, j);
                   flag=false;


               } else {
                   j--;
               }
           }else{
               if(value<Long.parseLong(arrays.get(i))){
                   swap(arrays, i, j);
                   flag=true;
               }else{
                   i++;
               }
           }
           System.out.println("i: "+i+" j:"+j+" star: "+start);
       }
       snp(arrays);
       _quick_sort(arrays, start, j-1);
       _quick_sort(arrays, i+1, end);
       
   }

   //打印一下每次排序以后的情况
   public void snp(List< String> arrays) {
       for (int i = 0; i < arrays.size(); i++) {
           System.out.print(arrays.get(i) + " ");
       }
       System.out.println();
   }

//list的位置互换，因为list每次remove以后长度都会变化 所以我提前再换的位置上加一
   private void swap(List< String> arrays, int i, int j) {
       String tempi,tempj;
       tempi = arrays.get(i);
       tempj = arrays.get(j);
       arrays.add(i+1, tempj);
       arrays.remove(i);
      
       arrays.add(j+1, tempi);
       arrays.remove(j);
//        arrays.add(j, temp);
   }

//测试一下
   public static void main(String args[]) {
    List< String> list = new ArrayList<>();
    list.add("6");
    list.add("1");
    list.add("3");
    list.add("2");
    list.add("9");
    list.add("5");
    list.add("5");
    list.add("5");
    list.add("51");
    list.add("1234567890123456789");
    list.add("1234567890123456788");
    list.add("57");
    list.add("8");
    list.add("85");
    list.add("8");
    list.add("1233567890123456789");
    list.add("8488");
    list.add("718646");
    paiXu q = new paiXu();
       int[] a = { 1, 2, 4,3,5,6,7,8};
       q.quick_sort(list,list.size());
   } 



}