時間複雜度O(3n)

不是很難，直接貼程式碼：

StaticLinkList.h

#ifndef _STATIC_LINK_LIST_H_
#define _STATIC_LINK_LIST_H_
#define MAXSIZE 100
typedef enum {ERROR,OK}Status;
typedef struct{
    int cur;
int data;
}StaticLinkList[MAXSIZE];
void initStaticLinkList(StaticLinkList staticLinkList);
int sll_Malloc(StaticLinkList staticLinkList);
 
void sll_Free(StaticLinkList staticLinkList,int k);
void sll_Insert(StaticLinkList staticLinkList,int k,int data);
int sll_length(StaticLinkList staticLinkList);
void sll_traverse(StaticLinkList staticLinkList,void(*pfun)(int));
void sll_add(StaticLinkList staticLinkList,int data);
void sll_del(StaticLinkList 
 
staticLinkList,int k);
#endif

StaticLinkList.c

#include "StaticLinkList.h"
/**
 * 初始化靜態連結串列 * @param staticLinkList
 */
/**
 * 總結： * 1.對陣列的第一個和最後一個元素做特殊的處理，他們的data不存放資料.
 * 2.通常把未使用的陣列元素稱為備用連結串列.
 * 3.陣列的第一個元素，即下標為0的那個元素的cur存放備用連結串列的第一個節點的下標.
 * 4.陣列的最後一個元素(MAXSIZE-1)則存放第一個有數值的元素的下標，相當於單鏈表中的頭結點作用 * @param staticLinkList
 
 */
void initStaticLinkList(StaticLinkList staticLinkList)
{
    int i=0;
for(;i<MAXSIZE-1;i++)
        staticLinkList[i].cur = i+1;
staticLinkList[MAXSIZE-1].cur = 0;
}

/**
 * 分配一個備用節點 * @param staticLinkList
 * @return
 */
int sll_Malloc(StaticLinkList staticLinkList)
{
    int k = staticLinkList[0].cur;
if(staticLinkList[0].cur)
        staticLinkList[0].cur = staticLinkList[k].cur;
return k;
}

/**
 * 新增data到尾部 * @param staticLinkList
 * @param data
 */
void sll_add(StaticLinkList staticLinkList,int data)
{
    int k = sll_Malloc(staticLinkList);
staticLinkList[k].data = data;
staticLinkList[k].cur = 0;
int start = staticLinkList[MAXSIZE-1].cur;
int pre = MAXSIZE-1;
while(start)
    {
        pre = start;
start = staticLinkList[start].cur;
}

    staticLinkList[pre].cur = k;
}

/**
 *
 * @param staticLinkList
 * @param k 將下標為k的節點收回到備用連結串列 */
void sll_Free(StaticLinkList staticLinkList,int k)
{
    staticLinkList[k].cur = staticLinkList[0].cur;
staticLinkList[0].cur = k;
}


/**
 * 將data插入到連結串列的第k個位置處 * @param staticLinkList
 * @param k
 * @param data
 */
void sll_Insert(StaticLinkList staticLinkList,int k,int data)
{
    if(k<1 || k>sll_length(staticLinkList)+1)//如果超出範圍
return;
int start = staticLinkList[MAXSIZE-1].cur;
int j = 1;
int pre = MAXSIZE-1;
while(start && j<k){
        pre = start;
start = staticLinkList[start].cur;
j++;
}

    if(start)
    {
        int l = sll_Malloc(staticLinkList);
staticLinkList[l].data = data;
staticLinkList[l].cur = start;
staticLinkList[pre].cur = l;
}
}

int sll_length(StaticLinkList staticLinkList)
{

    int start = staticLinkList[MAXSIZE-1].cur;
int j = 1;
while(start && j<MAXSIZE-2)
    {
        start = staticLinkList[start].cur;
j++;
}

    return j;
}

void sll_traverse(StaticLinkList staticLinkList,void(*pfun)(int))
{
    int start = staticLinkList[MAXSIZE-1].cur;
while(start)
    {
        pfun(staticLinkList[start].data);
start = staticLinkList[start].cur;
}
}

/**
 * 刪除位置為k的元素 * @param staticLinkList
 * @param k
 */
