数据结构和算法——用C语言实现所有排序算法

已于 2023-12-10 01:38:58 修改
阅读量756 收藏 3
点赞数 1
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 c语言 排序算法 外部排序
于 2023-10-27 23:21:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45295475/article/details/129909391
版权

文章目录

前言

本文所有代码均在仓库中，这是一个完整的由纯C语言实现的可以存储任意类型元素的数据结构的工程项目。

在这里插入图片描述

  • 首先是极好的工程意识，该项目是一个中大型的CMake项目，结构目录清晰，通过这个项目可以遇见许多工程问题并且可以培养自己的工程意识。
  • 其次是优秀的封装性（每个数据结构的头文件中只暴漏少量的信息），以及优秀的代码风格和全面的注释，通过这个项目可以提升自己的封装技巧：

在这里插入图片描述

在这里插入图片描述

最后也是最重要的一点，数据结构的通用性和舒适的体验感，下面以平衡二叉树为例：

  • 第一步：要想使用平衡二叉树，只需要引入其的头文件：
#include "tree-structure/balanced-binary-tree/BalancedBinaryTree.h"
  • 第二步：定义自己任意类型的数据，并构造插入数据（以一个自定义的结构体为例）：
#include "tree-structure/balanced-binary-tree/BalancedBinaryTree.h"

int dataCompare(void *, void *);

typedef struct People {
    char *name;
    int age;
} *People;

int main(int argc, char **argv) {
    struct People dataList[] = {
            {"张三", 15},
            {"李四", 3},
            {"王五", 7},
            {"赵六", 10},
            {"田七", 9},
            {"周八", 8},
    };
    BalancedBinaryTree tree = balancedBinaryTreeConstructor(NULL, 0, dataCompare);
    for (int i = 0; i < 6; ++i) {
        balancedBinaryTreeInsert(&tree, dataList + i, dataCompare);
    }
    return 0;
}

/**
 * 根据人的年龄比较
 */
int dataCompare(void *data1, void *data2) {
    int sub = ((People) data1)->age - ((People) data2)->age;
    if (sub > 0) {
        return 1;
    } else if (sub < 0) {
        return -1;
    } else {
        return 0;
    }
}
  • 第三步：打印一下平衡二叉树：
#include "tree-structure/balanced-binary-tree/BalancedBinaryTree.h"

int dataCompare(void *, void *);

void dataPrint(void *);

typedef struct People {
    char *name;
    int age;
} *People;

int main(int argc, char **argv) {
    struct People dataList[] = {
            {"张三", 15},
            {"李四", 3},
            {"王五", 7},
            {"赵六", 10},
            {"田七", 9},
            {"周八", 8},
    };
    BalancedBinaryTree tree = balancedBinaryTreeConstructor(NULL, 0, dataCompare);
    for (int i = 0; i < 6; ++i) {
        balancedBinaryTreeInsert(&tree, dataList + i, dataCompare);
        balancedBinaryTreePrint(tree, dataPrint);
        printf("-------------\n");
    }
    return 0;
}

/**
 * 根据人的年龄比较
 */
int dataCompare(void *data1, void *data2) {
    int sub = ((People) data1)->age - ((People) data2)->age;
    if (sub > 0) {
        return 1;
    } else if (sub < 0) {
        return -1;
    } else {
        return 0;
    }
}

/**
 * 打印人的年龄
 * @param data
 */
void dataPrint(void *data) {
    People people = (People) data;
    printf("%d", people->age);
}

打印的结果如下：

在这里插入图片描述
最后期待大佬们的点赞。

一些约定

  • 本文代码干练简洁、辅助变量命名明确，且均已上机运行通过
  • 待排列表下标从一开始
  • 待排元素可为任意类型，需传入int compare (void * a, void * b)函数用于待排元素的比较：
    • a > b a>b a>b则返回值大于零
    • a = b a=b a=b则返回值等于零
    • a < b a<b a<b则返回值小于零
  • 外部排序模拟代码会在近期补上

排序算法的基本概念

排序算法就是将结构中所有数据按照关键字有序的过程。排序的分类如下：

在这里插入图片描述

评价一个排序算法的指标通常有以下三种：

  • 时间复杂度
  • 空间复杂度
  • 稳定性

其中稳定性是指关键字相同的元素在排序前后相对位置是否改变，如果不变则称该排序算法是稳定的，否则就是不稳定的。

