快排 两种不同方法(java + swift)

java语言 方法一

public static void main(String[] args) {

        int[] array = {2, 4, 1, 20, 0};
        mhfQuickSort(0,array.length,array);
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }

 }
 
 public static void mhfQuickSort(int begin, int end, int[] array) {
        if(end - begin < 2) return;
        int mid =  findPivotFirstRight(begin, end,array);
        //int mid =  findPivotFirstLeft(begin, end,array);
         // [begin mid)[mid+1 end)
        mhfQuickSort(begin, mid, array);    // [begin, mid)
        mhfQuickSort(mid+1, end, array); // [mid+1, end)
    }

```java
    public  static  int findPivotFirstRight(int begin, int end, int[] array) {
    // 随机选择一个元素跟begin位置进行交换 为了避免找到的pivot轴点不是最左边或者最右边
	swap(begin, begin + (int)(Math.random() * (end - begin)));
       int pivotElement = array[begin];
       end--; // 因为是[begin, end)
        while (begin < end) {
            // 必须从右边开始扫描 即从end开始遍历
            while (begin < end) {
                if (pivotElement < array[end]) {
                    end--;
                }else {
                    array[begin++] = array[end];
                    break;
                }
            }

            while (begin < end) {
                if (array[begin] < pivotElement) {
                    begin++;
                }else {
                    array[end--] = array[begin];
                    break;
                }
            }
        }
        array[begin] = pivotElement;
        return begin;
    }

swift语言 方法一

  func quickSort(_ arr: [Int]) -> [Int] {
        var result = arr
        quickSort1(&result, 0, arr.count)
        return result
    }

  private func quickSort1(_ arr: inout [Int], _ start: Int, _ end: Int) {
        if  end - start == 1 {
            return
        }
        let mid = findPivotByQuickSort1(&arr, start, end)
        quickSort1(&arr, start, mid)
        quickSort1(&arr, mid + 1, end)
        
    }
    
    private func findPivotByQuickSort1(_ arr: inout [Int], _ start: Int, _ end: Int) -> Int {
        var start = start, end = end
        let pivotElement = arr[start]
        while start < end {
            
            while start < end {
                if pivotElement < arr[end] {
                   end -= 1
                }else {
                    arr[start] = arr[end]
                    start += 1
                    break
                }
                
            }
            
            while start < end  {
                
                if arr[start] < pivotElement {
                    start += 1
                }else {
                    arr[end] = arr[start]
                    end -= 1
                    break
                }
            }
        }
        
        arr[start] = pivotElement
        return start
        
    }

swift语言 方法二

   func quickSort(_ arr: [Int]) -> [Int] {
        var result = arr
        quickSort(&result, 0, arr.count - 1)
        return result
    }

  private func quickSort(_ arr: inout [Int], _ start: Int, _ end: Int) {
        if start == end {
            return
        }
        let pivot = partitionByQuickSort(&arr, start, end)
        quickSort(&arr, start, pivot - 1)
        quickSort(&arr, pivot + 1, end)
    }
    
    private func partition1ByQuickSort(_ arr: inout [Int], _ start: Int, _ end: Int) -> Int {
        var start = start, end = end
        let temp = arr[start]
        let preStart = start
        // [3, 2, 1]  => [1, 2, 3]
        while start < end {
            while start < end && arr[end] > temp {
                end -= 1
            }
            while start < end && arr[start] <= temp {
                start += 1
            }            
            (arr[start], arr[end]) = (arr[end], arr[start])
        }
        (arr[preStart], arr[start]) = (arr[start], arr[preStart])
        return start
    }
    
    
    private func partitionByQuickSort(_ arr: inout [Int], _ start: Int, _ end: Int) -> Int {
        //[ 2, 1]
        let pivotElement = arr[end]
        var i = start
        for j in stride(from: start, to: end, by: 1) {
            if arr[j] <= pivotElement {
                (arr[i], arr[j]) = (arr[j], arr[i])
                i += 1
            }
        }
        (arr[i], arr[end]) = (arr[end], arr[i])
        return i
    }