C语言数据结构之静态链表实现（A-B）U（B-A)

时间复杂度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;
        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;
        start = staticLinkList[start].cur;
    }

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

main2.c

#include "StaticLinkList.h"
#include 
#include 


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}

结果：