常用数据结构之排序算法总结

今天了整理排序算法的基本实现，主要是复习之前学过的排序算法

声明：红色表明的算法为必须掌握

首先是二路归并排序

/*
     * 二路归并排序
     * 思路：利用分治思想，对原数组进行二分分段，使元素在每一小段内有序，然后逐渐合并
     * 如，最小分段是2，先2内有序，合并为4,4内有序。。。。
     *
     * 时间复杂度：O(nlogn)
     * 空间复杂度：O(n)需要一个额外的数组作为临时存储
     */
    static void mergeSort(int array[], int helper[], int left, int right) {
        if (left >= right)
            return;
        int mid = (left + right) / 2;
        mergeSort(array, helper, left, mid);
        mergeSort(array, helper, mid + 1, right);

        int helperLeft = left;
        int helperRight = mid + 1;
        int cur = left;
        for (int i = left; i <= right; i++) {
            helper[i] = array[i];
        }
        while (helperLeft <= mid && helperRight <= right) {
            if (helper[helperLeft] <= helper[helperRight])
                array[cur++] = helper[helperLeft++];
            else
                array[cur++] = helper[helperRight++];
        }
        while (helperLeft <= mid)
            array[cur++] = helper[helperLeft++];
    }

接着是快速排序

/*
     * 快速排序
     * 思路：先选择一个哨兵元素，然后后往前遍历，遇到比哨兵小的元素停止，从前往后进行遍历，
     * 遇到比哨兵元素大的元素停止，交换两个元素，继续，直到前后相遇，此时交换相遇点的元素
     * 和哨兵元素，一趟排序下来，可以确保哨兵元素左边的元素比哨兵小，右边的元素比哨兵大（升序排序）；
     * 然后分区间再继续上述过程
     * 注意：通常选取左边界作为哨兵元素，此时，必定先进行从后往前的移动，否则不对称缺项会出错
     *
     * 时间复杂度：平均O(nlogn) 最差O(n^2)
     * 空间复杂度：O(logn)交换时需要一个额外的空间，一共交换logn次
     */
    static void quickSort(int array[], int left, int right) {
        if (left >= right)
            return;
        int pivot = array[left];
        int i = left;
        int j = right;
        while (i != j) {
            while (array[j] >= pivot && j > i)
                j--;
            while (array[i] <= pivot && i < j)
                i++;
            if (i < j) {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }
        array[left] = array[i];
        array[i] = pivot;

        quickSort(array, left, i - 1);
        quickSort(array, i + 1, right);
    }

接着是堆排序

/*
     * 堆排序
     */
    //调整堆，larger=true大顶堆，否则为小顶堆
    static void adjustHeap(int array[], int parent, int length, bool large) {
        int pivot = array[parent]; //保存当前父节点
        int child = 2 * parent + 1; //获取左孩子
        while (child < length) {
            if (large) {
                //大顶堆
                //如果有右孩子，且右孩子大于左孩子，选取有孩子节点
                if (child + 1 < length && array[child] < array[child + 1])
                    child++;
                // 如果父节点的值已经大于孩子节点的值，则直接结束
                if (array[parent] >= array[child])
                    break;
            } else {
                //如果有右孩子，且右孩子小于左孩子，选取右孩子节点
                if (child + 1 < length && array[child] > array[child + 1])
                    child++;
                //如果父节点的值已经小于孩子节点的值，则直接结束
                if (array[parent] < array[child])
                    break;
            }
            //把孩子节点的值赋给父节点
            array[parent] = array[child];
            //选取孩子节点的左孩子节点，继续向下筛选
            parent = child;
            child = child * 2 + 1;
　　　　　　　array[parent] = pivot;　
        }
    }
    /*
     * 初始化堆
     * 调整之后，第一个元素为序列的极值
     */
    static void buildHeap(int array[], int length, bool large) {
        for (int i = (length - 1) / 2; i >= 0; --i)
            adjustHeap(array, i, length, large);
    }
    /*
     * 初次建堆时间复杂度O(n)
     * 调整一次的时间为O(logn),一共调整n次
     * 时间复杂度为O(nlogn)
     * 空间复杂度O(1)
     */
    static void heapSort(int array[], int length, bool increase) {
        bool large;
        if (increase) {
            large = true;
        } else {
            large = false;
        }
        buildHeap(array, length, large);
        print(array, length);
        //将极值逐渐放到队尾，剩下元素重新调整
        for (int i = length - 1; i > 0; i--) {
            int temp = array[i];
            array[i] = array[0];
            array[0] = temp;
            adjustHeap(array, 0, i, large);
            print(array, length);
        }
    }

接着是直接插入排序

/*
     * 直接插入排序
     * 思路：由第二个元素开始，从前向后遍历，如若当前元素比前一个元素小，则将
     * 当前元素设为哨兵元素，保存当前元素，从当前位置向前扫描，寻找哨兵元素应该插入的位置，
     * 前面的元素依次后移，找到直接插入。然后继续上述过程
     * 时间复杂度：O(n^2)
     * 空间复杂度：O(1)
     */
    static void directInsertSort(int array[], int length) {
        //升序版本
        for (int i = 1; i < length; i++) {
            if (array[i] < array[i - 1]) {                //找到小数
                int j = i - 1;
                int pivot = array[i];                //复制小数为哨兵元素
                array[i] = array[i - 1];                //先进行一次后移
                while (pivot < array[j] && j >= 0) {                //寻找小数插入位置
                    array[j + 1] = array[j];
                    j--;
                }
                array[j + 1] = pivot;
            }
        }
    }

接着是二分插入排序

/*
     * 二分插入排序
     * 是直接插入排序的改进，主要体现在寻找哨兵元素插入位置时，使用了二分查找
     * 因为哨兵之前的元素一定是已经排序的，所以可以使用二分查找
     */
    static void binaryInsertSort(int array[], int length) {
        for (int i = 1; i < length; i++) {
            if (array[i] < array[i - 1]) {                //找到小数
                int pivot = array[i];                //复制小数为哨兵元素
                int low = 0;
                int high = i - 1;
                int mid = 0;

                while (low <= high) {
                    mid = (low + high) / 2;
                    if (pivot >= array[mid]) {
                        low = mid + 1;
                    } else {
                        high = mid - 1;
                    }
                }
                int j = i;
                //low位置就是要插入的位置,所以low到i之间的元素都需要往后移动一个位置
                while (j > low) {                //寻找小数插入位置
                    array[j] = array[j - 1];
                    j--;
                }
                array[low] = pivot;
            }
        }
    }

接着是二路插入排序

/*
     *    二路插入排序
     *    思路：创建一个辅助数组，将此数组当成一个环，环头存最小元素，环尾存最大元素
     *    如果待插入元素比当前最小的元素小，则插入最小元素之前，更新head
     *    如果待插入元素比当前最大的元素大，则插入最大元素之后，更新tail
     *    如果在最大最小之间，需要由后向前遍历，并依次向后移动，寻找插入点，插入
     *    最后，将环顺序复制并转化为正常顺序
     */
    static void twoInsertSort(int array[], int length) {
        //升序版本
        int head = 0;                //头指针 小元素
        int tail = 0;                //尾指针 大元素
        int cur = 0;
        int *helper = new int[length];
        helper[0] = array[0];
        for (int i = 1; i < length; i++) {
            if (array[i] < helper[head]) {                //待插入的元素比最小的元素小
                head = (head - 1 + length) % length;
                helper[head] = array[i];
            } else if (array[i] > helper[tail]) {                //待插入的元素比最大的大
                tail = (tail + 1 + length) % length;
                helper[tail] = array[i];
            } else {                //待插入的元素比最小的大，比最大的小
                cur = (tail + 1 + length) % length;
                //由后向前遍历，寻找当前元素插入点
                while (helper[(cur - 1 + length) % length] > array[i]) {
                    helper[(cur + length) % length] = helper[(cur - 1 + length)
                            % length];
                    cur = (cur - 1 + length) % length;
                }
                //插入元素
                helper[(cur + length) % length] = array[i];
                tail = (tail + 1 + length) % length;
            }
        }
        for (cur = 0; cur < length; cur++) {
            array[cur] = helper[(head + cur) % length];
        }
        delete[] helper;
    }

接着是希尔排序

/*
     * shell排序（缩小增量排序）
     * 思路：以一定间隔对数组进行分组，在组上进行直接插入排序，使之有序，之后缩小间隔，
     * 重复上述过程
     * 时间复杂度：O(n^1.5)
     * 空间复杂度：O(1)
     */
    static void shellSort(int array[], int length) {
        int gap = length / 2;
        while (gap >= 1) {
            //距离间隔gap为一组，遍历所有组
            for (int i = gap; i < length; i++) {
                if (array[i] < array[i - gap]) {
                    int j = i - gap;
                    int x = array[i];
                    array[i] = array[j];
                    //寻找x在当前序列上的插入点
                    while (x < array[j] && j >= 0) {
                        array[j + gap] = array[j];
                        j -= gap;
                    }
                    array[j + gap] = x;
                }
            }
            print(array, length);
            gap /= 2;
        }
    }

接着是直接选择排序

/*
     * 直接选择排序
     * 思路：(1)从待排序序列中，找到关键字最小的元素；
     * (2)如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；
     * (3)从余下的 N - 1 个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束。
     * 时间复杂度：O(n^2)
     * 空间复杂度：O(1)
     */
    static void selectSort(int array[], int length) {
        for (int i = 0; i < length; i++) {
            for (int j = i + 1; j < length; j++) {
                if (array[i] > array[j]) {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
    }

改进版的--两路选择排序

/*
     * 两路选择排序
     * 思路：外循环确定当前元素位置（头和尾），内循环遍历剩下元素并记录最大值和最小值的位置
     * 最后交换最值与当前元素
     */
    static void selectTwoSort(int array[], int length) {
        for (int i = 0; i <= length / 2; i++) {
            int min = i, max = i;
            for (int j = i + 1; j < length - i; j++) {
                if (array[j] >= array[max]) {
                    max = j;
                    continue;
                }
                if (array[j] < array[min]) {
                    min = j;
                }
            }
            int temp = array[i];
            array[i] = array[min];
            array[min] = temp;
            temp = array[length - i - 1];
            array[length - i - 1] = array[max];
            array[max] = temp;
        }
    }

接着是冒泡排序

    /*
     * 冒泡排序
     * 思路：每次内循环使相邻元素有序，单次循环后最大值沉底（升序时）
     * 之后缩短内循环范围，继续上述操作，但是 有个问题，太冗杂
     * 时间复杂度：O(N^2)
     * 空间复杂度：O(1)
     */
    static void bubbleSort(int array[], int length) {
        for (int i = 0; i < length - 1; i++) {
            for (int j = 0; j < length - i - 1; j++) {
                if (array[j] > array[j + 1]) {
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
            print(array, length);
        }
    }

冒泡改进1

/*
     * 改进冒泡1
     * 思路：设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。
     * 由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可
     */
    static void bubbleSort1(int array[], int length) {
        int i = length - 1;
        while (i > 0) {
            int pos = 0;
            for (int j = 0; j < i; j++) {
                if (array[j] > array[j + 1]) {
                    pos = j;
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
            i = pos;
            print(array, length);
        }
    }

冒泡改进2

/*
     * 改进冒泡2
     * 思路：进行两个方向的冒泡，以升序为例，正方向上下沉最大值，逆方向上上浮最小值
     * 范围是在不断缩小的
     */
    static void bubbleSort2(int array[], int length) {
        int low = 0;
        int high = length - 1;
        int j, temp;
        int pos = 0;
        while (low < high) {
            for (j = low; j < high; j++) {
                if (array[j] > array[j + 1]) {
                    pos = j;
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
            high = pos;
            for (j = high; j > low; --j) {
                if (array[j] < array[j - 1]) {
                    pos = j;
                    temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                }
            }
            low = pos;
            print(array, length);
        }
    }

桶排序

/*
     * 桶排序
     * 思路：
     */
    static void bucketSort(int array[], int length, int max) {
        int *tempArray = new int[length];
        int i;
        for (i = 0; i < length; i++)
            tempArray[i] = array[i];
        int *count = new int[max];
        memset(count, 0, max * sizeof(int));

        for (i = 0; i < length; i++) {
            count[array[i]]++;
        }
        for (i = 1; i < max; i++)
            count[i] = count[i - 1] + count[i];
        for (i = length - 1; i >= 0; i--) {
            array[--count[tempArray[i]]] = tempArray[i];
        }
    }

基数排序

/*
     * 基数排序
     * 思路：由低位到高位，分别用桶排序使之有序
     */
    //得到最大数的位数
    static int getMaxNums(int a[], int n) {
        int max = ~0;
        for (int i = 0; i < n; i++) {
            if (a[i] > max) {
                max = a[i];
            }
        }
        int j = 1;
        while (max >= 10) {
            j++;
            max /= 10;
        }
        return j;
    }
    //得到某位上的数字，最大支持5位
    static int getDigit(int x, int d) {
        int temp[] = { 1, 10, 100, 1000, 10000 };
        return ((x / temp[d - 1]) % 10);
    }
    //radix always equal 10, as 10 radix
    static void radixSort(int a[], int n, int radix) {
        int *count = new int[radix];
        int *bucket = new int[n];
        int digits = getMaxNums(a, n);

        int i = 0, j = 0;
        //从低位到高位排序
        for (int d = 1; d <= digits; d++) {
            for (i = 0; i < radix; i++) {
                count[i] = 0;
            }
            //统计各个桶要装入数据的个数
            for (i = 0; i < n; i++) {
                j = getDigit(a[i], d);
                count[j]++;
            }
            // count[i]表示第i个桶的右边界索引,将桶映射到数组
            // 表明当前界限之前有多少个元素要入桶，累加的意图就是为前面小元素空位
            // count[j]-count[j-1]就代表 j桶中元素的个数
            //--|---|----|-----|
            for (i = 1; i < radix; i++) {
                count[i] = count[i] + count[i - 1];
            }
            // 将数据依次装入桶中
            // 这里要从右向左扫描，保证排序稳定性
            for (i = n - 1; i >= 0; i--) {
                j = getDigit(a[i], d);
                bucket[count[j] - 1] = a[i];            //根据索引，得到桶对应数组的位置，从后向前
                count[j]--;
            }
            for (i = 0; i < n; i++) {
                a[i] = bucket[i];
            }
            print(a, n);
        }
        delete[] count;
        delete[] bucket;
    }

外排序 在大数据排序方面用的比较多，目的是减少内存使用，但是io频率有点高，为了解决这个问题，可以为io添加buff

/*
     * 外排序
     * 思路：首先对大文件分割，并排序存到小文件中。
     * 打开所有小文件，每个文件打开时读入第一个数，数来自哪个文件也要记录，填满buf（buf大小和文件个数一致），
     * 对buf建立最小堆，将堆顶数据写入输出文件，并从堆顶元素来自的文件补充一个元素，重新建堆，重复上述。
     * 直到写出的数据个数和总个数相等时，结束
     */
#include <stdio.h>
#include <time.h>
#include <math.h>
    //在文件中随机产生m个数据，每个一行
    static void OutSortGenData(char *fileName, int m) {
        FILE *fp = fopen(fileName, "w");
        if (fp == NULL) {
            printf("open file failed \n");
            exit(-1);
        }
        srand(time(0));
        for (int i = 0; i < m; i++) {
            int temp = (rand() << 15) | rand();    //rand一般产生15位随机数(32767)，扩展成30位
            fprintf(fp, "%d\n", temp);
        }
        fclose(fp);
    }
    static void OutSortSplit(char *fileName, int m, int n) {
        FILE *in = fopen(fileName, "r");
        int *buf = (int *) malloc(sizeof(int) * n);
        int k = ceil(double(m) / n);
        for (int i = 0, j; i < k; i++) {
            for (j = 0; j < n; j++) {
                if (fscanf(in, "%d", buf + j) != 1)
                    break;
            }
            int num = j;
            quickSort(buf, 0, num - 1);
            char tempfile[20];
            sprintf(tempfile, "./res/tempfile_%d.txt", i);
            FILE *out = fopen(tempfile, "w");
            for (j = 0; j < num; j++) {
                fprintf(out, "%d\n", buf[j]);
            }
            fclose(out);
        }
        free(buf);
    }
    typedef struct ospair {
        int num;
        int pos;
    } OPair;
    static void OutSortAdjust(OPair a[], int parent, int length) {
        OPair temp = a[parent]; //保存当前父节点
        int child = 2 * parent + 1; //获取左孩子
        while (child < length) {
            /*****小顶堆********/
            //如果有有孩子，且右孩子小于做孩子，选取右孩子节点
            if (child + 1 < length && a[child].num > a[child + 1].num) {
                child++;
            }
            // 如果父结点的值已经小于孩子结点的值，则直接结束
            if (a[parent].num < a[child].num) {
                break;
            }
            // 把孩子结点的值赋给父结点
            a[parent] = a[child];
            // 选取孩子结点的左孩子结点,继续向下筛选
            parent = child;
            child = 2 * child + 1;
        }
        a[parent] = temp;
        //PrintHeapSort(a, length);
    }
    /**
     * 初始堆进行调整
     * 将H[0..length-1]建成堆
     * 调整完之后第一个元素是序列的最小的元素
     */
    static void OutSortBuildHeap(OPair a[], int length) {
        for (int i = (length - 1) / 2; i >= 0; --i) {
            OutSortAdjust(a, i, length);
        }
    }
    static void OutSortMerge(char *outfile, int m, int n) {
        FILE *out = fopen(outfile, "w");
        int k = ceil((double) m / n);
        OPair *buf = (OPair *) malloc(sizeof(OPair) * k);
        FILE **fp = (FILE **) malloc(sizeof(FILE*) * k);
        for (int i = 0; i < k; i++) {
            *(fp + i) = (FILE*) malloc(sizeof(FILE));
            char tempfile[20];
            sprintf(tempfile, "./res/tempfile_%d.txt", i);
            fp[i] = fopen(tempfile, "r");
            int tem;
            fscanf(fp[i], "%d", &tem);
            buf[i].num = tem;
            buf[i].pos = i;
        }
        OutSortBuildHeap(buf, k);
        int nums = 0;
        while (1) {
            int minNum = buf[0].num;
            int minPos = buf[0].pos;
            if (nums == m)
                break;
            fprintf(out, "%d\n", minNum);
            int tem;
            fscanf(fp[minPos], "%d", &tem);
            buf[0].num = tem;
            OutSortBuildHeap(buf, k);
            nums++;
        }
        for (int i = 0; i < k; i++) {
            fclose(fp[i]);
            free(fp[i]);
        }
        free(*fp);
        free(buf);
        fclose(out);
    }
    static void OutSortTest() {
        char src[] = "./res/data.txt";
        char result[] = "./res/out.txt";
        int m = 200, n = 20;
        OutSortGenData(src, m);
        OutSortSplit(src, m, n);
        OutSortMerge(result, m, n);
    }

公共代码部分

static void print(int array[], int size) {
        for (int i = 0; i < size; i++) {
            cout << array[i] << " ";
        }
        cout << endl;
    }
    static void test() {
        int array[] = { 21, 40, 300, 101, 3, 2227, 22346, 10000 };
        int size = sizeof(array) / sizeof(array[0]);
        int *helper = new int[size];
//        mergeSort(array, helper, 0, size - 1);
//        quickSort(array, 0, size - 1);
//        heapSort(array, size, false);
//        directInsertSort(array, size);
//        binaryInsertSort(array, size);
//        twoInsertSort(array, size);
//        shellSort(array, size);
//        selectSort(array, size);
//        selectTwoSort(array, size);
//        bubbleSort(array, size);
//        bubbleSort1(array, size);
//        bubbleSort2(array, size);
//        bucketSort(array, size, 8);//max 需要大于数组里最大值
//        radixSort(array, size, 10);
        OutSortTest();
        print(array, size);
    }

 附一张网上整理的时间复杂度的对比

 

文件