排序算法学习笔记

交换排序

冒泡排序

// 冒泡排序 =======================================
void bubbleSort(int num[], int n) {//【冒泡排序】
    for(int i=0; i < n-1; i++) {// 需要 n-1 次排序
        for(int j=0; j < n-1-i; j++) {
            if(num[j] > num[j+1]) {
                int temp = num[j];
                num[j] = num[j+1];
                num[j+1] = temp;
            }
        }
    }
}

快速排序

// 快速排序 =======================================
//void quickSort(int num[], int left, int right) {//【快速排序】
//    if(left < right) {
//        int temp = num[left];
//        int low = left;
//        int high = right;
//        while(low < high) {
//            while(low < high && num[high] >= temp) {
//                high--;
//            }
//            num[low] = num[high];
//            while(low < high && num[low] < temp) {
//                low++;
//            }
//            num[high] = num[low];
//        }
//        num[low] = temp;
//
//        quickSort(num, left, low-1);
//        quickSort(num, low+1, right);
//    }
//}
int Partition(int num[], int left, int right) {
    int index = left + (right-left>>1);//注意：移位操作的优先级比加减法运算低
    int temp = num[index];
    num[index] = num[left];
    while(left < right) {
        while(left < right && temp <= num[right])
            right--;
        num[left] = num[right];
        while(left < right && temp > num[left])
            left++;
        num[right] = num[left];
    }
    num[left] = temp;
    return left;
}
void quickSort(int num[], int left, int right) {//【快速排序】
    if(left < right) {
        int index = Partition(num, left, right);
        quickSort(num, left, index-1);
        quickSort(num, index+1, right);
    }
}

插入排序

直接插入排序

// 插入排序 =======================================
void insertSort(int num[],int n) {//【直接插入排序】
    for(int i=1; i < n; i++) {
        if(num[i] < num[i-1]) {
            int temp = num[i];
            int j = i-1;
            while(j >=0 && temp < num[j]) {
                num[j+1] = num[j];
                j--;
            }
            num[j+1] = temp;
        }
    }
}

希尔排序

// 希尔排序 =======================================
void shellSort(int num[], int n) {//【希尔排序】
    for(int gap = n/2; gap > 0; gap/=2) {
        for(int i = gap; i < n; i++) {
            if(num[i] < num[i-gap]) {
                int temp = num[i];
                int j = i - gap;
                while(j >= 0 && temp < num[j]) {
                    num[j+gap] = num[j];
                    j -= gap;
                }
                num[j+gap] = temp;
            }
        }
    }
}

选择排序

直接选择排序

// 选择排序 =======================================
void selectSort(int num[], int n) {//【直接选择排序】
    for(int i=0; i < n-1; i++) {// 需要 n-1 次排序，每次从剩余的数中找出最小的那个数，然后和剩余数中的第一个数交换
        int index = i;// 先假设剩余数中第一个数为最小值。index 用于记录剩余数中的那个最小值的索引
        for(int j=i+1; j < n; j++) {
            if(num[j] < num[index]) {
                index = j;
            }
        }

        if(index != i) {// 将剩余数中找到的那个最小值，和剩余数中的第一个数交换
            int temp = num[i];
            num[i] = num[index];
            num[index] = temp;
        }
    }
}

堆排序

// 堆排序 =========================================
void heapAdjust(int num[], int n, int i) {// 调整节点 i
    if(i <= n/2-1 && n != 0) {// 保证是非叶子节点
        int leftChild = 2 * i + 1;// 节点 i 的左孩子
        int rightChild = 2 * i + 2;// 节点 i 的右孩子
        int index = i;
        if(num[index] < num[leftChild]) {
            index = leftChild;
        }
        if(rightChild < n && num[index] < num[rightChild]) {
            index = rightChild;
        }
        if(index != i) {
            int temp = num[i];
            num[i] = num[index];
            num[index] = temp;

            heapAdjust(num, n, index);
        }
    }
}

void heapSort(int num[], int n) {//【堆排序】
    // 构造初始堆。从最后一个非叶子节点开始调整
    for(int i=n/2-1; i >= 0; i--) {
        heapAdjust(num, n, i);
    }

    // 有了初始堆，开始排序
    for(int i=n-1; i >= 1; i--) {
        // 交换堆顶元素和最后一个元素
        int temp = num[0];
        num[0] = num[i];
        num[i] = temp;

        // 重新调整堆顶节点成为大顶堆
        heapAdjust(num, i, 0);
    }
}

归并排序

// 归并排序 =======================================
void mergeArray(int L[], int R[], int first, int middle, int last) {
    int i,k;
    i = k = first;
    int j = middle + 1;
    while(i<=middle && j<=last) {
        if(L[i] <= L[j])
            R[k++] = L[i++];
        else
            R[k++] = L[j++];
    }
    while(i <= middle)
        R[k++] = L[i++];
    while(j <= last)
        R[k++] = L[j++];
    for(i=first; i <=last; i++)
        L[i] = R[i];
}

void MSort(int num[], int temp[], int first, int last) {
    if(first == last)
        temp[first] = num[first];
    else {
        int middle = (first + last) / 2;
        MSort(num, temp, first, middle);
        MSort(num, temp, middle+1, last);
        mergeArray(temp, num, first, middle, last);
    }
}

void mergeSort(int num[], int n) {//【归并排序】
    int* temp = new int[n];
    MSort(num, temp, 0, n-1);
}

各种常用排序算法
类别	排序方法	时间复杂度			空间复杂度	稳定性
		平均情况	最好情况	最坏情况	辅助存储
交换排序	冒泡排序	O(n2)	O(n)	O(n2)	O(1)	稳定
	快速排序	O(nlog2n)	O(nlog2n)	O(n2)	O(logn)	不稳定
插入排序	直接插入	O(n2)	O(n)	O(n2)	O(1)	稳定
	希尔排序	O(n1.3)	O(nlog2n)	O(n2)	O(1)	不稳定
选择排序	直接选择	O(n2)	O(n2)	O(n2)	O(1)	不稳定
	堆排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(1)	不稳定
归并排序		O(nlog2n)	O(nlog2n)	O(nlog2n)	O(n)	稳定
基数排序（桶排序）		O(d(r+n))	O(d(rd+n))	O(d(r+n))	O(rd+n)	稳定
注意：基数排序的复杂度中：r代表关键字的基数，d代表长度，n代表关键字的个数

待续。。。。。。