#include<iostream>
#include<vector>

using namespace std;
int Partition(std::vector<int>& L, int low, int high) {
	int pivotkey = L[low];
	while (low < high) {
		while (low<high && L[high]>=pivotkey)
			--high;
		L[low] = L[high];
		while (low<high && L[low]<=pivotkey)
			++low;
		L[high] = L[low];
	}
	L[low] = pivotkey;
	return low;
}
 
void QSort(std::vector<int>& L, int low, int high) {
	if (low < high) {
		int pivotloc = Partition(L, low, high);
		QSort(L, low, pivotloc-1);
		QSort(L, pivotloc+1, high);
	}
}


int main(){
    vector<int> m={11, 99, 33 , 69, 77, 88, 55, 11, 33, 36,39, 66, 44, 22};
    QSort(m,0,13);
    for(int i=0;i<m.size();i++){
        cout<<m[i]<<endl;
    }
    return 0;
}

#include<cstdio>
#include<cstdlib>
#include<ctime>

void swap(int *arr, int i, int j) {
    if (i == j) return;
    arr[i] = arr[i] ^ arr[j];
    arr[j] = arr[i] ^ arr[j];
    arr[i] = arr[i] ^ arr[j];
}

void partition(int *arr, int left, int right, int *help) {
    srand((unsigned int)time(NULL));
    int ind = left + (int)((double)rand() / RAND_MAX * (right - left));
    swap(arr, ind, right);
    int less = left - 1, more = right;
    while (left < more) {
        if (arr[left] < arr[right]) swap(arr, ++less, left++);
        else if (arr[left] == arr[right]) ++left;
        else swap(arr, --more, left);
    }
    swap(arr, more, right);
    help[0] = less + 1;
    help[1] = more;
}

void quickSort(int *arr, int left, int right) {
    if (left >= right) return;
    int help[2];
    partition(arr, left, right, help);
    quickSort(arr, left, help[0] - 1);
    quickSort(arr, help[1] + 1, right);
}

int main() {
    int arr[] = {11, 99, 33 , 69, 77, 88, 55, 11, 33, 36,39, 66, 44, 22};
    int n = sizeof(arr) / sizeof(int);
    quickSort(arr, 0, n - 1);
    for (int i = 0; i < n; ++i) printf("%d\n", arr[i]);
}

//java版本：
public class Main{
    public static void main(String[] args){
        //建立数组
        int[] list = new int[]{11, 99, 33 , 69, 77, 88, 55, 11, 33, 36,39, 66, 44, 22};
        //快速排序
        quickSort(list,0,list.length-1);
        //打印
        for(int i : list){
            System.out.println(i);
        }
    }
    public static void quickSort(int[] list , int start, int end){
        //如果数组大小小于等于1则直接返回
        if(start>=end)return;
        //获取中间值（第一个），设置左右指针
        int midval = list[start];
        int left = start;
        int right = end;
        while(left<right){
            //右指针向左遍历，如果值大于中间值则略过
            while(left<right&&list[right]>midval){
                right--;
            }
            //左指针向右遍历，如果值小于中间值则略过
            while(left<right&&list[left]<=midval){
                left++;
            }
            //如果左右两边都停在了“不合群”的数字上，则将其交换
            if(left<right){
                int tem = list[left];
                list[left] = list[right];
                list[right] = tem;
            }
        }
        //将中间值换到它该在的地方
        list[start] = list[right];
        list[right] = midval;
        //将中间值左右两边再拿去排序
        quickSort(list,start,right-1);
        quickSort(list,right+1,end);
    }
}

def quickpri(a, start, end):
    pivot = start
    j = start + 1
    for i in range(start + 1, end + 1):
        if a[i] <= a[pivot]:
            a[i], a[j] = a[j], a[i]
            j += 1
    a[pivot], a[j - 1] = a[j - 1], a[pivot]
    pivot = j - 1
    #print(a[pivot], a[start:pivot], a[pivot + 1 : end + 1])
    return pivot


def quicksort(a, start, end):
    if start >= end:
        return
    pivot = quickpri(a, start, end)
    quicksort(a, start, pivot - 1)
    quicksort(a, pivot + 1, end)



a = [11, 99, 33, 69, 77, 88, 55, 11, 33, 36, 39, 66, 44, 22]
quicksort(a, 0, 13)
for i in range(0,len(a)):
    print(a[i])

def quick_sort(array):
    # 如果数组为空或只有一个元素，直接返回
    if len(array) <= 1:
        return array
    # 选择第一个元素作为基准
    pivot = array[0]
    # 创建两个空列表，用于存储小于或等于基准和大于基准的元素
    left = []
    right = []
    # 遍历除了基准以外的元素，根据大小放入相应的列表
    for i in range(1, len(array)):
        if array[i] <= pivot:
            left.append(array[i])
        else:
            right.append(array[i])
    # 对左右两个列表递归地进行快速排序，并将结果拼接起来
    return quick_sort(left) + [pivot] + quick_sort(right)


# 测试
array = [11, 99, 33, 69, 77, 88, 55, 11, 33, 36, 39, 66, 44, 22]
sorted_array = quick_sort(array)
for i in sorted_array:
    print(i)
# print(sorted_array)

ls=[11, 99, 33 , 69, 77, 88, 55, 11, 33, 36,39, 66, 44, 22]

for i in range(n):
    l = i
    r = n - 1
    while l<r:
        if ls[i] <= ls[l]:
            l+=1
        else:
            ls[i], ls[l] = ls[l], ls[i]
            
        if ls[l] <= ls[r]: 
            r-=1
        else:
            ls[l], ls[r] = ls[r], ls[l]
for i in ls:
    print(i)

l=[11, 99, 33 , 69, 77, 88, 55, 11, 33, 36,39, 66, 44, 22]
l.sort()
for i in l:
    print(i)

C++模板#

#include <iostream>
using namespace std;
int A[14]={11, 99, 33 , 69, 77, 88, 55, 11, 33, 36,39, 66, 44, 22};
 void quick_sort(int A[],int l,int r){
     if(l>=r) return;
     int i=l-1;int j=r+1;
     while(i<j){
             do ++i;while(A[i]<A[(l+r)/2]);
             do --j;while(A[j]>A[(l+r)/2]);
             if(i<j){
                 int temp=A[i];
                 A[i]=A[j];
                 A[j]=temp;
             }
        }
         quick_sort(A, l, j);
         quick_sort(A, j+1, r);
 }
int main(){
    quick_sort(A, 0, 13);
     for(int i=0;i<14;i++){
        printf("%d\n",A[i]);
    }
    return 0;
}