笨办法学C 练习33：链表算法

时间  2019-12-31
标签 办法 练习 链表 算法 栏目 C&C++ 繁體版
原文   原文链接

练习33：链表算法

原文：Exercise 33: Linked List Algorithmshtml

译者：飞龙git

我将想你介绍涉及到排序的两个算法，你能够用它们操做链表。我首先要警告你，若是你打算对数据排序，不要使用链表，它们对于排序十分麻烦，而且有更好的数据结构做为替代。我向你介绍这两种算法只是由于它们难以在链表上完成，而且让你思考如何高效操做它们。github

为了编写这本书，我打算将算法放在两个不一样的文件中，list_algos.h和list_algos.c，以后在list_algos_test.c中编写测试。如今你要按照个人结构，由于它足以把事情作好，可是若是你使用其它的库要记住这并非通用的结构。算法

这个练习中我打算给你一些额外的挑战，而且但愿你不要做弊。我打算先给你单元测试，而且让你打下来。以后让你基于它们在维基百科中的描述，尝试实现这个两个算法，以后看看你的代码是否和个人相似。编程

冒泡排序和归并排序

互联网的强大之处，就是我能够仅仅给你冒泡排序和归并排序的连接，来让你学习它们。是的，这省了我不少字。如今我要告诉你如何使用它们的伪代码来实现它们。你能够像这样来实现算法：数据结构

  • 阅读描述，而且观察任何可视化的图表。函数

  • 使用方框和线条在纸上画出算法，或者使用一些带有数字的卡片（好比扑克牌），尝试手动执行算法。这会向你形象地展现算法的执行过程。性能

  • 在list_algos.c文案总建立函数的主干，而且建立list_algos.h文件，以后建立测试代码。单元测试

  • 编写第一个测试而且编译全部东西。学习

  • 回到维基百科页面，复制粘贴伪代码到你建立的函数中（不是C代码）。

  • 将伪代码翻译成良好的C代码，就像我教你的那样，使用你的单元测试来保证它有效。

  • 为边界状况补充一些测试，例如空链表，排序号的链表，以及其它。

  • 对下一个算法重复这些过程并测试。

我只是告诉你理解大多数算法的秘密，直到你碰到一些更加麻烦的算法。这里你只是按照维基百科来实现冒泡排序和归并排序，它们是一个好的起始。

单元测试

下面是你应该经过的单元测试：

#include "minunit.h"
#include <lcthw/list_algos.h>
#include <assert.h>
#include <string.h>

char *values[] = {"XXXX", "1234", "abcd", "xjvef", "NDSS"};
#define NUM_VALUES 5

List *create_words()
{
    int i = 0;
    List *words = List_create();

    for(i = 0; i < NUM_VALUES; i++) {
        List_push(words, values[i]);
    }

    return words;
}

int is_sorted(List *words)
{
    LIST_FOREACH(words, first, next, cur) {
        if(cur->next && strcmp(cur->value, cur->next->value) > 0) {
            debug("%s %s", (char *)cur->value, (char *)cur->next->value);
            return 0;
        }
    }

    return 1;
}

char *test_bubble_sort()
{
    List *words = create_words();

    // should work on a list that needs sorting
    int rc = List_bubble_sort(words, (List_compare)strcmp);
    mu_assert(rc == 0, "Bubble sort failed.");
    mu_assert(is_sorted(words), "Words are not sorted after bubble sort.");

    // should work on an already sorted list
    rc = List_bubble_sort(words, (List_compare)strcmp);
    mu_assert(rc == 0, "Bubble sort of already sorted failed.");
    mu_assert(is_sorted(words), "Words should be sort if already bubble sorted.");

    List_destroy(words);

    // should work on an empty list
    words = List_create(words);
    rc = List_bubble_sort(words, (List_compare)strcmp);
    mu_assert(rc == 0, "Bubble sort failed on empty list.");
    mu_assert(is_sorted(words), "Words should be sorted if empty.");

    List_destroy(words);

    return NULL;
}

char *test_merge_sort()
{
    List *words = create_words();

    // should work on a list that needs sorting
    List *res = List_merge_sort(words, (List_compare)strcmp);
    mu_assert(is_sorted(res), "Words are not sorted after merge sort.");

    List *res2 = List_merge_sort(res, (List_compare)strcmp);
    mu_assert(is_sorted(res), "Should still be sorted after merge sort.");
    List_destroy(res2);
    List_destroy(res);

    List_destroy(words);
    return NULL;
}


char *all_tests()
{
    mu_suite_start();

    mu_run_test(test_bubble_sort);
    mu_run_test(test_merge_sort);

    return NULL;
}

RUN_TESTS(all_tests);

建议你从冒泡排序开始，使它正确，以后再测试归并。我所作的就是编写函数原型和主干，让这三个文件可以编译，但不能经过测试。以后你将实现填充进入以后才可以工做。

实现

你做弊了吗？以后的练习中，我只会给你单元测试，而且让本身实现它。对于你来讲，不看这段代码知道你本身实现它是一种很好的练习。下面是list_algos.c和list_algos.h的代码：

#ifndef lcthw_List_algos_h
#define lcthw_List_algos_h

#include <lcthw/list.h>

typedef int (*List_compare)(const void *a, const void *b);

int List_bubble_sort(List *list, List_compare cmp);

List *List_merge_sort(List *list, List_compare cmp);

#endif
#include <lcthw/list_algos.h>
#include <lcthw/dbg.h>

