仿Linux内核链表实现合并有序链表、逆序单链表功能，C版本 JavaScript版本

直接贴上已经码好的：

list_sort.c:

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>
#include <unistd.h>

/**** 双向链表，非双向循环链表哦！
 *
 *  gcc -m32 ： 在64位系统上编译出32位的程序(指针大小4字节)，
 *  这样编译本代码不会编译报警告
 *
 *****/

#define use_double_direction_list    //关闭双向非循环链表模式，则默认开启单向非循环链表模式  

 /*计算member在type中的位置*/
#define offsetof(type, member)  (unsigned int)(&((type*)0)->member)

 /*根据member的地址获取type的起始地址*/
#define container_of(ptr, type, member) ({                   \
        const typeof(((type *)0)->member)*__mptr = (ptr);    \
        (type *)((char *)__mptr - offsetof(type, member)); })

typedef  struct _inside_link{
    struct _inside_link* pNext;

#if defined(use_double_direction_list)
    struct _inside_link* pFront;
#endif

}inside_link;

typedef struct _usr_data_pack{
    unsigned  char* name0;
    unsigned  int   data0;
}usr_data_pack;

typedef  struct _usrdata_templ{
    inside_link link;

    usr_data_pack usr_data;
}usrdata_templ;

void usrdata_set(usrdata_templ* pusr_data_list, usr_data_pack* pdata_pack){

    memset(&pusr_data_list->usr_data, 0,          sizeof(usr_data_pack));
    memcpy(&pusr_data_list->usr_data, pdata_pack, sizeof(usr_data_pack));
}

static void print_usr_data_pack(usr_data_pack* pdata_pack){

    printf("pdata_pack->name0 = \033[0;31m %s,\t\033[0m pdata_pack->data0 = \033[0;33m %d \033[0m\n", \
                                      pdata_pack->name0, pdata_pack->data0);

}   

void usrdata_print(usrdata_templ* pusr_data_list){

    if(pusr_data_list != NULL){
        print_usr_data_pack(&pusr_data_list->usr_data);
    }

    inside_link* pNext_link = pusr_data_list->link.pNext;

    while(pNext_link){
        usrdata_templ* pNext_templ = NULL;
        pNext_templ = container_of(pNext_link, usrdata_templ, link);

        print_usr_data_pack(&pNext_templ->usr_data);

        pNext_link = pNext_link->pNext;
    }
}

void link_init(inside_link* plink){
#if defined(use_double_direction_list)
    plink->pFront = NULL;   

#endif

    plink->pNext = NULL;
}

/***** 对比内核链表
下面是内核从尾部添加函数：
static inline void list_add_tail(struct list_head *newer, struct list_head *head)
{
    __list_add(newer, head->prev, head);
}
内核链表使用了双向循环链表，这里找到尾巴节点，只要从头节点向前推一个节点就找到了，很方便。
而我使用了双向非循环链表，就需要遍历了，代码也更难看了。
心得： 双向循环链表相对于双向非循环链表，几乎不增加内存成本，而且能够提高效率。
      以后写代码，编写组件，都要使用双向循环链表。
*******/

/**
 * list_add_tail没有检查同一个链表节点两次被加入的情况。
 * 但是我这个函数检查了
 * **/
int link_tail_add(inside_link* plink, inside_link* pnode){

    inside_link* pcurrent_node = plink->pNext;
    inside_link* pformer_node = plink;

    if(plink == pnode){             /****检查同一个链表节点两次及以上次数被加入*****/
        return -1;
    }

    while(pcurrent_node){
        if(pnode == pcurrent_node){ /****检查同一个链表节点两次及以上次数被加入*****/
            return -1;
        }

        pformer_node = pcurrent_node;
        pcurrent_node = pcurrent_node->pNext;
    }

#if defined(use_double_direction_list)
    pnode->pFront = pformer_node;
#endif

    pformer_node->pNext = pnode;

    return 0;
}

