5 链表合并（OJ通过）

假设有两个按元素值递增次序排列的线性表，均以单链表形式存储。请编写算法将这两个单链表归并为一个按元素值递减次序排列的单链表，并要求利用原来两个单链表的结点存放归并后的单链表。
输入：
先输入两个整数 m, n，分别代表两个递增单链表的长度。
输入两行整数，分别代表两个递增单链表的结点值。
输出：
输出一个排好序的递减的链表。

输入样例

4 4
1 2 5 7
3 4 6 8

输出样例

8 7 6 5 4 3 2 1

Code1：（这个看看就行了，当时头脑有点不清楚）

#include 
#include 
typedef struct node
{
    int data;
    struct node *prior;
    struct node *next;
}node;

int main(void )
{
    node *a,*b,*c,*p,*tail;
    int data,i,j,ii,jj,k,t;
    a=b=c=NULL;
    t=0;
    scanf("%d %d",&i,&j);
    ii=i,jj=j;
    k=i+j;
    while (i--)
    {
        p=(node *) malloc(sizeof (node));
        scanf("%d",&p->data);
        if(!a)
        {
            a=p;
            p->prior=NULL;
        }
        else
        {
          tail->next=p;
          p->prior=tail;
        }
        p->next=NULL;
        tail=p;    
    }
    tail->next=a;
    a->prior=tail;
    
    
    while (j--)
    {
        p=(node *) malloc(sizeof (node));
        scanf("%d",&p->data);
        if(!b)
        {
            b=p;
            p->prior=NULL;
        }
        else
        {
            tail->next=p;
            p->prior=tail;
        }
        p->next=NULL;
        tail=p;
    }
    tail->next=b;
    b->prior=tail;
    
    c=tail=(node *)malloc(sizeof(node));
    while (ii&&jj)
    {	
        if(b->prior->data>a->prior->data)
        {
            tail->next=b->prior;
            tail=b->prior;
            b->prior=b->prior->prior;
            jj--;
        }
        else if(b->prior->dataprior->data)
        {
            tail->next=a->prior;
            tail=a->prior;
            a->prior=a->prior->prior;
            ii--;
        }
        else
        {
            tail->next=b->prior;
            tail=b->prior;
            b->prior=b->prior->prior;
            a->prior=a->prior->prior;
            jj--;
            t++;
        }
    }
    if(!jj)
    {
    	tail->next=a->prior;
    	while(--ii)
    	{
    		tail=a->prior;
    		a=a->prior;
    		tail->next=a->prior;
		}
    	
	}
	else
	{
		tail->next=b->prior;
    	while(--jj)
    	{
    		tail=b->prior;
    		b=b->prior;
    		tail->next=b->prior;
		}
	}

    p=c->next;
    k-=t;
    while(k--)
    {
    	
        printf("%d ",p->data);
        p=p->next;
    }
    return 0;
}

Code2：（骗OJ版）

#include "stdio.h"
#include "stdlib.h"
#define maxsize 1000

int main(void )
{
    int sizea,sizeb;
    int *stacka,*stackb;
    int posa,posb;
    posa=posb=-1;
    stacka=(int *) malloc(maxsize*sizeof (int ));
    stackb=(int *) malloc(maxsize*sizeof (int ));
    scanf("%d %d",&sizea,&sizeb);
    while (++posastackb[posb])
        {
            printf("%d ",stacka[posa]);
            posa--;
        }
        else
        {
            printf("%d ",stacka[posa]);
            posa--;
            posb--;
        }
    }

    if(posa==-1)
    {
        while(posb!=-1)
        {
            printf("%d ",stackb[posb--]);
        }
    }
    else
    {
        while(posa!=-1)
        {
            printf("%d ",stacka[posa--]);
        }
    }
    free(stacka);
    free(stackb);
    return 0;
}

Code3：（prior指针的单向链表，待更新）