通常鏈表實現集合運算（C語言）

最近在學習數據結構，遇到如下問題：

假設集合A = （c, b, e, g, f, d），B = （a, b, n, f），利用通常線性鏈表實現集合運算（A-B）∪（B-A）。

分析：

上面的問題只要是考察怎樣應用鏈表，熟悉鏈表的操做，對鏈表有更加理性的認識。題目理解：題目的意思是將A和B中相同的元素刪除，不一樣的元素插入的到A中，或者另外建立一個鏈表來存儲。知道題目要求以後下面來提供實現思路：

思路：

一、根據鏈表的特色，實現它的基本功能（增、刪、改、查）。
二、在主函數中建立兩個鏈表來存儲集合A和B。
三、題目實現函數：經過使用指針來遍歷A和B若是發現相同元素則進行刪除，若是沒有相同元素則添加。

下面給出示例代碼：

/**
 * @Author   明志
 * @Detail   實現集合運算（A-B）∪（B-A）
 * @DateTime 2019-11-02
 * @Tools    sublime text3 + gcc
 */
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>

typedef char ElemType;   //聲明元素類型

//聲明單鏈表的存儲結構
typedef struct LNode
{
    ElemType data;
    struct LNode* next;

}LNode, *LinkList;

//初始化單鏈表

void InitList(LinkList* L)  //注意：這裏的L是二級指針
{
    *L = (LinkList)malloc(sizeof(LNode)); //分配空間
    if (!(*L))
    {
        printf("the allocation space error!");
        exit(0);
    }
    (*L)->next = NULL;
}

//銷燬單鏈表
void DestroyList(LinkList *L)
{
    LinkList q;
    while (*L)
    {
        q = (*L)->next;
        free(*L);  //釋放頭結點
        *L = q;   //L指向原首元節點，實現頭結點
    }
}

//將單鏈表重置爲空表
void ClearList(LinkList L)
{
    LinkList p = L->next; //p指向第一個結點
    L->next = NULL;   //頭結點指針域爲空
    DestroyList(&p);  //銷燬p所指向的單鏈表

}

//判斷單鏈表是否爲空表
int ListEmpty(LinkList L)
{
    if (L->next) //非空
    {
        return 0;
    }
    else
    {
        return 1;
    }

}

//返回L中的數據元素個數
int ListLength(LinkList L)
{
    int i = 0;
    LinkList p = L->next; //p指向第一個結點
    while (p)
    {
        i++;
        p = p->next;  //p指向下一個結點
    }
    return i;

}


//獲取單鏈表中的第i個元素
int GetElem(LinkList L, int i, ElemType *e)
{
    int j = 1;
    LinkList p = L->next; //p指向第一個結點
    while (p && j < i)
    {
        j++; //計數器加一
        p = p->next;  //p指向下一個結點
    }

    if ((!p) || (j > i)) //結點不存在
    {
        return 0;
    }
    *e = p->data;  //獲取第i個元素
    return 1;
}

//返回L中第一個與e存在關係的元素的位置
int LocateElem(LinkList L, ElemType e, int(*compare)(ElemType, ElemType))
{
    int i = 0;
    LinkList p = L->next; //p指向第一個結點
    while (p)  //未到表尾
    {
        i++;
        if (compare(p->data, e))  //找出數據元素
        {
            return i;
        }
        p = p->next;  //p指向下一個結點
    }
    return 0;  //知足關係的數據元素不存在
}

//比較兩個元素是否相等
int ListCompare(ElemType e1, ElemType e2)
{
    if (e1 == e2)
    {
        return 1;
    }
    else
    {
        return 0;
    }

}
//在帶頭結點的單鏈表L中第i個位置以前插入元素e
int ListInsert(LinkList L, int i, ElemType e)
{
    int j = 0;
    LinkList s, p = L;   //p指向頭結點
    while (p && j < i - 1)  //尋找第i - 1個結點
    {
        j++;
        p = p->next;  //p指向下一個結點
    }
    if (!p || j > i - 1)
    {
        return -1;   //插入失敗
    }
    s = (LinkList)malloc(sizeof(LNode));  //生成新節點，如下將其插入L中
    s->data = e;      //將e賦值給新節點
    s->next = p->next; //新節點指向原第i個結點
    p->next = s;      //原第i-1個結點指向新節點
    return 1;     //成功插入
}

//在單鏈表中刪除第i個元素而且用e返回
int ListDelete(LinkList L, int i, ElemType *e)
{
    int j = 0;
    LinkList q, p = L;
    while (p->next && j < i - 1)
    {
        j++;
        p = p->next;   //p指向下一個結點
    }

    if (!p->next || j > i - 1)  //刪除位置不合理
    {
        return -1;
    }

    q = p->next;  //指向待刪除的結點
    p->next = q->next;   //
    *e = q->data;
    free(q);
    return 1;

}

//打印函數
void Display(ElemType e)
{
    printf("%c, ", e);

}
//將元素輸出
void ListTraverse(LinkList L, void(*visit)(ElemType))
{
    LinkList p = L->next;
    while (p)
    {
        visit(p->data);
        p = p->next;
    }
    printf("\n");
}

//求和函數
void ListAdd(LinkList &list1, LinkList &list2)
{
    ElemType e;   //用來暫時存放元素
    LinkList p1 = list1->next;    //首先將指針賦值給變量p1和p2，使用指針來遍歷鏈表
    LinkList p2 = list2->next;

    while (p1)
    {
        while (p2)
        {
            int pos = LocateElem(list1, p2->data, ListCompare);   //尋找元素的位置
            if (pos)   //若是元素存在，則將元素刪除
            {
                ListDelete(list1, pos, &e);  //刪除元素
            }
            else
            {
                ListInsert(list1, 1, p2->data);   //插入元素
            }
            p2 = p2->next;   //移動指針，遍歷鏈表
        }

        p1 = p1->next; //移動指針，遍歷鏈表
    }


}

int main(void)
{
    char A[] = {'c', 'b', 'e', 'g', 'f', 'd'};  //初始化插入元素
    char B[] = {'a', 'b', 'n', 'f'};
    LinkList list1;    //用鏈表來保存數據
    LinkList list2;

    InitList(&list1);   //初始化鏈表
    InitList(&list2);
    //初始化鏈表
    for (int i = 0; i < 6; i++)
    {
        ListInsert(list1, i + 1, A[i]);    //將鏈表初始化
    }

    for (int i = 0; i < 4; i++)
    {
        ListInsert(list2, i + 1, B[i]);    //將鏈表初始化
    }

    ListTraverse(list1, Display);     //顯示鏈表當前狀態
    ListTraverse(list2, Display);

    ListAdd(list1, list2);
    //輸出鏈表的結果
    ListTraverse(list1, Display);    //顯示結果
    ClearList(list1);
        ClearList(list2);
    system("pause");    //讓程序等待

    return 0;
}

測試結果：

注：

上面程序在遍歷鏈表查找相同元素時，效率還不是很高，若是你有更好的想法歡迎給我留言。