排序：快速排序 （学习记录）

时间复杂度：O（n²）最坏，优化后O（nlogn）

C语言版：

#include <stdio.h>

//交换函数
void Swap(int* arr, int i, int j){
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}
void QuickSort(int* arr, int start, int end)
{
    //递归出口
	if (start > end)
	{
		return;
	}

    //快排优化，将中间元素与start进行交换。可以使得每次几乎分成相等的两份
    //避免在数组初始有序时算法退化为冒泡
    int middle = start + (end-start)/2;
	Swap(arr,start,middle);

	int key,left,right;
	left = start;
	right = end;
	key = left;           //将初始值的第一个元素设为基准值

	while( left < right ){
        //从右边开始，当右指针元素比基准值大时，右指针左移
	    while(left < right && arr[right] >= arr[key]){
			right--;
		}
        //左边开始，当左指针元素比基准值小时，左指针右移
		while(left < right && arr[left] <= arr[key]){
			left++;
		}
	    //交换left、right各自找到的值
		if (left < right)
		{
			Swap(arr, left, right);
		}
	}
    //把基准值与left=right时的值进行交换
    Swap(arr,left,key);
	
    //递归左边分组
	QuickSort(arr, start, left-1);
    //递归右边分组
	QuickSort(arr, left+1, end);
}
//输出
void Show(int* arr, int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main()
{
    void Swap();
	int arr[] = {33,5,6,88,1,0,77};
	QuickSort(arr, 0, sizeof(arr) / sizeof(arr[0])-1);
	Show(arr, sizeof(arr) / sizeof(arr[0]));
	return 0;
}
 
​

 Java版：

package com.example.demo.PC_mode;

import com.sun.org.apache.bcel.internal.generic.SWAP;

public class QuickSort {
    public static void Swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void QS(int[] a, int start, int end) {
        //递归出口
        if (start >= end) return;
        int left = start, right = end, key;
        //假定第一个元素为枢轴值
        key = a[left];
        while (left < right) {
            while (left < right && a[right] >= key) {
                right--;
            }
            while (left < right && a[left] <= key) {
                left++;
            }
            if (left < right) {
                Swap(a, left, right);
            }
        }

        //对初始时选择的基准值与在left=right时的位置进行交换，
        // 确保了左边都比基准值小，右边都比基准值大
        a[start] = a[left];
        a[left] = key;

        for (int s :
                a) {
            System.out.print(s + " ");
        }
        System.out.println();

        QS(a, start, left - 1);
        QS(a, left + 1, end);
    }

    public static void main(String[] args) {
        int[] A = new int[]{2, 1, 4, 5, 7, 3, 2};
        System.out.println("快速排序：");
        System.out.println("排序前");
        for (int a :
                A) {
            System.out.print(a + " ");
        }
        System.out.println();
        System.out.println("排序后");
        QS(A, 0, A.length - 1);
        for (int a :
                A) {
            System.out.print(a + " ");
        }
    }
}