氣泡排序

void bubbleSort(vector<int> &nums) {
        for (int i = 0; i < nums.size() - 1; ++i) {
            for (int j = 0; j < nums.size() - 1 - i; ++j) {
                if (nums[j] > nums[j + 1])swap(nums[j], nums[j + 1]);
            }
        }
    }

選擇排序

void selectionSort(vector<int> &nums) {
        for (int i = 0; i < nums.size() - 1; ++i) {
            int cur = i;
            for (int j = i + 1; j < nums.size(); ++j) {
                if (nums[j] < nums[cur])cur = j;
            }
            if (i != cur)swap(nums[i], nums[cur]);
        }
    }
 

插入排序

void insertionSort(vector<int> &nums) {
        for (int i = 1; i < nums.size(); ++i) {
            int key = nums[i];
            // 尋找合適的插入位置
            int j = i - 1;
            while (j >= 0 && nums[j] > key) {
                swap(nums[j], nums[j + 1]);
                j--;
            }
            nums[j + 1] = key;
        }
    }
# 歸併排序
```c++
// 歸併操作
void __merge(vector<int> &nums,int l,int mid,int r){
    vector<int>mem(r-l+1,0);
    for(int i=l;i<=r;i++){
        mem[i-l]=num[i];  
    }
    int i=l,j=mid+1;
    for(int k=l;k<=r;k++){
        if(i>mid){
            nums[k]=mem[j++];
        }else if(j>r){
            nums[k]=mem[i++];
        }else if(mem[i]<mem[j]){
            nums[k]=mem[i];
        }else{
            nums[k]=mem[j];
        }
    }
}

void __mergeSort(vector<int> &nums,int l,int r){
    if(l>=r)return;
    int mid=(l+r)>>1;
    __mergeSort(nums,l,mid);
    __mergeSort(nums,mid+1,r);
    __merge(nums,l,mid,r);
}

void mergeSort(vector<int> &nums){
    __mergeSort(nums,0,nums.size()-1);
}
 

快速排序

int partition(vector<int> &nums, int low, int high) {
        int pivot = nums[low];
        while (low < high) {
            // 找到比pivot小的
            while (low < high && nums[high] >= pivot)high--; // 從右到左找到第一個嚴格小於pivot的值（注意嚴格小於！！！）
            nums[low] = nums[high];
            // 找到比pivot大的
            while (low < high && nums[low] <= pivot)low++;
            nums[high] = nums[low];
        }
        nums[low] = pivot;
        return low;
    }

    void quickSort(vector<int> &nums, int low, int high) {
        if (low >= high)return;
        int pivot = partition(nums, low, high);
        quickSort(nums, low, pivot - 1);
        quickSort(nums, pivot + 1, high);
    }

    void quickSort(vector<int> &nums) {
        quickSort(nums, 0, nums.size() - 1);
    }
 

堆排序

void shiftDown(vector<int> &nums, int len, int k) {
        while (2 * k + 1 < len) { // 有左孩子
            int next = 2 * k + 1;
            if (next + 1 < len && nums[next + 1] > nums[next])next++;
            if (nums[k] >= nums[next])break;
            swap(nums[k], nums[next]);
            k = next;
        }
    }

    void heapSort(vector<int> &nums) {
        int len = nums.size();
        // heapify -> 生成最大堆
        int k = (len - 1) / 2;
        while (k >= 0) {
            shiftDown(nums, len, k--);
        }
        // 進行原地排序
        for (int i = len - 1; i > 0; --i) {
            swap(nums[0], nums[i]);
            shiftDown(nums, i, 0);
        }
    }