冒泡&快排&堆排序

不稳定：快排，选择排序，希尔排序，堆排序 （快选希堆）

冒泡排序（n^2,稳定）

//冒泡排序（稳定）
void bubble_sort(vector<int> &nums) {
    int size = nums.size();
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (nums[j] > nums[j+1]) {
                swap(nums[j], nums[j+1]);
            }
        }
    }
}

冒泡排序

void bubble(int* arr, int n) {
    for (int i = 0; i < n - 1; i++) {
        if (arr[i] > arr[i + 1]) {
            int temp = arr[i];
            arr[i] = arr[i + 1];
            arr[i + 1] = temp;
        }
    }
}
void bubbleSort(int* arr, int n) {
    for (int i = n; i > 0; i--) {
        bubble(arr, i);
    }
}

快排（nlogn,不稳定）

//快速排序（不稳定）
int getStandard(vector<int> &nums, int low, int high) {
    int key = nums[low];
    while(low < high) {
        while (low < high && nums[high] >= key) {
            high--;
        }
        if (low < high) {
            nums[low] = nums[high];
        }
        while(low < high && nums[low] <= key) {
            low++;
        }
        if (low < high) {
            nums[high] = nums[low];
        }
    }
    nums[low] = key;
    return low;
}
void quick_sort(vector<int> &nums, int low, int high) {
    if (low < high) {
        int privot = getStandard(nums, low, high);
        quick_sort(nums, low, privot-1);
        quick_sort(nums, privot+1, high);
    }
}

堆排序（nlogn,不稳定）

//堆排序（选择排序，不稳定）
//1.建堆 2.调整堆
//a->待调整的堆；pos->待调整的数组元素的位置；len->数组的长度
void heapAdjust(vector<int>& a, int pos, int len) {
    int temp = a[pos];
    for (int i = 2*pos+1; i < len; pos = i, i = 2*i+1) {
        if (i+1 < len && a[i+1] < a[i]) {
            i++;
        }
        if (temp > a[i]) {
            a[pos] = a[i];
        } else {
            break;
        }
    }
    a[pos] = temp;
}
//初始堆调整，调整完第一个元素是序列的最小元素
void buildHeap(vector<int>& a, int len) {
    //最后一个有孩子的节点位置是i = (len - 1) / 2;
    for (int i = (len - 1) / 2; i >= 0; i--) {
        heapAdjust(a, i, len);
    }
}
void heapsort(vector<int>& a) {
    int len = a.size();
    buildHeap(a, len);
    //从最后一个元素对序列进行调整
    for (int i = len - 1; i > 0; i--) {
        //交换堆顶元素a[0]和堆中最后一个元素
        int temp = a[i];
        a[i] = a[0];
        a[0] = temp;
        //交换完要对堆进行调整
        heapAdjust(a, 0, i);
    }
}

归并排序：

void merge(int* arr, int l, int r, int mid) {
    int aux[r-l+1];
    int i,j,k;
    i = l;
    j = mid+1;
    k = 0;
    while (i <= mid && j <= r) {
        if (arr[i] < arr[j]) {
            aux[k++] = arr[i++];
        } else {
            aux[k++] = arr[j++];
        }
    }
    while (i <= mid) {
        aux[k++] = arr[i++];
    }
    while (j <= r) {
        aux[k++] = arr[j++];
    }
    for (i = 0; i < r - l + 1; i++) {
        arr[i+l] = aux[i];
    }
}

void mergeSort(int* arr, int l, int r) {
    if (l < r) {
        int mid = l + ((r - l) >> 1);
        mergeSort(arr, l, mid);
        mergeSort(arr, mid+1, r);
        merge(arr, l, r, mid);
    }
}

选择排序：

// 从长度为n的arr数组中找到最大值的下标
int findMaxPos(int* arr, int n) {
    int max = arr[0];
    int pos = 0;
    for (int i = 1; i < n; i++) {
        if (arr[i] > max) {
            max = arr[i];
            pos = i;
        }
    }
    return pos;
}
void selectSort(int* arr, int n) {
    while (n > 1) {
        int pos = findMaxPos(arr, n);
        int temp = arr[pos];
        arr[pos] = arr[n-1];
        arr[n-1] = temp;
        n--;
    }
}

插入排序：

//将arr[n]插到合适的位置
void insert(int* arr, int n) {
    int key = arr[n];
    int i = n;
    while(arr[i-1] > key) {
        arr[i] = arr[i-1];
        i--;
        if (i == 0) {
            break;
        }
    }
    arr[i] = key;
}
void insertSort(int* arr, int n) {
    for (int i = 1; i < n; i++) {
        insert(arr, i);
    }
}