void create_usrdaralist1(usrdata_templ* phead){

    link_init(&phead->link); 

    // add first node, then print
    usr_data_pack pack0 = {"jack 170", 170};
    usrdata_set(phead, &pack0);

#if 0
    // add second node, then print
    usrdata_templ* pnode1 = (usrdata_templ*)malloc(sizeof(usrdata_templ));
    usr_data_pack pack1 = {"jack 171", 171};
    link_init(&pnode1->link);
    usrdata_set(pnode1, &pack1);

    if(!link_tail_add(&phead->link, &pnode1->link)){

    }else{

        printf("\033[0;33m this Node add Fail!  \033[0m \n");
    }
#endif

    // add third node, then print
    usrdata_templ* pnode2 = (usrdata_templ*)malloc(sizeof(usrdata_templ));
    usr_data_pack pack2 = {"jack 172", 172};
    link_init(&pnode2->link);
    usrdata_set(pnode2, &pack2);

    if(!link_tail_add(&phead->link, &pnode2->link)){

    }else{

        printf("\033[0;33m this Node add Fail!  \033[0m \n");
    }

    // add 4th node, then print
    // 这里尝试将实验3处的节点再次添加到链表上，
    // 即实验一个链表节点多次被添加
    if(!link_tail_add(&phead->link, &pnode2->link)){

    }else{

        printf("\033[0;33m this Node add Fail!  \033[0m \n");
    }

#if 1
    // add 4th node agian, then print
    usrdata_templ* pnode3 = (usrdata_templ*)malloc(sizeof(usrdata_templ));
    usr_data_pack pack3 = {"jack 178", 178};
    link_init(&pnode3->link);
    usrdata_set(pnode3, &pack3);

    if(!link_tail_add(&phead->link, &pnode3->link)){

        //usrdata_print(phead);
        //printf("Creat List1  Done ----------\n\n");

    }else{

        printf("\033[0;33m this Node add Fail!!  \033[0m \n");
    }
#endif   

    usrdata_print(phead);
    printf("Creat List1  Done ----------\n\n");

}

void create_usrdaralist2(usrdata_templ* phead){

    link_init(&phead->link); 

    // add first node, then print
    usr_data_pack pack0 = {"merry 172", 172};
    usrdata_set(phead, &pack0);

    //usrdata_print(phead);

    // add second node, then print
    usrdata_templ* pnode1 = (usrdata_templ*)malloc(sizeof(usrdata_templ));
    usr_data_pack pack1 = {"merry 173", 173};
    link_init(&pnode1->link);
    usrdata_set(pnode1, &pack1);

    if(!link_tail_add(&phead->link, &pnode1->link)){
        //usrdata_print(phead);
    }else{

        printf("\033[0;33m this Node add Fail!  \033[0m \n");
    }

    // add third node, then print
    usrdata_templ* pnode2 = (usrdata_templ*)malloc(sizeof(usrdata_templ));
    usr_data_pack pack2 = {"merry 174", 174};
    link_init(&pnode2->link);
    usrdata_set(pnode2, &pack2);

    if(!link_tail_add(&phead->link, &pnode2->link)){
        //usrdata_print(phead);
    }else{

        printf("\033[0;33m this Node add Fail!  \033[0m \n");
    }

    // add 4th node, then print
    // 这里尝试将实验3处的节点再次添加到链表上，
    // 即实验一个链表节点多次被添加
    if(!link_tail_add(&phead->link, &pnode2->link)){
        //usrdata_print(phead);
    }else{

        printf("\033[0;33m this Node add Fail!  \033[0m \n");
    }

    // add 4th node agian, then print
    usrdata_templ* pnode3 = (usrdata_templ*)malloc(sizeof(usrdata_templ));
    usr_data_pack pack3 = {"merry 175", 175};
    link_init(&pnode3->link);
    usrdata_set(pnode3, &pack3);

    if(!link_tail_add(&phead->link, &pnode3->link)){

        usrdata_print(phead);
        printf("Create List2 Done ----------\n\n");

    }else{

        printf("\033[0;33m this Node add Fail!!  \033[0m \n");
    }
}

