两个有序的无头结点的链表的交并集的实现

#include "stdafx.h"
#include<iostream>
using namespace std;

typedef struct LNode
{
    int data;
    struct LNode *next;
    LNode(const int &d) :data(d), next(NULL) {}
}LNode,*ListNode;

void CreatList(ListNode &L,int l[],int length)
{
    ListNode p = NULL, q;
    L = (ListNode)malloc(sizeof(LNode));  // 生成头结点
    L->next = NULL;
    q = L;
    for (int i = 0; i < length; i++)
    {
        p = (ListNode)malloc(sizeof(LNode));
        p->data = l[i];
        q->next = p;
        q = q->next;
        p->next = NULL;
    }
}

void Print(ListNode L)
{
    // 输出链表结点内容
    LNode *p;
    p = L->next;
    // cout << "L=";
    while (p) {
        cout << p->data<<"  ";
        if (p->next) {
            //    cout <<"下一个存在"<<endl;
            p = p->next;
        }

        else {
            //  cout << "下一个不存在"<<endl;
            break;
        }
    }
    cout << endl;
}

ListNode intersection(ListNode &L1, ListNode &L2, ListNode &L3)
{
    ListNode p = NULL, q;
    L3 = (ListNode)malloc(sizeof(LNode));  // 生成头结点
    L3->next = NULL;
    q = L3;
    LNode *A;
    A = L1->next;
    LNode *B;
    B = L2->next;
    //判断不为空
    if (A == NULL || B == NULL)
    {
        return NULL;    
    }
    //新链表的头结点
    //ListNode newlist= (ListNode)malloc(sizeof(LNode));
    //ListNode tail = newlist;
    while (A&&B)
    {
        //相等一起走
        if (A->data == B->data)
        {
            p = (ListNode)malloc(sizeof(LNode));
            p->data = A->data;
            q->next = p;
            q = q->next;
            A = A->next;
            B = B->next;
            //Print(q);
        }

        //
        else if (A->data < B->data)
        {            
            A = A->next;
        }
        else
        {
            B = B->next;
        }
    }
    p->next = NULL;
    return L3;
}

//此函数用于求出L1，L2链表的并集，存入L4链表
ListNode unionsection(ListNode &L1, ListNode &L2, ListNode &L4)
{
    ListNode p = NULL, q;//p、q指针相互配合，不断向前生成L4链表
    L4 = (ListNode)malloc(sizeof(LNode));//生成L4链表的头结点
    L4->next = NULL;
    q = L4;//q成为L4链表的头结点
    ListNode A = L1->next;//A、B为函数内的临时指针变量，用于遍历L1，L2；
    ListNode B = L2->next;
    if (A ==NULL&& B==NULL)//当A和B指针指向的内容都为空时，代表不用继续遍历，函数进行结束，返回
    {
        return NULL;
    }
    while (A != NULL || B != NULL)//当A或B其中任意一个指针指向的内容不为空时，继续遍历
    {
        if (A != NULL && B != NULL)
        {
            //相等存A或B中任意一个，只存一次
            if (A->data == B->data)
            {
                p = (ListNode)malloc(sizeof(LNode));
                p->data = A->data;
                q->next = p;
                q = q->next;
                p->next = NULL;
                A = A->next;
                B = B->next;
            }
            else if (A->data < B->data)
            {
                p = (ListNode)malloc(sizeof(LNode));
                p->data = A->data;
                q->next = p;
                q = q->next;
                p->next = NULL;
                A = A->next;
            }
            else
            {
                p = (ListNode)malloc(sizeof(LNode));
                p->data = B->data;
                q->next = p;
                q = q->next;
                p->next = NULL;
                B = B->next;
            }
        }
        else if(A)
        {
            p = (ListNode)malloc(sizeof(LNode));
            p->data = A->data;
            q->next = p;
            q = q->next;
            p->next = NULL;
            A = A->next;
        }
        else if (B)
        {
            p = (ListNode)malloc(sizeof(LNode));
            p->data = B->data;
            q->next = p;
            q = q->next;
            p->next = NULL;
            B = B->next;
        }
    }

    return L4;
}
int main()
{
    ListNode A, B;
    int a[] = { 1,3,4,7,9,10 };
    int b[] = { 2,3,4,6,8,9,10,55 };
    int lengtha= sizeof(a) / sizeof(int);//记录动态数组长度
    int lengthb = sizeof(b) / sizeof(int);//记录动态数组长度

    cout << "lengtha="<<sizeof(a) / sizeof(int)<<endl;
    cout << "lengthb=" << sizeof(b) / sizeof(int) << endl;
    
    CreatList(A, a, lengtha);
    cout << "集合A：";
    Print(A);
    CreatList(B, b, lengthb);
    cout << "集合B：";
    Print(B);
    ListNode newlist;
    
    newlist=intersection(A, B,newlist);
    cout << "AB的交集：";
    Print(newlist);
    cout << "集合A：";
    Print(A);
    cout << "集合B：";
    Print(B);
    newlist = unionsection(A, B, newlist);
    cout << "AB的并集：";
    Print(newlist);    
}