内部排序

插入排序

算法思想：每次将一个待排序的记录按其关键字大小插入前面已排好序的子序列，直到全部记录插入完成。

直接插入排序

  • 算法思想：每次将一个待排序的记录按其关键字大小插入前面已排好序的子序列，直到全部记录插入完成。
  • 时间复杂度： O ( n ) ∼ O ( n 2 ) O(n)\thicksim O(n²) O(n)∼O(n2)
  • 空间复杂度： O ( 1 ) O(1) O(1)
  • 稳定性：稳定
/**
 * 直接插入排序
 * @param dataList
 * @param length
 */
void directInsert(void *dataList[], int length, int (*compare)(void *, void *)) {
    for (int unOrderListIterator = 2; unOrderListIterator <= length; ++unOrderListIterator) {
        void *sortedData = dataList[unOrderListIterator - 1];
        int orderListIterator;
        for (orderListIterator = unOrderListIterator - 1; orderListIterator >= 1 && compare(sortedData, dataList[orderListIterator - 1]) < 0; --orderListIterator) {
            dataList[orderListIterator + 1 - 1] = dataList[orderListIterator - 1];
        }
        dataList[orderListIterator + 1 - 1] = sortedData;
    }
}

折半插入排序

  • 算法思想：在直接插入排序的基础上，用二分查找待排元素的位置。
  • 时间复杂度： O ( n l o g 2 n ) ∼ O ( n 2 ) O(nlog₂n)\thicksim O(n²) O(nlog2​n)∼O(n2)
  • 空间复杂度： O ( 1 ) O(1) O(1)
  • 稳定性：稳定
/**
 * 折半插入排序
 * @param dataList
 * @param length
 */
