Java与Scala快排

快排

Java快排

public class QuitSortJava {
    /**
     *
     * 基准
     * 左右哨兵
     *数组进行基准分区
     * 递归
     */

    public static void sort(int[] arr, int start, int end){
        //判断递归停止条件，右边哨兵小于等于左边哨兵的下标，递归结束
        if(start >= end || arr == null)
            return;
        int jz = partition(arr,start,end);
        sort(arr, start, jz - 1);
        sort(arr,jz + 1,end);
    }

    //数组进行基准分区，基准所在的索引
    public static int partition(int[] arr, int start, int end){
        //定义一个基准，以数组第一个元素
        int temp = arr[start];
        //定义左右哨兵
        int i = start;
        int j = end;
        //将小于基准的元素放在基准左边，大于基准的元素放在基准右边
        while (i < j){
            //右哨兵，从右往左找到小于基准的数据，找到一个就停止
            while (arr[j] >= temp & j > i) {
                j--;
            }
                //左哨兵，从左往右找到大于基准的数据，找到一个就停止
            while (arr[i] <= temp & i < j){
                i++;
            }


            if (i < j){
                int temp2 = arr[i];
                arr[i] = arr[j];
                arr[j] = temp2;
            }
        }
        //左右哨兵碰面所在的数组的元素要和基准所在数组的元素交换位置
        if (j != start){
            int temp1 = arr[start];
            arr[start] = arr[j];
            arr[j] = temp1;
        }
        return j;
    }

    public static void main(String[] args) {
        int[] arr = {5,6,8,1,2,4,9};
        System.out.println("------------初始数组--------");
        for (int i : arr){
            System.out.print(i);
        }
        sort(arr,0,arr.length-1);
        System.out.println("---------排序的数组--------");
        for (int i : arr){
            System.out.print(i);
        }
    }

}

Scala快排

object QuitSort {

  def qSort(a:List[Int]):List[Int] =
    if (a.length<2) a
  else
      qSort(a.filter(_<a.head))++
        a.filter(_==a.head)++
        qSort(a.filter(_>a.head))

  def main(args: Array[String]): Unit = {
    qSort(List(1,5,9,1,7,8,2)).foreach(println)
  }
}