数据结构-有序单链表的集合运算

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

#include "stdafx.h"
#include "malloc.h"
typedef struct Node
{
    char data;
    Node *next;
}List;// 创建单链表
void CreateList(List *&L, char a[], int n)
{
    List *s,*r;
    L = (List *)malloc(sizeof(List));
    L->next = NULL;
    r = L;
    for (int i = 0; i < n; i++)
    {
        s = (List *)malloc(sizeof(List));
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}// 使用了排序算法中的插入排序
void Sort(List *&head)
{
    List *p = head->next, *q, *r; // p指向第一个节点
    if(p!=NULL)
    {
        r = p->next; // r指向第二个节点
        p->next = NULL; // p的后继节点为NULL
        p = r; // p指向第一个节点
        while (p!=NULL)
        {
            r = p->next; 
            q = head;
            while (q->next!=NULL &&q->next->data<p->data)
            {
                q = q->next;
            }
            p->next = q->next;
            q->next = p;
            p = r;
        }
    }
}
 
// 求两个集合并集
void Union(List *La, List *Lb, List *&Lc)
{
    List *la = La->next, *lb = Lb->next,*tc,*s;
    Lc = (List *)malloc(sizeof(List));
    tc = Lc;
    // 在进行比较
    if (la != NULL && lb != NULL)
    {
        while (la != NULL && lb != NULL)
        {
            s = (List *)malloc(sizeof(List));
            if (la->data > lb->data)
            {
                // la节点大于lb节点
                s->data = lb->data;
                tc->next = s;
                tc = s;
                lb = lb->next;
            }
            else if(la->data<lb->data)
            {
                 // la节点小于lb节点
                s->data = la->data;
                tc->next = s;
                tc = s;
                la = la->next;
            }
            else
            {
                s->data = la->data;
                tc->next = s;
                tc = s;
                la = la->next;
                lb = lb->next;
            }
        }
    }
 
    //  剩余节点(la与lb必定有一个是NULL)
    if (lb != NULL)
    {
        la = lb;
    }
    while (la!=NULL)
    {
        s = (List *)malloc(sizeof(List));
        s->data = la->data;
        tc->next = s;
        tc = s;
        la = la->next;
    }
    tc->next = NULL;
}
 
// 求两个集合的并集
void  InterSect(List *La, List *Lb, List *&Lc)
{
    List *la = La->next, *lb,*tc, *s;
    Lc = (List *)malloc(sizeof(List));
    tc = Lc;
    while (la!=NULL)
    {
        lb = Lb->next;
        // 根据链表为有序链表过滤一部分比较节点
        while (lb!=NULL && lb->data<la->data)
        {
            lb = lb->next;
        }
        if (lb != NULL && lb->data == la->data)
        {
            s = (List *)malloc(sizeof(List));
            s->data = la->data;
            tc->next = s;
            tc = s;
        }
        la = la->next;
    }
    tc->next = NULL;
}
 
// 求差集，即a-b，去掉a链表中与b链表的交集
void Subs(List *La, List *Lb, List *&Lc)
{
    List *la = La->next, *lb, *tc, *s;
    Lc = (List *)malloc(sizeof(List));
    tc = Lc;
    while (la!=NULL)
    {
        lb = Lb->next;
        // 根据链表为有序链表过滤一部分比较节点
        while (lb!=NULL && lb->data<la->data)
        {
            lb = lb->next;
        }
        // 去掉Lb链表与La链表的交集部分
        if (!(lb != NULL &&la->data == lb->data))
        {
            s = (List *)malloc(sizeof(List));
            s->data = la->data;
            tc->next = s;
            tc = s;
        }
        la = la->next;
    }
    tc->next = NULL;
}