inline void ListNode_swap(ListNode *a, ListNode *b)
{
    void *temp = a->value;
    a->value = b->value;
    b->value = temp;
}

int List_bubble_sort(List *list, List_compare cmp)
{
    int sorted = 1;

    if(List_count(list) <= 1) {
        return 0;  // already sorted
    }

    do {
        sorted = 1;
        LIST_FOREACH(list, first, next, cur) {
            if(cur->next) {
                if(cmp(cur->value, cur->next->value) > 0) {
                    ListNode_swap(cur, cur->next);
                    sorted = 0;
                }
            }
        }
    } while(!sorted);

    return 0;
}

inline List *List_merge(List *left, List *right, List_compare cmp)
{
    List *result = List_create();
    void *val = NULL;

    while(List_count(left) > 0 || List_count(right) > 0) {
        if(List_count(left) > 0 && List_count(right) > 0) {
            if(cmp(List_first(left), List_first(right)) <= 0) {
                val = List_shift(left);
            } else {
                val = List_shift(right);
            }

            List_push(result, val);
        } else if(List_count(left) > 0) {
            val = List_shift(left);
            List_push(result, val);
        } else if(List_count(right) > 0) {
            val = List_shift(right);
            List_push(result, val);
        }
    }

    return result;
}

List *List_merge_sort(List *list, List_compare cmp)
{
    if(List_count(list) <= 1) {
        return list;
    }

    List *left = List_create();
    List *right = List_create();
    int middle = List_count(list) / 2;

    LIST_FOREACH(list, first, next, cur) {
        if(middle > 0) {
            List_push(left, cur->value);
        } else {
            List_push(right, cur->value);
        }

        middle--;
    }

    List *sort_left = List_merge_sort(left, cmp);
    List *sort_right = List_merge_sort(right, cmp);

    if(sort_left != left) List_destroy(left);
    if(sort_right != right) List_destroy(right);

    return List_merge(sort_left, sort_right, cmp);
}

冒泡排序并不难以理解，虽然它很是慢。归并排序更为复杂，实话讲若是我想要牺牲可读性的话，我会花一点时间来优化代码。

归并排序有另外一种“自底向上”的实现方式，可是它太难了，我就没有选择它。就像我刚才说的那样，在链表上编写排序算法没有什么意思。你能够把时间都花在使它更快，它比起其余可排序的数据结构会至关版。链表的本质决定了若是你须要对数据进行排序，你就不要使用它们（尤为是单向的）。

你会看到什么

若是一切都正常工做，你会看到这些：

$ make clean all
rm -rf build src/lcthw/list.o src/lcthw/list_algos.o tests/list_algos_tests tests/list_tests
rm -f tests/tests.log 
find . -name "*.gc*" -exec rm {} \;
rm -rf `find . -name "*.dSYM" -print`
cc -g -O2 -Wall -Wextra -Isrc -rdynamic -DNDEBUG  -fPIC   -c -o src/lcthw/list.o src/lcthw/list.c
cc -g -O2 -Wall -Wextra -Isrc -rdynamic -DNDEBUG  -fPIC   -c -o src/lcthw/list_algos.o src/lcthw/list_algos.c
ar rcs build/liblcthw.a src/lcthw/list.o src/lcthw/list_algos.o
ranlib build/liblcthw.a
cc -shared -o build/liblcthw.so src/lcthw/list.o src/lcthw/list_algos.o
cc -g -O2 -Wall -Wextra -Isrc -rdynamic -DNDEBUG  build/liblcthw.a    tests/list_algos_tests.c   -o tests/list_algos_tests
cc -g -O2 -Wall -Wextra -Isrc -rdynamic -DNDEBUG  build/liblcthw.a    tests/list_tests.c   -o tests/list_tests
sh ./tests/runtests.sh
Running unit tests:
----
RUNNING: ./tests/list_algos_tests
ALL TESTS PASSED
Tests run: 2
tests/list_algos_tests PASS
----
RUNNING: ./tests/list_tests
ALL TESTS PASSED
Tests run: 6
tests/list_tests PASS
$

这个练习以后我就不会向你展现这样的输出了，除非有必要向你展现它的工做原理。你应该能知道我运行了测试，而且经过了全部测试。

如何改进

退回去查看算法描述，有一些方法可用于改进这些实现，其中一些是很显然的：

  • 归并排序作了大量的链表复制和建立操做，寻找减小它们的办法。

  • 归并排序的维基百科描述提到了一些优化，实现它们。

  • 你能使用List_split和List_join（若是你实现了的话）来改进归并排序嘛？

  • 浏览全部防护性编程原则，检查并提高这一实现的健壮性，避免NULL指针，而且建立一个可选的调试级别的不变量，在排序后实现is_sorted的功能。

附加题

  • 建立单元测试来比较这两个算法的性能。你须要man 3 time来查询基本的时间函数，而且须要运行足够的迭代次数，至少以几秒钟做为样本。

  • 改变须要排序的链表中的数据总量，看看耗时如何变化。

  • 寻找方法来建立不一样长度的随机链表，而且测量须要多少时间，以后将它可视化并与算法的描述对比。

  • 尝试解释为何对链表排序十分麻烦。

  • 实现List_insert_sorted（有序链表），它使用List_compare，接收一个值，将其插入到正确的位置，使链表有序。它与建立链表后再进行排序相比怎么样？

  • 尝试实现维基百科上“自底向上”的归并排序。上面的代码已是C写的了，因此很容易从新建立，可是要试着理解它的工做原理，并与这里的低效版本对比。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程