PAT (Basic Level) Practice （中文） 1105 链表合并 （C）

本文使用双向链表解答。之所以使用双向链表而非静态连续存储的方式一是为了提供新的解决问题的方法，二是为了熟练掌握C语言的灵魂——指针。

题目：

给定两个单链表 L1​=a1​→a2​→⋯→an−1​→an​ 和 L2​=b1​→b2​→⋯→bm−1​→bm​。如果 n≥2m，你的任务是将比较短的那个链表逆序，然后将之并入比较长的那个链表，得到一个形如 a1​→a2​→bm​→a3​→a4​→bm−1​⋯ 的结果。例如给定两个链表分别为 6→7 和 1→2→3→4→5，你应该输出 1→2→7→3→4→6→5。

输入格式：

输入首先在第一行中给出两个链表 L1​ 和 L2​ 的头结点的地址，以及正整数
N (≤10^5)，即给定的结点总数。一个结点的地址是一个 5 位数的非负整数，空地址 NULL 用 -1 表示。

随后 N 行，每行按以下格式给出一个结点的信息：

Address Data Next

其中 Address 是结点的地址，Data 是不超过 10^5 的正整数，Next 是下一个结点的地址。题目保证没有空链表，并且较长的链表至少是较短链表的两倍长。

输出格式：

按顺序输出结果链表，每个结点占一行，格式与输入相同。

输入样例：

00100 01000 7
02233 2 34891
00100 6 00001
34891 3 10086
01000 1 02233
00033 5 -1
10086 4 00033
00001 7 -1

输出样例：

01000 1 02233
02233 2 00001
00001 7 34891
34891 3 10086
10086 4 00100
00100 6 00033
00033 5 -1

代码长度限制   16 KB

时间限制 400 ms

内存限制  64 MB

---

分析：

一、输入数据和建立链表。使用三个链表 L1、L2和L。L1和 L2存储有序的两个链表，L作辅助用。以样例为例，输入后，各链表的初始状态：

链表 L1：6<->7，链表 L2：1，辅助链表 L：2<->3<->5<->4。

接着，把辅助链表中待排序数据链接到 L1和 L2，得到俩链表的有序态：

链表 L1：6<->7，链表 L2：1<->2<->3<->4<->5。（辅助链表：NULL）

二、合并链表。使用两个指针 *q和 *p。q指向短链表待插入数据，p指向长链表待插入位置。短链表有多少个数据就要插入多少次。

样例需要执行两次插入操作。第一次操作初始状态：

链表 L1：6<->7，链表 L2：1<->2<->3<->4<->5。

q                           p  

第二次操作初始状态：

链表 L1：6，链表 L2：1<->2<->7<->3<->4<->5。

     q                                               p

最终：

（链表 L1：NULL）链表 L2：1<->2<->7<->3<->4<->6<->5。

三、输出。

 

代码：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    typedef struct _node {
        int data, ad, nad;
        struct _node *next, *back;
    } Node;
    typedef struct _list {
        int len;
        Node *head, *tail;
    } List;
    List L1, L2, L;
    int x1, x2, N, i;
    Node *p, *q;
    
    scanf("%d %d %d\n", &x1, &x2, &N);
    
    void Link( List *pL, Node *np ) { //定义链接函数
    	if ( pL->head ) {
            pL->tail->next = np;
            np->back = pL->tail;
            pL->tail = np;
        } else {
            pL->head = pL->tail = np;
            np->back = NULL;
        }
	}
    for ( i=N,L1.head=L2.head=L.head=NULL,L1.len=L2.len=0; i; i-- ) { //输入和链接
        Node *np = (Node*)malloc(sizeof(Node));
        scanf("%d %d %d", &np->ad, &np->data, &np->nad);
        if ( i-1 ) getchar();
        np->next = NULL;
        
        if ( np->ad == x1 ) {
            Link( &L1, &*np );
            
            x1 = np->nad;
            L1.len++;
        } else if ( np->ad == x2 ) {
            Link( &L2, &*np );
            
            x2 = np->nad;
            L2.len++;
        } else {
            Link( &L, &*np );
        }
    }
    
    void Link2( List *pL, Node *p ) { //定义链接函数2
    	pL->tail->next = p;
        p->back = pL->tail;
        pL->tail = p;
        p->next = NULL;
	}
    for ( p=L.head; p; ) { //链接
        if ( p->ad != x1 && p->ad != x2 ) {
            p = p->next;
        } else {
            if ( !p->back && p->next ) {
                L.head = p->next;
                L.head->back = NULL;
            } else if ( !p->next && p->back ) p->back->next = NULL;
            else if ( p->next && p->back ) {
                p->back->next = p->next;
                p->next->back = p->back;
            } else L.head = NULL;
            
            if ( p->ad == x1 ) {
                Link2( &L1, &*p );
                
                x1 = p->nad;
                L1.len++;
            } else {
                Link2( &L2, &*p );
                
                x2 = p->nad;
                L2.len++;
            }
            
            p = L.head;
        }
    }
    
    void Combine( List *pL1, List *pL2 ) { //定义合并函数
        Node *p, *q;
        for ( p=pL2->head->next,q=pL1->tail; q; q=pL1->tail) {
            pL1->tail = q->back;

            q->next = p->next;
            p->next = q;

            if ( q->next ) {
            	if ( q->next->next ) p = q->next->next;
            }
        }
    }
    L1.len < L2.len ? Combine( &L1, &L2 ) : Combine( &L2, &L1 ); //合并
    
    for ( p=L1.len<L2.len?L2.head:L1.head; p->next; q=p,p=p->next,free(q) ) { //输出和释放
    	printf("%05d %d %05d\n", p->ad, p->data, p->next->ad);
    }
    printf("%05d %d -1", p->ad, p->data);
    free(p);
    
    return 0;
}

提交结果：