void binaryInsertSort(void *dataList[], int length, int (*compare)(void *, void *)) {
    for (int unOrderListIterator = 2; unOrderListIterator <= length; ++unOrderListIterator) {
        void *sortedData = dataList[unOrderListIterator - 1];
        int mid, high = unOrderListIterator - 1, low = 1;
        while (low <= high) {
            mid = (high + low) / 2;
            if (compare(dataList[mid - 1], sortedData) > 0) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        for (int orderListIterator = unOrderListIterator; orderListIterator > low; orderListIterator--) {
            dataList[orderListIterator - 1] = dataList[orderListIterator - 1 - 1];
        }
        dataList[low - 1] = sortedData;
    }
}

希尔排序

  • 算法思想：先将待排序列表分割成若干形如 L [ i , i + d , i + 2 d , … , i + k d ] L[i,i+d,i+2d,\dots,i+kd] L[i,i+d,i+2d,…,i+kd]的子表，然后对各个子表分别进行直接插入排序，之后缩小增量 d d d，重复上述过程，直到 d = 1 d=1 d=1。
  • 时间复杂度：无法用数学方法准确表示，当 n n n在某一范围内时间复杂度为 O ( n 1.3 ) O(n^{1.3}) O(n1.3)，最坏的时间复杂度为 O ( n 2 ) O(n²) O(n2)
  • 空间复杂度： O ( 1 ) O(1) O(1)
  • 稳定性：不稳定
/**
 * 希尔排序
 * @param dataList
 * @param length
 * @param compare
 */
void shellSort(void *dataList[], int length, int (*compare)(void *, void *)) {
    for (int p = length / 2; p >= 1; p /= 2) {
        for (int unOrderListIterator = p + 1; unOrderListIterator <= length; ++unOrderListIterator) {
            void *sortedData = dataList[unOrderListIterator - 1];
            int orderListIterator;
            for (orderListIterator = unOrderListIterator - p; orderListIterator >= 1 && compare(sortedData, dataList[orderListIterator - 1]) < 0; orderListIterator -= p) {
                dataList[orderListIterator + p - 1] = dataList[orderListIterator - 1];
            }
            dataList[orderListIterator + p - 1] = sortedData;
        }
    }
}

交换排序

算法思想：根据序列中两个元素关键字的比较结果来对换这两个元素在序列中的位置。

冒泡排序

  • 算法思想：从前往后两两比较相邻两元素的关键字，若为逆序则交换它们，直到序列比较完成，此时最小的元素将被交换到第一个位置，这就是一趟冒泡。只要经过 n − 1 n-1 n−1趟冒泡，待排序列就有序了。
  • 时间复杂度： O ( n ) ∼ O ( n 2 ) O(n)\thicksim O(n²) O(n)∼O(n2)
  • 空间复杂度： O ( 1 ) O(1) O(1)
  • 稳定性：稳定
/**
 * 冒泡排序
 * @param dataList
 * @param length
 * @param compare
 */
void bubbleSort(void *dataList[], int length, int (*compare)(void *, void *)) {
    for (int trip = 1; trip <= length - 1; trip++) {
        bool isSwap = false;
        for (int j = length; j > trip; j--) {
            if (compare(dataList[j - 1], dataList[j - 1 - 1]) < 0) {
                swap(dataList + j - 1, dataList + j - 1 - 1);
                isSwap = true;
            }
        }
        //如果没有交换则序列已有序
        if (!isSwap) {
            break;
        }
    }
}

快速排序

快速排序算法的平均时间复杂度接近最好时间复杂度的排序算法，是最好的内部排序。

  • 算法思想：在待排序列中选择一个元素 p i v o t pivot pivot作为基准，通过一趟排序将序列划分为两部分 L [ 1 , … , k − 1 ] L[1,\dots,k-1] L[1,…,k−1]和 L [ k + 1 , … , n ] L[k+1,\dots,n] L[k+1,…,n]，使得 L [ 1 , … , k − 1 ] L[1,\dots,k-1] L[1,…,k−1]中所有元素小于 p i v o t pivot pivot， L [ k + 1 , … , n ] L[k+1,\dots,n] L[k+1,…,n]中所有元素大于等于 p i v o t pivot pivot。 p i o v t piovt piovt则放在了其最终的位置 L [ k ] L[k] L[k]上，这个过程为一趟快速排序。然后分别递归的对两个部分重复上述过程，直到每部分只有一个元素或空为止。
  • 时间复杂度： O ( n l o g 2 n ) ∼ O ( n 2 ) O(nlog₂n)\thicksim O(n²) O(nlog2​n)∼O(n2)，具体为 O ( n × 递归层数 ) O(n\times 递归层数) O(n×递归层数)
  • 空间复杂度： O ( l o g 2 n ) ∼ O ( n ) O(log₂n)\thicksim O(n) O(log2​n)∼O(n)，具体为 O ( 递归层数 ) O(递归层数) O(递归层数)
  • 稳定性：不稳定
static int partition(void *dataList[], int low, int high, int (*compare)(void *, void *)) {
    void *pivot = dataList[low - 1];
    while (low < high) {
        while (low < high && compare(dataList[high - 1], pivot) > 0) {
            high--;
        }
        dataList[low - 1] = dataList[high - 1];
        while (low < high && compare(dataList[low - 1], pivot) <= 0) {
            low++;
        }
        dataList[high - 1] = dataList[low - 1];
    }
    dataList[low - 1] = pivot;
    return low;
}

/**
 * 快速排序
 * @param dataList 
 * @param low 
 * @param high 
 * @param compare 
 */
void quickSort(void *dataList[], int low, int high, int (*compare)(void *, void *)) {
    if (low < high) {
        int pivotPos = partition(dataList, low, high, compare);
        quickSort(dataList, low, pivotPos - 1, compare);
        quickSort(dataList, pivotPos + 1, high, compare);
    }
}

选择排序

算法思想：每一趟在待排序序列中选择关键字最小或最大的元素加入有序子序列。

简单选择排序

  • 算法思想：第 i i i趟从 L ( i . . . n ) L(i...n) L(i...n)中选择关键字最小的元素与 L ( i ) L(i) L(i)交换，每一趟排序都可以确定一个元素的最终位置。
  • 时间复杂度： O ( n 2 ) O(n²) O(n2)
  • 空间复杂度： O ( 1 ) O(1) O(1)
  • 稳定性：不稳定
/**
 * 简单选择排序
 * @param dataList 
 * @param length 
 * @param compare 
 */
void simpleSelectSort(void *dataList[], int length, int (*compare)(void *, void *)) {
    for (int orderListIterator = 1; orderListIterator < length; ++orderListIterator) {
        int minIndex = orderListIterator;
        for (int unOrderListIterator = orderListIterator + 1; unOrderListIterator <= length; ++unOrderListIterator) {
            if (compare(dataList[unOrderListIterator - 1], dataList[minIndex - 1]) < 0) {
                minIndex = unOrderListIterator;
            }
        }
        if (minIndex != orderListIterator) {
            swap(dataList + orderListIterator - 1, dataList + minIndex - 1);
        }
    }
}

堆排序

当一个序列 L [ 1 , … , n ] L[1,\dots,n] L[1,…,n]满足：

  • L ( i ) > = L ( 2 i ) L(i)>=L(2i) L(i)>=L(2i)且 L ( i ) > = L ( 2 i + 1 ) L(i)>=L(2i+1) L(i)>=L(2i+1)时，称该序列为大顶堆
  • L ( i ) < = L ( 2 i ) L(i)<=L(2i) L(i)<=L(2i)且 L ( i ) < = L ( 2 i + 1 ) L(i)<=L(2i+1) L(i)<=L(2i+1)时，称该序列为小顶堆

可以将堆看成一棵线性存储的完全二叉树：

  • 大顶堆的最大元素存放在根结点，且其任一非根结点的值小于等于其双亲结点的值。
  • 小顶堆的最小元素存放在根结点，且其任一非根结点的值大于等于其双亲结点的值。
  • 在完全二叉树中：
    • 若 i < = ⌊ n / 2 ⌋ i<=⌊n/2⌋ i<=⌊n/2⌋，那么结点 i i i为分支结点，否则为叶子结点。
    • i i i的左孩子 2 i 2i 2i
    • i i i的右孩子 2 i + 1 2i+1 2i+1
    • i i i的父结点 ⌊ i / 2 ⌋ ⌊i/2⌋ ⌊i/2⌋

堆排序首要任务就是先构建一个堆（以大顶堆为例）：

  • 检查所有分支结点的关键字是否满足大顶堆的性质，如果不满足，则用最大孩子的关键字和分支结点的关键字交换，使该分支子树成为大顶堆。之后依次对 ⌊ n / 2 ⌋ − 1 ∼ 1 ⌊n/2⌋-1\thicksim1 ⌊n/2⌋−1∼1位置的分支结点重复以上检查。
  • 若关键字交换破坏了下一级的堆，则采用相同的方式继续往下调整。

堆构建完后就可以进行堆排序了，堆排序的算法思想如下：

  • 每一趟将堆顶元素加入有序子序列（与待排序列中的最后一个元素交换），并将待排元素序列再次调整为大顶堆。
  • 时间复杂度：
    • 建立堆时： O ( n ) O(n) O(n)
    • 排序时： O ( n l o g 2 n ) O(nlog_2n) O(nlog2​n)
    • 整体： O ( n l o g 2 n ) O(nlog₂n) O(nlog2​n)
  • 空间复杂度： O ( 1 ) O(1) O(1)
  • 稳定性：不稳定

如果要在堆中插入或删除元素（以小顶堆为例），那么思想为：

  • 插入元素时，首先将新元素放到堆尾，然后与父结点对比，若新元素比父结点更小，则将两者互换，一直重复此步骤直至新元素无法上升。
  • 删除元素时，首先用堆底元素代替被删除的元素，然后让该元素不断的下坠，直到无法下坠为止。
static void heapAdjust(void **dataList, int rootIndex, int length, int (*compare)(void *, void *)) {
    void *root = dataList[rootIndex - 1];
    //i指向左孩子
    for (int i = 2 * rootIndex; i <= length; i *= 2) {
        //如果右孩子>左孩子，则让i指向右孩子
        if (i < length && compare(dataList[i + 1 - 1], dataList[i - 1]) > 0) {
            i++;
        }
        if (compare(root, dataList[i - 1]) > 0) {
            break;
        } else {
            dataList[rootIndex - 1] = dataList[i - 1];
            //调整完当前子树后接着向下调整，以免上一次的交换破坏了下一级的堆
            rootIndex = i;
        }
    }
    dataList[rootIndex - 1] = root;
}

static void maxHeapBuild(void **dataList, int length, int (*compare)(void *, void *)) {
    for (int i = length / 2; i >= 1; i--) {
        int a = *((int *) dataList[i - 1]);
        heapAdjust(dataList, i, length, compare);
    }
}

/**
 * 堆排序
 * @param dataList
 * @param length
 * @param compare
 */
void heapSort(void **dataList, int length, int (*compare)(void *, void *)) {
    maxHeapBuild(dataList, length, compare);
    for (int i = length; i > 1; i--) {
        swap(dataList + i - 1, dataList + 1 - 1);
        heapAdjust(dataList, 1, i - 1, compare);
    }
}

归并排序

  • 算法思想：将待排序列视为 n n n个有序的子序列，然后两两（或两个以上）归并，得到 ⌈ n / 2 ⌉ ⌈n/2⌉ ⌈n/2⌉个长度为 2 2 2或为 1 1 1的有序序列，然后继续归并，直到合成一个长度为 n n n的有序序列为止。
  • 时间复杂度： O ( n l o g 2 n ) O(nlog₂n) O(nlog2​n)
  • 空间复杂度： O ( n ) O(n) O(n)
  • 稳定性：稳定
static void merge(void *dataList[], int length, int low, int mid, int high, int (*compare)(void *, void *)) {
    void *temp[length];
    int i, j, k;
    for (k = low; k <= high; ++k) {
        temp[k-1] = dataList[k-1];
    }
    for (i = low, j = mid + 1, k = low; i <= mid && j <= high; k++) {
        if (compare(temp[i - 1], temp[j - 1]) < 0) {
            dataList[k - 1] = temp[i - 1];
            i++;
        } else {
            dataList[k - 1] = temp[j - 1];
            j++;
        }
    }
    while (i <= mid) {
        dataList[k - 1] = temp[i - 1];
        k++;
        i++;
    }
    for (; j <= high;) {
        dataList[k - 1] = temp[j - 1];
        k++;
        j++;
    }
}

/**
 * 归并排序
 * @param dataList
 * @param length
 * @param low
 * @param high
 * @param compare
 */
void mergeSort(void *dataList[], int length, int low, int high, int (*compare)(void *, void *)) {
    if (low < high) {
        int mid = (low + high) / 2;
        mergeSort(dataList, length, low, mid, compare);
        mergeSort(dataList, length, mid + 1, high, compare);
        merge(dataList, length, low, mid, high, compare);
    }
}

基数排序

假设长度为 n n n的排序列表中每个结点 a j a_j aj​的关键字由 d d d元组 ( k j d − 1 , k j d − 2 , … , k j 1 , k j 0 ) (k_j^{d-1},k_j^{d-2},\dots,k_j^1,k_j^0) (kjd−1​,kjd−2​,…,kj1​,kj0​)组成，其中 0 ≤ k j i ≤ r − 1 , ( 0 ≤ j < n , 0 ≤ i ≤ d − 1 ) 0\leq k_j^i\leq r-1,(0\leq j<n,0\leq i\leq d-1) 0≤kji​≤r−1,(0≤j<n,0≤i≤d−1)， r r r称为基数。那么基数排序的算法思想为：

  • 初始化：设置 r r r个空队列， Q 0 , Q 1 , … , Q r − 1 Q_0,Q_1,\dots,Q_{r-1} Q0​,Q1​,…,Qr−1​
  • 按照各个关键字位权重递增的次数对 d d d个关键字位分别进行分配和收集
    • 分配：顺序扫描各个元素，若当前处理的关键字位 = x =x =x，则将元素插入 Q x Q_x Qx​队尾
    • 收集：把 Q 0 , Q 1 , … , Q r − 1 Q_0,Q_1,\dots,Q_{r-1} Q0​,Q1​,…,Qr−1​各个队列中的结点依次出队链接
  • 时间复杂度： O ( d ( n + r ) ) O(d(n+r)) O(d(n+r))
  • 空间复杂度： O ( r ) O(r) O(r)
  • 稳定性：稳定

以int dataList[] = {278, 109, 63, 930, 589, 184, 505, 269, 8, 83}为例：

/**
 * 基数排序
 * @param dataList
 * @param length
 * @param maxLength
 */
void radixSort(int dataList[], int length, int maxLength) {
    LinkedQueue queue = linkedQueueConstructor();
    for (int i = 0; i < length; ++i) {
        linkedQueueEnQueue(queue, dataList + i);
    }
    LinkedQueue queue0 = linkedQueueConstructor();
    LinkedQueue queue1 = linkedQueueConstructor();
    LinkedQueue queue2 = linkedQueueConstructor();
    LinkedQueue queue3 = linkedQueueConstructor();
    LinkedQueue queue4 = linkedQueueConstructor();
    LinkedQueue queue5 = linkedQueueConstructor();
    LinkedQueue queue6 = linkedQueueConstructor();
    LinkedQueue queue7 = linkedQueueConstructor();
    LinkedQueue queue8 = linkedQueueConstructor();
    LinkedQueue queue9 = linkedQueueConstructor();
    LinkedQueue queueList[] = {queue0, queue1, queue2, queue3, queue4, queue5, queue6, queue7, queue8, queue9};
    for (int i = 1; i <= maxLength; ++i) {
        while (!linkedQueueIsEmpty(queue)) {
            void *data = linkedQueueDeQueue(queue);
            int key = *(int *) data / (int) pow(10, i - 1) % 10;
            linkedQueueEnQueue(queueList[key], data);
        }
        for (int j = 0; j < 10; ++j) {
            LinkedQueue keyQueue = queueList[j];
            while (!linkedQueueIsEmpty(keyQueue)) {
                linkedQueueEnQueue(queue, linkedQueueDeQueue(keyQueue));
            }
        }
    }
    while (!linkedQueueIsEmpty(queue)) {
        void *data = linkedQueueDeQueue(queue);
        printf("%d,", *(int *) data);
    }
}

在这里插入图片描述

外部排序

多路归并

操作系统以块为单位对磁盘存储空间进行管理，如果要修改磁盘块中的数据，就需要把对应磁盘块的内容读到内存中，在内存中修改后再写回磁盘。在对磁盘数据进行排序时，如果磁盘中的数据过多，那么无法一次将数据全部读到内存中，此时就应该使用外部排序。实现外部排序的思想是使用归并排序的的方法，最少只需要在内存中分配三块大小的缓冲区即可对任意一个大文件进行排序。

在这里插入图片描述
外部排序的步骤如下：

  • 构造归并段：每次将磁盘中两个块的内容读入输入缓冲区中，进行内部排序写到输出缓冲区，当某个输入缓冲区为空时就立即读入磁盘中的下一个段，当输出缓冲区已满时就写入到磁盘中。16个块都排序完后就构造了8个两块长度的初始归并段。
  • 接着继续构造4个4块长度的归并段。
  • 以此类推当只有一个归并段时整个磁盘就变得有序了。

在每次构造归并段时都需要把所有的磁盘块读写一遍，并且还要进行内部排序，因此外部排序的时间开销由以下几部分构成：
外部排序的时间开销 = 读写外存的时间 + 内部排序所需时间 + 内部归并所需的时间 外部排序的时间开销=读写外存的时间+内部排序所需时间+内部归并所需的时间 外部排序的时间开销=读写外存的时间+内部排序所需时间+内部归并所需的时间
其中读写外存的时间是外部排序的主要开销，因此可以使用多路归并的方式来减少归并的趟数从而减少读写外存的次数。若对 r r r个初始归并段做 k k k路归并，则归并树可用 k k k叉树表示，若树高为 h h h，则归并趟数 n n n为：
n = h − 1 = ⌈ l o g k r ⌉ n=h-1=⌈log_kr⌉ n=h−1=⌈logk​r⌉
因此归并路数（增加缓冲区的个数）越多，初始归并段（增加缓冲区的长度）越少，读写磁盘的次数就越少。但多路归并同样存在着问题：

  • 问题一： k k k路归并时，需要开辟 k k k个输入缓冲区，内存开销增大。
  • 问题二：每挑选一个关键字需要对比关键字 k − 1 k-1 k−1次，内部归并所需要的时间增加。

败者树

败者树可视为多一个根结点的完全二叉树， k k k个叶结点分别是当前参加比较的元素，非叶子结点用来记忆左右子树中的失败者，而让胜者往上继续进行比较，一直到根结点。

在这里插入图片描述

可以将败者树用于多路归并从而减少关键字的对比，从而解决问题二。对于 k k k路归并，第一次构造败者树需要对比关键字 k − 1 k-1 k−1次，有了败者树，选出最小元素，只需要对比关键字 ⌈ l o g 2 k ⌉ ⌈log_2k⌉ ⌈log2​k⌉次。

置换——选择排序

对于传统归并段构造的方法，如果用于内部排序的输入缓冲区可容纳 l l l个记录，则每个初始归并段也只能包含 l l l个记录，若文件共有 n n n个记录，则初始归并段的数量为 r = n l r=\frac{n}{l} r=ln​。而置换——选择排序可以构造比内存缓冲区长度长的归并段。置换——选择排序的思想为：

  • 假设输入缓冲区的大小为三，读入代排文件中的三个记录。
  • 每次将缓冲区的最小记录放到归并段一的末尾（并在内存中记录这个最小记录miniMax），接着读入待排文件的下一记录填充输入缓冲区。
  • 若当前缓冲区的最小记录小于miniMax，那么就不可能将其放到归并段一的末尾，此时找到第二小且大于miniMax的记录放到归并段。
  • 当某一时刻输入缓冲区的所有记录都小于miniMax时，第一个初始归并段就构造结束。
  • 接着以同样的方式构造初始归并段二，依次类推直到待排文件为空。

最佳归并树

如果采用置换——选择排序构造初始归并段，并将每一个初始归并段看作一个叶子结点，归并段的长度作为结点的权值，则归并树的带权路径长度 W S L WSL WSL有以下公式成立：
W S L = 读磁盘的次数 = 写磁盘的次数 WSL=读磁盘的次数=写磁盘的次数 WSL=读磁盘的次数=写磁盘的次数

那么 W S L WSL WSL最小的树就是一棵哈夫曼树，从而可以通过构造一棵哈夫曼树以使存盘存取次数最小。在构造哈夫曼树树的过程中，如果初始归并段的数量无法构成严格的 k k k叉哈夫曼树，那么就需要补充长度为0的虚段，再进行构造。对于一棵 k k k叉归并树：

  • 如果 ( 初始归并段的数量 − 1 ) % ( k − 1 ) = 0 (初始归并段的数量-1)\%(k-1)=0 (初始归并段的数量−1)%(k−1)=0，则说明刚好可以构成严格 k k k叉哈夫曼树，此时不需要添加虚段。
  • 如果 ( 初始归并段的数量 − 1 ) % ( k − 1 ) = u ≠ 0 (初始归并段的数量-1)\%(k-1)=u\neq0 (初始归并段的数量−1)%(k−1)=u=0，则需要补充 ( k − 1 ) − u (k-1)-u (k−1)−u个虚段。
亻乍屯页女子白勺
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构与算法学习——好有用C算法文章汇总
weixin_45895718的博客
03-05 170
好有用的C语言算法文章汇总 这篇文章完全是一篇索引文章，都是我觉得通俗易懂且思路清晰明了的，来引用各个大牛的学习心得 KMP算法 KMP算法最浅显理解——一看就明白 qsort算法 当bsearch要查找的key是字符数组 快速排序函数qsort（） 写在最后文章均为转载，感谢大牛们的分享！ ...
【数据结构与算法】汉诺塔算法——C语言递归实现
兰亭风雨的专栏
09-07 9311
汉诺塔的递归实现算法，将A中的圆盘借助B圆盘完全移动到C圆盘上， 每次只能移动一个圆盘，并且每次移动时大盘不能放在小盘上面 递归函数的伪算法为如下: if(n == 1)    直接将A柱子上的圆盘从A移动到C else    先将A柱子上的n-1个圆盘借助C柱子移动到B柱子上    直接将A柱子上的第n个圆盘移动到C柱子上    最后将B柱子上的n-1个圆盘借助A柱子移动到C柱子
C语言实现全排列、环排列问题-深度优先算法
jakercl的博客
07-06 995
1 深度优先算法2.1 全排列问题2.2 代码实现（以5个字符为例） 2.3 代码结果3.1 环排列问题3.2 代码实现 3.3 代码结果如下：
c++ 全排列的实现
ntr851217的博客
08-01 2478
next_permutation到底是做什么的呢？next_permutation是用于求下一个排列,默认是升序排列使用next_permutation需要头文件#include函数原型：那么next_permutation是怎么求下一个排列的呢？其实，next_permutation在求下一个排列的时候，，我们可以根据 next_permutation 的返回值求出全排列例如 "4 3 2 1"就没有下一个排列，它是排名最靠后的.
数据结构——C语言实现直接插入排序算法
Suasuasua的博客
11-27 4323
数据结构——C语言实现直接插入排序算法 一、基本思想        直接插入排序算法是在一个已经有序的记录上，将下一个待排序的数，有序的插入已排好序的记录中，这个过程一直持续到将所有待排数全部插入到有序记录中才停止。 例如，如果将一组数：      2      5      3      7   
排序算法-基于C语言实现的排序算法之BubbleSort实现.zip
03-27
在计算机科学中，排序算法是数据结构领域的重要组成部分，它涉及到如何有效地重新排列一组数据，使其按照特定的顺序（如升序或降序）排列。本项目重点介绍了一种经典的排序算法——冒泡排序（Bubble Sort），并提供...
排序算法-基于C语言实现的排序算法之CombSort实现.zip
03-27
在C语言中，实现各种排序算法是学习数据结构和算法的基础。本资源聚焦于一种相对不那么常见的排序算法——CombSort（梳排序）。 **CombSort算法** CombSort是一种改进的快速排序算法，由Glenn Sheila和Wendy Hall...
经典数据结构算法c语言实现代码（大全）
12-11
N皇后问题回溯算法.txt ping.txt re.txt source.txt winsock2.txt ww.txt 万年历.txt 万年历的算法 .txt 乘方函数桃子猴.txt 乘法矩阵.txt 二分查找1.txt 二分查找2.txt 二叉排序树.txt 二叉树.txt ...
《数据结构与算法分析——C语言描述》随书练习.zip
06-13
《数据结构与算法分析——C语言描述》是计算机科学领域一本经典的教材，主要涵盖了数据结构和算法的基础理论以及实现方法，特别强调了C语言作为实现工具。这本书的随书练习通常包括一系列的问题和编程任务，旨在帮助...
算法与数据结构-C语言版
06-14
在C语言这个强大的编程工具下，我们可以更直观地理解和实现各种算法与数据结构。 一、算法 1. **基础算法**：包括排序（冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序等）和搜索（线性搜索、二分查找...
36. Adam 算法详解
最新发布
qq_41238579的博客
07-10 655
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
D1.排序
2302_79232710的博客
07-07 188
快速排序和归并排序
【力扣】数组中的第K个最大元素
m0_61876562的博客
07-05 301
l, left]（该部分小于基准元素key）、[left + 1, right - 1]（等于基准元素key）、[right, r]（大于基准元素key）。3、计算每部分所包含的元素个数，分别为a 、b = right - left - 1、 c = r - right + 1;请注意，你需要找的是数组排序后的第。你必须设计并实现时间复杂度为。个最大的元素，而不是第。1、随机选择基准元素。
十一、作业
weixin_58543820的博客
07-07 459
计算1/1-1/2+1/3-1/4+1/5 ……+ 1/99 - 1/100 的值，打印出结果。编写程序数一下 1到 100 的所有整数中出现多少个数字9。要求：找到了就打印数字所在的下标，找不到则输出：找不到。写一个代码打印1-100之间所有3的倍数的数字。编写代码在一个整形有序数组中查找具体的某个数。打印1000年到2000年之间的闰年。写代码将三个整数数按从大到小输出。给定两个数，求这两个数的最大公约数。最小公倍数=a*b/最大公约数。在屏幕上输出9*9乘法口诀表。%-2d - 左对齐。
每周算法：无向图的双连通分量
少儿编程乔老师
07-06 1236
通过Tarjan算法求无向连通图的双连通分量，计算至少添加多少条边可以将原图变为一个双连通分量。
【排序 - 堆排序】
2302_80393814的博客
07-10 284
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
【算法笔记自学】第 5 章 入门篇（3）——数学问题
qq_62704693的博客
07-06 1277
【代码】【算法笔记自学】入门篇（3）——数学问题。
算法库应用--Brute - Force算法串匹配(顺序串)
qq_57484399的博客
07-06 912
V1.0: 在原有的博客基础上, 加入我构建的算法库, 让博客更完全 , 代码可以运行看效果, 不是让算法仅仅停留在 逻辑方面, 这也是后续我努力的方向, 把这些算法模型, 尽可能的去运用到实际的嵌入式项目中, 把理论变成实物 , 本次也进行了名字优化, 让逻辑更清晰。利用B-f算法,寻找子串在母串中的位置。
算法力扣刷题 三十二【239. 滑动窗口最大值】
danaaaa的博客
07-05 674
单调队列（自定义一种队列规则）使用场景1.
管理信息化信息化知识数据结构的C语言算法.pdf
12-29
"该资源是关于管理信息化领域中数据结构的C语言算法介绍，包括了对数据结构基础知识的讲解和具体算法的实现。文件包含了从简单的排序算法到线性表操作的各种实例，如交换三个整数的顺序、顺序表的创建、显示和插入...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

亻乍屯页女子白勺

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值