void combine_2_becomes_1(usrdata_templ*plist1, usrdata_templ*plist2){

    inside_link* p_list1_curlink = &plist1->link;
    inside_link* p_list2_curlink = &plist2->link;

        //inside_link* p_list1_baklink = NULL;
        //inside_link* p_list2_baklink = NULL;

    usrdata_templ* p_cur_usrdata1 = NULL;
    usrdata_templ* p_cur_usrdata2 = NULL;  

    usrdata_templ newlist = {
                             .link = {0}, 

                             .usr_data = {
                                .name0 = "我是头节点",
                                .data0 = 0,
                             }
                            };
    link_init(&newlist.link); 

    int flagloop = 1;

    do{
        usleep(100000);
        printf(" time: 100 ms \n");

        // 1. 取
        if(NULL != p_list1_curlink){
            p_cur_usrdata1 = container_of(p_list1_curlink, usrdata_templ, link);
            //printf("%s,  %d \n", p_cur_usrdata1->usr_data.name0, p_cur_usrdata1->usr_data.data0);
        }
        else{
            break;
        }

        if(NULL != p_list2_curlink){
            p_cur_usrdata2 = container_of(p_list2_curlink, usrdata_templ, link);
            //printf("%s,  %d \n", p_cur_usrdata2->usr_data.name0, p_cur_usrdata2->usr_data.data0);
        }
        else{
            break;
        }

        // 2.比
        if(p_cur_usrdata1->usr_data.data0 <= p_cur_usrdata2->usr_data.data0){

            // 3. 存
            usrdata_templ *pnode = (usrdata_templ *)malloc(sizeof(usrdata_templ));
            usr_data_pack pack = {0};
            memcpy(&pack, &p_cur_usrdata1->usr_data, sizeof(usr_data_pack));
            link_init(&pnode->link);
            usrdata_set(pnode, &pack);

            if(!link_tail_add(&newlist.link, &pnode->link)){
                printf("\033[0;34m Add Success. Line: %d \033[0m \n", __LINE__);
            }
            else{
                printf("\033[0;33m this Node add Fail! Line: %d \033[0m \n", __LINE__);
            }

            // 4. 移
            p_list1_curlink = p_list1_curlink->pNext;

        }else{

            // 3. 存
            usrdata_templ *pnode = (usrdata_templ *)malloc(sizeof(usrdata_templ));
            usr_data_pack pack = {0};
            memcpy(&pack, &p_cur_usrdata2->usr_data, sizeof(usr_data_pack));
            link_init(&pnode->link);
            usrdata_set(pnode, &pack);

            if(!link_tail_add(&newlist.link, &pnode->link)){
                printf("\033[0;34m Add Success. Line: %d \033[0m \n", __LINE__);
            }
            else{
                printf("\033[0;33m this Node add Fail! Line: %d \033[0m \n", __LINE__);
            }

            // 4. 移
            p_list2_curlink = p_list2_curlink->pNext;

        }

    }while(1); // 4. 比

    printf("p_list1_curlink = 0x%x,  p_list2_curlink = 0x%x \n",   \
                 (unsigned int)p_list1_curlink, (unsigned int)p_list2_curlink);

    inside_link* p_list_left = NULL;

    printf("====下面打印的排序后的两个有序链表的前半部分======\n");
    usrdata_print(&newlist); 

    if(NULL != p_list1_curlink){
        p_list_left = p_list1_curlink;
    }

    if(NULL != p_list2_curlink){
        p_list_left = p_list2_curlink;
    }

    while(p_list_left){

        usrdata_templ* p_left_usrdata = container_of(p_list_left, usrdata_templ, link);

        usrdata_templ *pnode = (usrdata_templ *)malloc(sizeof(usrdata_templ));
        usr_data_pack pack = {0};
        memcpy(&pack, &p_left_usrdata->usr_data, sizeof(usr_data_pack));
        link_init(&pnode->link);
        usrdata_set(pnode, &pack);

        if(!link_tail_add(&newlist.link, &pnode->link)){
            printf("\033[0;34m Add Success. Line: %d \033[0m \n", __LINE__);
        }
        else{
            printf("\033[0;33m this Node add Fail! Line: %d \033[0m \n", __LINE__);
        }

        p_list_left = p_list_left->pNext;

    }

    printf("====下面完整打印排序后的两个有序链表======\n");
    usrdata_print(&newlist); 

}

