Java、Scala、Go以相同方式實現快速排序代碼量比較__Java

   在程式猿的世界，語言之爭是個永恒的話題，在此，我想說：讓爭論來的更猛烈些吧。

   在此，我要用相同的方式實現快速排序。首先，我們簡單的回顧一下什麼是快速排序。

快速排序：

  快排的精髓在於”分治“。注意：這是兩個方面，”分“講的是利用所選的元素（往往是第一個元素，在此命名為Key），以Key為分水嶺將列表分為：比Key元素大的和比Key元素小的兩部分；”治“講的是將分開的兩部分以同樣的方式（”分”的方式）繼續排序，直至完全排完。如下圖所示：

                  

  很顯然，用“遞迴”的方式是很不錯的。下面，每個語言用最最簡潔的方式實現這個排序，然後比較一下代碼量：

   給出的需要排序的序列是：6、2、7、3、9、4、8、5

JAVA:

private void setQuickSort(int[] array,int left,int right) {
        int i = left;
        int j= right;
        int key = array[left];
        int keyFlag = left;
        while (i < j) {
            while (i < j&&key <= array[j]) {
                j--;
            }
            if(i < j){
                int tmp = array[j];
                array[j] = array[i];
                array[i] = tmp;
                keyFlag = j;
            }
            while (i < j&&key >= array[i]) {
                i++;
            }
            if(i < j){
                int tmp1 = array[j];
                array[j] = array[i];
                array[i] = tmp1;
                keyFlag = i;
            }
        }
        if(keyFlag>left+1){
            setQuickSort(array, left, keyFlag - 1);
        }
        if(keyFlag<right-1){
            setQuickSort(array,keyFlag+1,right);
        }
    }
}

Go:

func setQuickSort(array *[9]int, left, right int) {
        i, j := left, right
        m := left
     key := array[left]
for i < j {
     for i < j && key <= array[j] {
           j--
}
if i < j {
     array[i], array[j] = array[j], array[i]
            m = j
}
for i < j && key >= array[i] {
        i++
}
if i < j {
      array[i], array[j] = array[j], array[i]
       m = i
}
}
if m > left+1 {
     setQuickSort(array, left, m-1)
}
if m < right-1 {
     setQuickSort(array, m+1, right)
}
}

Scala:

  def quickSort(array: List[Int]): List[Int] = {
    if (array.isEmpty) array
    else
      quickSort(array.filter(_<array.head)):::array.head::quickSort(array.filter(_>array.head))
  }

Scala 完勝。哈哈，請不要噴我。