void sll_del(StaticLinkList staticLinkList,int k)
{
    int start = staticLinkList[MAXSIZE-1].cur;
int j = 1;
int pre = MAXSIZE-1; //上一個元素的遊標
while(start && j<k){
        pre = start;
start = staticLinkList[start].cur;
}

    staticLinkList[pre].cur = staticLinkList[start].cur;
sll_Free(staticLinkList,start);
}

main2.c

#include "StaticLinkList.h"
#include <stdio.h>
#include <stdbool.h>
void pfun(int data);
/**
 * 進行集合的減法運算 * @param sa
 * @param sb
 * @param staticLinkList
 */
void sll_sub(const StaticLinkList sa,const StaticLinkList sb,StaticLinkList staticLinkList)
;
/**
 * 進行並集運算 */
void sll_or(StaticLinkList sa,StaticLinkList sb, StaticLinkList staticLinkList)
;
//靜態連結串列實現（A-B）U（B-A)
void difference(const StaticLinkList sa,const StaticLinkList sb,StaticLinkList * staticLinkList);
int main(void)
{

 StaticLinkList s1,s2,s3;
initStaticLinkList(s1);
sll_add(s1,2);
sll_add(s1,3);
sll_add(s1,4);
sll_add(s1,5);
sll_add(s1,7);
initStaticLinkList(s2);
sll_add(s2,5);
sll_add(s2,6);
sll_add(s2,7);
sll_add(s2,8);
sll_add(s2,9);
initStaticLinkList(s3);
difference(s1,s2,&s3);
sll_traverse(s3,pfun);
return 0;
}
//靜態連結串列實現（A-B）U（B-A)
void difference(const StaticLinkList sa,const StaticLinkList sb,StaticLinkList * staticLinkList){
    StaticLinkList s1,s2,s3;
initStaticLinkList(s1);
initStaticLinkList(s2);
initStaticLinkList(s3);
sll_sub(sa,sb,s1);//sa-sb
sll_sub(sb,sa,s2);//sb-sa
sll_or(s1,s2,s3);//s3=s1Us2
sll_traverse(s3,pfun);
}

/**
 * 進行集合的減法運算 * @param sa
 * @param sb
 * @param staticLinkList
 */
void sll_sub(const StaticLinkList sa,const StaticLinkList sb,StaticLinkList staticLinkList)
{
    int s1 = sa[MAXSIZE -1].cur;
int s2 = sb[MAXSIZE -1].cur;
while(s1 && s2)
    {
        if(sa[s1].data == sb[s2].data)
        {
            s1 = sa[s1].cur;
s2 = sb[s2].cur;
}else if(sa[s1].data > sb[s2].data)
        {
            sll_add(staticLinkList,sb[s2].data);
s2 = sb[s2].cur;
}else{
            sll_add(staticLinkList,sa[s1].data);
s1 = sa[s1].cur;
}

        //135
        //567
        //135
        //234
}

    while(s1)
    {
        sll_add(staticLinkList,sa[s1].data);
s1 = sa[s1].cur;
}

    while(s2)
    {
        sll_add(staticLinkList,sb[s2].data);
s2 = sb[s2].cur;
}
}

/**
 * 進行並集運算 */
void sll_or(StaticLinkList sa,StaticLinkList sb, StaticLinkList staticLinkList)
{
    int s1,s2;
s1 = sa[MAXSIZE-1].cur;
s2 = sb[MAXSIZE-1].cur;
while(s1 && s2)
    {
        if(sa[s1].data == sb[s2].data)
        {
            sll_add(staticLinkList,sa[s1].data);
s1 = sa[s1].cur;
s2 = sb[s2].cur;
}else if(sa[s1].data < sb[s2].data)
        {
            sll_add(staticLinkList,sa[s1].data);
s1 = sa[s1].cur;
}else{
            sll_add(staticLinkList,sb[s2].data);
s2 = sb[s2].cur;
}
    }

    while(s1)
    {
        sll_add(staticLinkList,sa[s1].data);
s1 = sa[s1].cur;
}

    while(s2)
    {
        sll_add(staticLinkList,sb[s2].data);
s2 = sb[s2].cur;
}

}
void pfun(int data)
{
    printf("%d ",data);
}

   //測試用例
//A = {2,3,4,5,7}
//B = {5,6,7,8,9}
//A - B = {2,3,4}
//B - A = {6,8,9}
//(A-B)U(B-A) = {2,3,4,6,8,9}

結果：