usrdata_templ* reverse_single_direction_list(usrdata_templ*plist){

    usrdata_templ* plist_local = plist;

    inside_link *p_list_curlink = &plist_local->link;
    inside_link *p_list_baklink_former = NULL, *p_list_baklink_former_former = NULL;

    unsigned int the_single_list_node_cnt = 0;

    usrdata_templ* p_cur_usrdata;

    while(p_list_curlink->pNext){

        /** 如果单链表有N个节点，那么退出该while时，the_single_list_node_cnt值为(N-1) **/
        the_single_list_node_cnt++;

        p_list_baklink_former_former = p_list_baklink_former;
        p_list_baklink_former = p_list_curlink;
        p_list_curlink  = p_list_curlink->pNext;

        if(the_single_list_node_cnt >= 2){

            p_list_baklink_former->pNext = p_list_baklink_former_former;
        }
    }

    p_list_curlink->pNext = p_list_baklink_former;

    if(the_single_list_node_cnt >= 1){
        /**只要存在两个以上节点，就要把第一个节点的pNext指针值为NULL(即将其设置为尾节点)**/
        plist_local->link.pNext = NULL;
    }

    if(0 == the_single_list_node_cnt){
         printf("\033[0;33m 该list只有1个节点，不需要逆序!  \033[0m \n");
    }

    p_cur_usrdata = container_of(p_list_curlink, usrdata_templ, link);  

    return p_cur_usrdata;
}

int main(){

    usrdata_templ* phead1 = (usrdata_templ*)malloc(sizeof(usrdata_templ));
    create_usrdaralist1(phead1);

    usrdata_templ* phead2 = (usrdata_templ*)malloc(sizeof(usrdata_templ));
    create_usrdaralist2(phead2);

    #if 1
        printf("  合并两个有序链表测试 开始\n\n");
        combine_2_becomes_1(phead1, phead2);
        printf("  合并两个有序链表测试 完毕 \n\n\n");
    #endif

    #if 1
        printf("\n  逆序单链表List1 测试 开始\n");

        usrdata_templ* p_reverse = reverse_single_direction_list(phead1);
        usrdata_print(p_reverse); 

        printf("  逆序单链表测试 完毕\n\n");
    #endif

    return 0;
}

makefile:

do:
    #gcc list_sort.c
    gcc -m32 list_sort.c
    ./a.out

运行：

解题思路：

合并有序链表思路： 小鬼摘葡萄

领略JavaScript风采

同样的思路，同样的原理(和上述C版本的一模一样)，JavaScript版本的核心代码：

JavaScript版本实现的单链表逆序的核心代码，此版本思路较我上面的C版本更简洁，更佳，所以上面的C代码还可以参考此代码进行改进

个人心得：

　　对于链表的使用，不仅仅是学习其侵入式链表的特点，还要领会其循环链表的优点， 双向、循环、侵入式、每个都是值得学习的地方。

话外(吐槽)：

　　对于面试造飞机，要在一小时内写完一张卷子，还包括几道这种题目，难度的确大。

备战面试笔试，我们要做到不假思索就能写出来，不仅靠调试能力(面试笔试只有笔和纸，甚至都不能调试)，可能还需要记和背了。

　   本例子实现的链表不仅完成了基本功能，还具有一定的可复用特点，具有一定的工程意义，所以足以应付笔试标准。

但是对外提供的API还不够丰富，且未做线程安全处理， 达不到实际工程标准，在实际工程中，我们应该参考Linux内核链表去实现，而不要凭空自己去实现。

.