快速排序，归并排序，堆排序代码

快排

public static void quickSort(int[] array, int begin, int end) {

    if (end <= begin) return;

    int pivot = partition(array, begin, end);

    quickSort(array, begin, pivot - 1);

    quickSort(array, pivot + 1, end);

}

 

static int partition(int[] a, int begin, int end) {

    // pivot: 标杆位置，counter: 小于pivot的元素的个数

    int pivot = end, counter = begin;

    for (int i = begin; i < end; i++) {

        if (a[i] < a[pivot]) {

            int temp = a[counter]; a[counter] = a[i]; a[i] = temp;

            counter++;

        }

    }

    int temp = a[pivot]; a[pivot] = a[counter]; a[counter] = temp;

    return counter;

}

 归并排序

public static void mergeSort(int[] array, int left, int right) {

    if (right <= left) return;

    int mid = (left + right) >> 1; // (left + right) / 2

 

    mergeSort(array, left, mid);

    mergeSort(array, mid + 1, right);

    merge(array, left, mid, right);

}

 

public static void merge(int[] arr, int left, int mid, int right) {

        int[] temp = new int[right - left + 1]; // 中间数组

        int i = left, j = mid + 1, k = 0;

 

        while (i <= mid && j <= right) {

            temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];

        }

 

        while (i <= mid)   temp[k++] = arr[i++];

        while (j <= right) temp[k++] = arr[j++];

 

        for (int p = 0; p < temp.length; p++) {

            arr[left + p] = temp[p];

        }

        // 也可以用 System.arraycopy(a, start1, b, start2, length)

    }

 堆排序

static void heapify(int[] array, int length, int i) {

    int left = 2 * i + 1, right = 2 * i + 2；

    int largest = i;

 

    if (left < length && array[left] > array[largest]) {

        largest = left;

    }

    if (right < length && array[right] > array[largest]) {

        largest = right;

    }

 

    if (largest != i) {

        int temp = array[i]; array[i] = array[largest]; array[largest] = temp;

        heapify(array, length, largest);

    }

}

 

public static void heapSort(int[] array) {

    if (array.length == 0) return;

 

    int length = array.length;

    for (int i = length / 2-1; i >= 0; i-) 

        heapify(array, length, i);

 

    for (int i = length - 1; i >= 0; i--) {

        int temp = array[0]; array[0] = array[i]; array[i] = temp;

        heapify(array, i, 0);

    }

}