有序单链表的合并

  #返回上一级

@Author: 张海拔

@Update: 2014-01-23

@Link: http://www.cnblogs.com/zhanghaiba/p/3531142.html

/*
 *Author: ZhangHaiba
 *Date: 2014-1-23
 *File: sorted_list_merge.c
 *
 *a demo shows how to merge two sorted single linked list by
 *creating a new list or in-place.
 */

#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#define INF 0x7fffffff
#define CMD_LNE 128

typedef struct node* link;
typedef struct node {
    int item;
    link next;
}node;

//public
link NODE(int item, link next);
link list_create(int n);
link sorted_list_merge_create1(link list_src_a, link list_src_b);
link sorted_list_merge_create2(link list_src_a, link list_src_b);
link sorted_list_merge_in_place1(link list_src_a, link list_src_b);
link sorted_list_merge_in_place2(link list_src_a, link list_src_b);
void list_travel(link head);
void list_destroy(link head);
//private
//accept list without Head Node, and return list without Head Node as well
link sorted_list_merge_create_iter(link a, link b);
link sorted_list_merge_in_place_iter(link a, link b);
link sorted_list_merge_create_rec(link a, link b);
link sorted_list_merge_in_place_rec(link a, link b);


int main(void)
{
    int len_a, len_b;

    scanf("%d", &len_a);
    link list_a = list_create(len_a);
    printf("list_a travel: ");
    list_travel(list_a);

    scanf("%d", &len_b);
    link list_b = list_create(len_b);
    printf("list_b travel: ");
    list_travel(list_b);

    printf("create list_c by using(merging) list_a and list_b nodes.
");
    //link list_c = sorted_list_merge_create1(list_a, list_b);
    link list_c = sorted_list_merge_create2(list_a, list_b);
    printf("list_c travel: ");
    list_travel(list_c);

    printf("merge list_c and list_a to list_d.
");
    //link list_d = sorted_list_merge_in_place1(list_c, list_a);
    link list_d = sorted_list_merge_in_place2(list_c, list_a);
    printf("list_d travel: ");
    list_travel(list_d);

    list_c = list_a = NULL;
    list_destroy(list_b);
    printf("list_b destroyed!
");
    list_destroy(list_d);
    printf("list_d destroyed!
");
    return 0;
}

link NODE(int item, link next)
{
    link born = malloc(sizeof (node));
    born->item = item;
    born->next = next;
    return born;
}

//tail insert
link list_create(int n)
{
    int i, item;
    link head = NODE(INF, NULL);
    link tail = head;

    for (i = 0; i < n; ++i) {
        scanf("%d", &item);
        tail->next = NODE(item, NULL);
        tail = tail->next;
    }
    return head;
}

//Iterative implementation begin here
link sorted_list_merge_create_iter(link a, link b)
{
    link tmp_head = NODE(INF, NULL);
    link c = tmp_head; //c as tail pointer for the list_c

    for (; a != NULL && b != NULL; c = c->next)
        if (a->item < b->item)
              c->next = NODE(a->item, NULL), a = a->next;
        else
            c->next = NODE(b->item, NULL), b = b->next;
    for (; a != NULL; c = c->next, a = a->next)
        c->next = NODE(a->item, NULL);
    for (; b != NULL; c = c->next, b = b->next)        
        c->next = NODE(b->item, NULL);
    link first = tmp_head->next;
    free(tmp_head);
    return first;
}

link sorted_list_merge_create1(link a, link b)
{
    if (a == NULL || b == NULL)
        return NULL;
    return NODE(INF, sorted_list_merge_create_iter(a->next, b->next));
}

link sorted_list_merge_in_place_iter(link a, link b)
{
    link tmp_head = NODE(INF, NULL);
    link c = tmp_head; //c as tail pointer for the list_c

    for (; a != NULL && b != NULL; c = c->next)
        if (a->item < b->item)
            c->next = a, a = a->next;
        else
            c->next = b, b = b->next;
    c->next = a != NULL ? a : b; //link left ordered list
    link first = tmp_head->next;
    free(tmp_head);
    return first;
}

link sorted_list_merge_in_place1(link a, link b)
{
    if (a == NULL || b == NULL)
        return NULL;
    link head = NODE(INF, sorted_list_merge_in_place_iter(a->next, b->next));
    free(a);
    free(b);
    return head;
}
//Iterative implementation end here


//Recursive implementation begin here
link sorted_list_merge_create_rec(link a, link b)
{
    link first = NULL;

    if (a == NULL) {
        link tmp_head = NODE(INF, NULL);
        link c = tmp_head; //c as tail pointer for left list
        while (b != NULL) {
            c->next = NODE(b->item, NULL);
            c = c->next;
            b = b->next;
        }
        link left = tmp_head->next;
        free(tmp_head);
        return left;
    }
    if (b == NULL) {
        link tmp_head = NODE(INF, NULL);
        link c = tmp_head; //c as tail pointer for left list
        while (a != NULL) {
            c->next = NODE(a->item, NULL);
            c = c->next;
            a = a->next;
        }
        link left = tmp_head->next;
        free(tmp_head);
        return left;
    }
    if (a->item < b->item) {
        first = NODE(a->item, NULL);
        first->next = sorted_list_merge_create_rec(a->next, b);
    } else {
        first = NODE(b->item, NULL);
        first->next = sorted_list_merge_create_rec(b->next, a);
    }
    return first;
}

link sorted_list_merge_create2(link a, link b)
{
    if (a == NULL || b == NULL)
        return NULL;
    return NODE(INF, sorted_list_merge_create_rec(a->next, b->next));
}

link sorted_list_merge_in_place_rec(link a, link b)
{
    if (a == NULL)
        return b;
    if (b == NULL)
        return a;
    link first = NULL;
    if (a->item < b->item) {
        first = a;
        first->next = sorted_list_merge_in_place_rec(a->next, b);
    } else {
        first = b;
        first->next = sorted_list_merge_in_place_rec(a, b->next);
    }
    return first;
}

link sorted_list_merge_in_place2(link a, link b)
{
    if (a == NULL || b == NULL)
        return NULL;
    link head = NODE(INF, sorted_list_merge_in_place_rec(a->next, b->next));
    free(a);
    free(b);
    return head;
}
//Recursive implementation end here

void list_travel(link head)
{
    for (head = head->next; head != NULL; head = head->next)
        printf(head->next == NULL ? "%d
" : "%d ", head->item);
}

void list_destroy(link head)
{
    head->next == NULL ? free(head) : list_destroy(head->next);
}

测试示例：

ZhangHaiba-MacBook-Pro:code apple$ ./a.out
6
30 53 65 77 88 99
list_a travel: 30 53 65 77 88 99
9
11 22 33 44 55 100 120 199 211
list_b travel: 11 22 33 44 55 100 120 199 211
create list_c by using(merging) list_a and list_b nodes.
list_c travel: 11 22 30 33 44 53 55 65 77 88 99 100 120 199 211
merge list_c and list_a to list_d.
list_d travel: 11 22 30 30 33 44 53 53 55 65 65 77 77 88 88 99 99 100 120 199 211
list_b destroyed!
list_d destroyed!

单链表的合并，给出了两个接口（函数）：sorted_list_merge_create()和sorted_list_merge_in_place()。分别对应非就地合并和就地合并。

两个函数各有用武之地，非就地合并生成一个新链表，输入的两个链表还可以继续使用；

就地合并则把输入的两个链表a和b合并为一个链表c，合并后a和b逻辑上就不存在了。

由于这里操作的链表是：带头节点的单链表。

考虑函数的复用性，首先设计的合并函数A：接收两个不带头节点的链表，返回一个不带头节点的（新）链表。

带头节点的链表只是不带头节点的链表的一种限定（子集），

所以通过设计一个外壳函数包装上一步实现的合并函数A，就可以实现带头节点的单链表合并的函数B。

合并函数B：接收两个带头节点的链表，返回一个带头节点的（新）链表。规定传入链表的头节点不能为空，否则返回NULL。

A函数对应上述实现中的

sorted_list_merge_create_iter()和sorted_list_merge_create_rec()

sorted_list_merge_in_place_iter()和sorted_list_merge_in_place_rec()

下面从实现方法的角度做一个纵向对比——

（1）迭代实现

迭代实现中，借助了一个临时头节点，这样才能保存第一个节点的指针first，返回first之前先释放临时头节点

1）非就地合并

如果b遍历完了a还没完，则把a剩下的依次复制到新链表后面；b同理。

2）就地合并

如果b遍历完了a还没完，则把a剩下的链表一次链接到tail指针c中即可，效率很高的说；b同理。

（2）递归实现

1）非就地合并

若链表a为空，则复制b剩下的链表（借助了临时头节点来实现，返回left前释放临时头节点）；b同理。

否则选较小的节点复制作为当前链表的根节点，然后合并剩下的链表作为子链表。

2）就地合并

若链表a为空，则直接返回链表b；b同理。

否则选较小的节点作为当前链表的根节点，然后合并剩下的链表作为子链表。

对于外壳函数，非就地合并没啥可说，就地合并返回前还需要释放a和b的头节点。

客户端程序（主函数）中，就地合并c和a之后，有责任把c和a置为NULL，因为调用方知道此时c和a已经不存在了。

小结：单链表的非就地合并和就地合并，都是利用了链表的“尾插法”来建表。区别是，前者生成节点，后者链入节点，且后者的效率会更高。

  #返回上一级