快速排序

import java.util.Arrays;

public class QuickSort {

    private static void quickSort(int[] nums) {
        quickSort(nums, 0, nums.length - 1);
    }

    private static void quickSort(int[] nums, int low, int high) {
        if (low >= high) {
            return;
        }
        int[] p = partition(nums, low, high);
        quickSort(nums, low, p[0] - 1);
        quickSort(nums, p[0] + 1, high);
    }

    private static int[] partition(int[] nums, int low, int high) {
        int less = low - 1, more = high;
        while (low < more) {
            if (nums[low] < nums[high]) {
                swap(nums, ++less, low++);
            } else if (nums[low] > nums[high]) {
                swap(nums, --more, low);
            } else {
                ++low;
            }
        }
        swap(nums, more, high);
        return new int[] {less + 1, more};
    }

    private static void swap(int[] nums, int i, int j) {
        int t = nums[i];
        nums[i] = nums[j];
        nums[j] = t;
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 7, 4, 5, 3};
        quickSort(nums);
        System.out.println(Arrays.toString(nums));
    }
}

function quickSort(arr) {
    let len = arr.length;
    return qSort(arr, 0, len - 1);
}

function qSort(arr, left, right) {
    if (left < right) {
        let index = partition(arr, left, right);
        qSort(arr, left, index - 1);
        qSort(arr, index + 1, right);
    }
    return arr;
}

function partition(arr, left, right) {
    let temp = arr[left];
    while (left < right) {
        while (left < right && arr[right] > temp) {
            right--;
        }
        arr[left] = arr[right];
        while (left < right && arr[left] <= temp) {
            left++;
        }
        arr[right] = arr[left];
    }
    arr[left] = temp;
    console.log(arr)
    return left;
}

arr = [3, 5, 6, 2, 1, 7, 4];
console.log(quickSort(arr))

package main

import "fmt"

func partition(nums []int, low, high int) int {
	pivot := nums[low]
	for low < high {
		for low < high && nums[high] >= pivot {
			high--
		}
		nums[low] = nums[high]
		for low < high && nums[low] < pivot {
			low++
		}
		nums[high] = nums[low]
	}
	nums[low] = pivot
	return low
}

func _quickSort(nums []int, low, high int) {
	if low >= high {
		return
	}
	mid := partition(nums, low, high)
	_quickSort(nums, low, mid)
	_quickSort(nums, mid+1, high)
}

func quickSort(nums []int) {
	_quickSort(nums, 0, len(nums)-1)
}

func main() {
	nums := []int{1, 2, 7, 4, 5, 3}
	quickSort(nums)
	fmt.Println(nums)
}