数据结构上机实验（2）

1、顺序表的各种基本运算操作

#include <stdio.h>
#include<stdlib.h>
#define MaxSize 50

typedef char ElemType;
typedef struct 
{
ElemType elem[MaxSize];
   int length;
} SqList;

//初始化 O(1)
void InitList(SqList *&L)
{
L=(SqList *)malloc(sizeof(SqList));
L->length=0;
}
//销毁 O(1)
void DestroyList(SqList *L)
{
free(L);
}
//判断是否为空 O(1)
int ListEmpty(SqList *L)
{
return(L->length==0);
}
//求长度 O(1)
int ListLength(SqList *L)
{
return(L->length);
}
//输出顺序表 O(n)
void DispList(SqList *L)
{
int i;
if (ListEmpty(L)) return;
for (i=0;i<L->length;i++)
   printf("%c",L->elem[i]);
printf("
");
}
//获取第i个位置上的元素返回给e O(1)
int GetElem(SqList *L,int i,ElemType &e)
{
if (i<1 || i>L->length)
   return 0;
e=L->elem[i-1];
return e;
}
//查找返回元素e的位置  O(n)
int LocateElem(SqList *L, ElemType e)
{
int i=0;
while (i<L->length && L->elem[i]!=e) i++;
if (i>=L->length)
   return 0;
else
   return i+1;
}
//把元素e插入到位置i O(n)
bool ListInsert(SqList *&L,int i,ElemType e)
{
int j;
if (i<1 || i>L->length+1)
   return false;
i--;        //将顺序表位序转化为elem下标
for (j=L->length;j>i;j--)   //将elem[i]及后面元素后移一个位置
   L->elem[j]=L->elem[j-1];
L->elem[i]=e;
L->length++;     
return true;
}
//删除位置i上的元素 O(n)
bool ListDelete(SqList *&L,int i,ElemType &e)
{
int j;
if (i<1 || i>L->length)
   return false;
i--;        //将顺序表位序转化为elem下标
e=L->elem[i];
for (j=i;j<L->length-1;j++)   //将elem[i]及后面元素前移一个位置
   L->elem[j]=L->elem[j+1];
L->length--;
return true;
}

int main()
{
SqList *L;
ElemType e;
printf("(1)初始化顺序表L
");
InitList(L);
printf("(2)依次采用尾插法插入a,b,c,d,e元素
");
ListInsert(L,1,'a');
ListInsert(L,2,'b');
ListInsert(L,3,'c');
ListInsert(L,4,'d');
ListInsert(L,5,'e');
printf("(3)输出顺序表L:");
DispList(L);
printf("(4)顺序表L长度=%d
",ListLength(L));
printf("(5)顺序表L为%s
",(ListEmpty(L)?"空":"非空"));
GetElem(L,4,e);
printf("(6)顺序表L的第4个元素=%c
",e);
printf("(7)元素a的位置=%d
",LocateElem(L,'a'));
printf("(8)在第3个元素位置上插入f元素
");
ListInsert(L,3,'f');
printf("(9)输出顺序表L:");
DispList(L);
printf("(10)删除L的第4个元素
");
    ListDelete(L,4,e);
printf("(11)输出顺序表L:");
DispList(L);
printf("(12)释放顺序表L
");
DestroyList(L);
}

2、单链表的各种基本运算算法

#include<stdio.h>
#include<stdlib.h>

typedef char ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
} LinkList;

//两种插入学习
//使用头插法
void CreateListF(LinkList *&L,ElemType a[],int n)
{
    LinkList *s;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
    for(i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        s->next=L->next;
        L->next=s;
    }
}
//使用尾插法
void CreateListR(LinkList *&L,ElemType a[],int n)
{
    LinkList *s,*r;
    int i;
    L=(LinkList *)malloc(sizeof(LinkList));
    r=L;
    for(i=0; i<n; i++)
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=a[i];
        r->next=s;
        r=s;
    }
    r->next=NULL;
}

//初始化线性表 O(1)
void InitList(LinkList *&L)
{
    L=(LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
}
//销毁线性表 O(n)
void DestroyList(LinkList *&L)
{
    LinkList *pre=L,*p=L->next;
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;
    }
    free(pre);
}
//判断线性表是否为空表 O(1)
bool ListEmpty(LinkList *L)
{
    return (L->next==NULL);
}
//求线性表的长度 O(n)
int ListLength(LinkList *L)
{
    int n=0;
    LinkList *p=L;
    while(p->next!=NULL)
    {
        n++;
        p=p->next;
    }
    return (n);
}
//输出线性表 O(n)
void DispList(LinkList *L)
{
    LinkList *p=L->next;
    while(p!=NULL)
    {
        printf("%c",p->data);
        p=p->next;
    }
    printf("
");
}
//求线性表中某个数据元素值  O(n)
int GetElem(LinkList *L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L;
    while(j<i&&p!=NULL) //题目中i默认大于0
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return 0;
    else
    {
        e=p->data;
        return e;
    }
}
//按元素值查找 O(n)
int LocateElem(LinkList *L,ElemType e)
{
    int i=1;
    LinkList *p=L->next;
    while(p!=NULL&&p->data!=e)
    {
        p=p->next;
        i++;
    }
    if(p==NULL)
        return 0;
    else
        return i;
}
//插入数据元素 O(n)
bool ListInsert(LinkList *&L,int i,ElemType e)
{
    int j=0;
    LinkList *p=L,*s;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        s=(LinkList *)malloc(sizeof(LinkList));
        s->data=e;
        s->next=p->next;
        p->next=s;
        return true;
    }
 
}
//删除数据元素 O(n)
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j=0;
    LinkList *p=L,*q;
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else
    {
        q=p->next;
        if(q==NULL)
            return false;
        e=q->data;
        p->next=q->next;
        free(q);
        return true;
    }
}
 
int main()
{
    LinkList *L;
    char s[5]= {'a','b','c','d','e'};
    char e;
    int i,j;
    printf("(1)初始化单链表L
");
    InitList(L);
    printf("(2)采用尾插法插入a,b,c,d,e元素");
    CreateListR(L,s,5);
    printf("
");
    printf("(3)输出单链表L:");
    DispList(L);
    printf("(4)单链表L长度=%d
",ListLength(L));
    i=ListEmpty(L);
    if(i==0)
    {
        printf("(5)该单链表L非空
");
    }
    else
    {
        printf("(5)该单链表L为空
");
    }
    e=GetElem(L,3,e);
    printf("(6)第三个元素为：%c
",e);
    j=LocateElem(L,'a');
    printf("(7)元素a为第%d个元素
",j);
    printf("(8)在第4个元素位置上插入f元素
");
    ListInsert(L,4,'f');
    printf("(9)输出单链表L:");
    DispList(L);
    printf("(10)删除L的第3个元素
");
    ListDelete(L,3,e);
    printf("(11)输出单链表L:");
    DispList(L);
    printf("(12)释放单链表L
");
    DestroyList(L);
}

3、双链表的各种基本运算算法

#include <stdio.h>
#include <stdlib.h>

typedef char ElemType;
typedef struct DNode
{
    ElemType data;
    struct DNode *prior;   //指向前驱结点
    struct DNode *next;   //指向后继结点
}DLinkNode;//声明双链表结点类型;

//尾插法建立双链表
void CreateListR(DLinkNode *&L,ElemType a[],int n)
{
    DLinkNode *s,*r;
    //创建头结点
    L=(DLinkNode *)malloc(sizeof(DLinkNode));
    L->prior=L->next=NULL;
    r=L;   //r始终指向终端结点,开始时指向头结点
    for (int i = 0; i < n; i++)
    {
        //创建新结点
        s=(DLinkNode *)malloc(sizeof(DLinkNode));
        //数据域
        s->data=a[i];
        //将节点s插入到节点r之后
        r->next=s;
        s->prior=r;
        r=s;
    }
    r->next=NULL;   //尾结点next域置空
}

//初始化双链表
void InitList(DLinkNode *&L)
{
    L=(DLinkNode *)malloc(sizeof(DLinkNode));
    L->prior=L->next=NULL;
}
//销毁双链表
void DestroyList(DLinkNode *&L)
{
    DLinkNode *pre=L, *p=pre->next;
    while(p!=NULL)
    {
        free(pre);
        //pre,p同步后移一个节点
        pre=p;
        p=pre->next;
    }
    free(p);
}
//判断是否为空
bool ListEmpty(DLinkNode *L)
{
    return(L->next==NULL);
}
//求长度
int ListLength(DLinkNode *L)
{
    DLinkNode *p=L;
    int i=0;   //p指向头结点 i设置为0
    while(p->next!=NULL)
    {
        i++;
        p=p->next;
    }
    return i;
}
//输出线性表
void DispList(DLinkNode *L)
{
    DLinkNode *p=L->next;
    while(p!=NULL)
    {
        printf("%c",p->data);
        p=p->next;
    }
     printf("
");
}
//求线性表中第i个元素值
int GetElem(DLinkNode *L,int i,ElemType &e)
{
    int j=0;
    DLinkNode *p=L;
    //查找第i个结点p
    while(j<i&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if (p==NULL)
        return 0;
    else   //找到了
    {
        e=p->data;
        return e;
    }
}
//按元素值查找
int LocateElem(DLinkNode *L,ElemType e)
{
    int i=1;
    DLinkNode *p=L->next;
    while(p!=NULL&&p->data!=e)
    {
        i++;   //i对应结点p的序号
        p=p->next;
    }
    if (p==NULL)
        return 0;
    else
        return i;
}
//插入数据元素
bool ListInsert(DLinkNode *&L,int i,ElemType e)
{
    int j=0;
    DLinkNode *p=L,*s;    // p指向头结点,j设置为0
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if (p==NULL)
        return false;
    else   //找到第i-1个结点p
    {
        //创建新结点s
        s=(DLinkNode *)malloc(sizeof(DLinkNode));
        s->data=e;
        //将节点s插入到节点p之后
        s->next=p->next;
        if(p->next!=NULL)
            p->next->prior=s;
        s->prior=p;
        p->next=s;
        return true;
    }
}
//删除数据元素 
bool ListDelete(DLinkNode *&L,int i,ElemType &e)
{
    int j=0;
    DLinkNode *p=L,*q;    //p指向头结点,j设置为0
    while(j<i-1&&p!=NULL)
    {
        j++;
        p=p->next;
    }
    if(p==NULL)
        return false;
    else   //找到第i-1个结点p
    {
        q=p->next;   //q指向第i个结点
        //当不存在第i个结点时返回false
        if(q==NULL)
            return false;
        e=q->data;
        //从双链表中删除结点q
        p->next=q->next;
        //若p结点存在后继结点,修改其前驱指针
        if(p->next != NULL)
            p->next->prior = p;
        //释放q结点
        free(q);
        return true;
    }
}

int main()
{
    DLinkNode *h;
    ElemType e;

    printf("(1)初始化双链表h
");
    InitList(h);
    printf("(2)依次采用尾插法插入a,b,c,d,e元素
");
    ListInsert(h, 1, 'a');
    ListInsert(h, 2, 'b');
    ListInsert(h, 3, 'c');
    ListInsert(h, 4, 'd');
    ListInsert(h, 5, 'e');
    printf("(3)输出双链表h:");
    DispList(h);
    printf("(4)双链表h长度:%d
", ListLength(h));
    printf("(5)双链表h为%s
", (ListEmpty(h) ? "空" : "非空"));
    GetElem(h, 3, e);
    printf("(6)双链表h的第3个元素:%c
", e);
    printf("(7)元素e的位置:%d
", LocateElem(h, 'e'));
    printf("(8)在第4个元素位置上插入f元素
");
    ListInsert(h, 4, 'f');
    printf("(9)输出双链表h:");
    DispList(h);
    printf("(10)删除h的第3个元素
");
    ListDelete(h, 3, e);
    printf("(11)输出双链表h:");
    DispList(h);
    printf("(12)释放双链表h
");
    DestroyList(h);
} 

4、循环单链表的各种基本运算操作

#include <stdio.h>
#include <malloc.h>

//学习自CSDN作者-静能生悟，循环单链表主要看插入和删除操作的代码实现即可

typedef char ElemType;
typedef struct LNode   // 定义循环单链表结点类型
{
    ElemType data;   // 数据域
    struct LNode *next;   // 指针域
}CLinkList;

//初始化
void InitList(CLinkList *&L)   // 指针的引用
{
    L = (CLinkList *)malloc(sizeof(CLinkList));   //创建头结点
    L->next = L;
}

//销毁循环单链表L
void DestroyList(CLinkList *&L)
{
    CLinkList *p = L;
    CLinkList *q = p->next;
    
    while(q != L)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

//判断是否为空表
int ListEmpty(CLinkList *L)
{
    return (L->next == L);            
}

//求长度
int ListLength(CLinkList *L)
{
    int i = 0;
    CLinkList *p = L;
    
    while(p->next != L)
    {
        i++;
        p = p->next;
    }
    
    return i;
}

//输出循环单链表L
void DispList(CLinkList *L)
{
    CLinkList *p = L->next;
    
    while(p != L)
    {
        printf("%c ", p->data);
        p = p->next;
    }
    printf("
");
}

//获取循环单链表L中的第i个元素
int GetElem(CLinkList *L, int i, ElemType &e)    
{
    int j = 0;
    CLinkList *p;
    
    if(L->next != L)   // 单链表为非空表时
    {
        if(i == 1)
        {
            e = L->next->data;   // 提取元素
            return 1;
        }
        else   // i不为1时
        {
            p = L->next;
            while((p != L) && (j < i - 1))
            {
                j++;
                p = p->next;
            }
            if(p == L)
                return 0;
            else   // 找到第i个元素
            {
                e = p->data;    
                return e;
            }
        }
    }
    else                        // 单链表为空表时
        return 0;
}

//在循环单链表L中查找元素e
int LocateElem(CLinkList *L, ElemType e)
{
    int n = 1;
    CLinkList *p = L->next;
    
    while((p != L) && (p->data != e))
    {
        p = p->next;
        n++;
    }
    
    if(p == L)
        return 0;
    else
        return n;
}

//在循环单链表L中第i个位置上插入元素e
int ListInsert(CLinkList *&L, int i, ElemType e)
{
    int j = 0;
    CLinkList *p = L, *s;
    
    if((i == 1) || (p->next == L))                        // 原单链表为空表或i=1时
    {
        s = (CLinkList *)malloc(sizeof(CLinkList));        // 创建新结点s
        s->data = e;
        s->next = p ->next;                                // 将s插入到p之后
        p->next = s;
        return 1;
    }
    else
    {
        p = L->next;
        while((p != L) && (j < i - 2))                    // 查找第i-1个结点
        {
            j++;
            p = p->next;
        }
        
        if(p == L)                                        // 未找到第i-1个结点
            return 0;
        else                                            // 找到第i-1个结点
        {
            s = (CLinkList *)malloc(sizeof(CLinkList));    // 创建新结点s
            s->data = e;
            s->next = p->next;                            // 将s插入到p之后
            p->next = s;
            return 1;
        }
    }
}

//在循环单链表L中删除第i个元素
int ListDelete(CLinkList *&L, int i, ElemType &e)
{
    int j = 0;
    CLinkList *p = L, *q;
    
    if(p->next != L)                                    // 原单链表不为空表时
    {
        if(i == 1)                                        // i=1时
        {
            q = L->next;                                // 删除第1个结点
            e = q->data;
            L->next = q->next;
            free(q);
            return 1;
        }
        else                                            // i不为1时
        {
            p = L->next;
            while((p != L) && (j < i - 2))                // 查找第i-1个结点                    
            {
                j++;
                p = p->next;
            }
            if(p == L)                                    // 未查找到第i-1个结点    
                return 0;
            else                                        // 查找到第i-1个结点    
            {
                q = p->next;                            // q指向要删除的结点
                e = q->data;                            // 提取元素
                p->next = q->next;                        // 从单链表中删除q结点
                free(q);                                // 释放q结点
            }
        }
    }
    else
        return 0;
}

int main()
{
    CLinkList *h;
    ElemType e;
    
    printf("(1)初始化循环单链表h
");
    InitList(h);
    printf("(2)依次采用尾部插入法插入a,b,c,d,e元素
");
    ListInsert(h, 1, 'a');
    ListInsert(h, 2, 'b');
    ListInsert(h, 3, 'c');
    ListInsert(h, 4, 'd');
    ListInsert(h, 5, 'e');
    printf("(3)输出循环单链表h:");
    DispList(h);
    printf("(4)循环单链表h长度=%d
", ListLength(h));
    printf("(5)循环单链表h为%s
", (ListEmpty(h) ? "空" : "非空"));
    GetElem(h, 3, e);
    printf("(6)循环单链表h的第3个元素=%c
", e);
    printf("(7)元素a的位置=%d
", LocateElem(h, 'a'));
    printf("(8)在第4个元素位置上插入f元素
");
    ListInsert(h, 4, 'f');
    printf("(9)输出循环单链表h:");
    DispList(h);
    printf("(10)删除h的第3个元素
");
    ListDelete(h, 3, e);
    printf("(11)输出循环单链表h:");
    DispList(h);
    printf("(12)释放循环单链表h
");
    DestroyList(h);
}

5、循环双链表的各种基本运算操作

#include <stdio.h>
#include <malloc.h>

//学习自CSDN作者-静能生悟，循环双链表主要看插入和删除操作的代码实现即可

typedef char ElemType;
typedef struct DNode                        // 定义循环双链表结点类型
{
    ElemType data;                            // 数据域
    struct DNode *prior;                    // 指向直接前驱结点
    struct DNode *next;                        // 指向直接后继结点
}CDLinkList;


//初始化
void InitList(CDLinkList *&L)    // 指针的引用
{
    L = (CDLinkList *)malloc(sizeof(CDLinkList));            // 创建头结点
    L->prior = L->next = L;
}

//销毁循环双链表L
void DestroyList(CDLinkList *&L)
{
    CDLinkList *p = L;
    CDLinkList *q = p->next;
    
    while(q != L)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

//判断循环双链表L是否为空表
int ListEmpty(CDLinkList *L)
{
    return (L->next == L);
}

//求长度
int ListLength(CDLinkList *L)
{
    int i = 0;
    CDLinkList *p = L;
    
    while(p->next != L)
    {
        i++;
        p = p->next;
    }
    return i;
}

//输出循环双链表L
void DispList(CDLinkList *L)
{
    CDLinkList *p = L->next;
    
    while(p != L)
    {
        printf("%c ", p->data);
        p = p->next;
    }
    printf("
");
}

//获取循环双链表L中第i个元素
int GetElem(CDLinkList *L, int i, ElemType &e)
{
    int j = 0;
    CDLinkList *p;
    
    if(L->next != L)                                // 循环双链表为非空表时
    {
        if(i == 1)
        {
            e = L->next->data;                        // 提取元素
            return 1;
        }
        else                                        // i不为1时
        {
            p = L->next;
            while((p != L) && (j < i - 1))            
            {
                j++;
                p = p->next;
            }
            if(p == L)
                return 0;
            else
            {
                e = p->data;
                return 1;
            }
        }
    }
    else                                            // 循环双链表为空表时
        return 0;
}

//在循环双链表L中查找元素e
int LocateElem(CDLinkList *L, ElemType e)
{
    int n = 1;
    CDLinkList *p = L->next;
    
    while((p != L) && (p->data != e))
    {
        n++;
        p = p->next;
    }
    if(p == NULL)
        return 0;
    else
        return n;
}

//在循环双链表L中第i个位置上插入元素e
int ListInsert(CDLinkList *&L, int i, ElemType e)
{
    int j = 0;
    CDLinkList *p = L, *s;
    
    if(p->next == L)                                    // 原双链表为空表时
    {
        s = (CDLinkList *)malloc(sizeof(CDLinkList));        // 创建新结点s
        s->data = e;
        p->next = s; s->next = p;
        p->prior = s; s->prior = p;
        return 1;
    }
    else if(i == 1)                                        // 原双链表不为空表但i=1时
    {
        s = (CDLinkList *)malloc(sizeof(CDLinkList));        // 创建新结点s
        s->data = e;
        // 将s插入到结点p之后
        s->next = p->next;
        p->next = s;
        s->next->prior = s;
        s->prior = p;
        return 1;
    }
    else
    {
        p = L->next;
        while((p != L) && (j < i - 2))
        {
            j++;
            p = p->next;
        }
        if(p == L)                                        // 未找到第i-1个结点
            return 0;
        else                                            // 找到第i-1个结点p
        {
            s = (CDLinkList *)malloc(sizeof(CDLinkList));    // 创建新结点s
            s->data = e;
            // 将s插入到结点p之后
            s->next = p->next;
            if(p ->next != NULL)
                p->next->prior = s;
            s->prior = p;
            p->next = s;
            return 1;
        }
    }
}

//在循环双链表L中删除第i个元素e
int ListDelete(CDLinkList *&L, int i, ElemType &e)
{
    int j = 0;
    CDLinkList *p = L, *q;
    
    if(p->next != L)                                    // 原双链表不为空表时
    {
        if(i == 1)                                        // i=1时
        {
            q = L->next;                                // 删除第1个结点
            e = q->data;
            L->next = q->next;
            q->next->prior = L;
            free(q);
            return 1;
        }
        else                                            // i不为1时
        {
            p = L->next;
            while((p != NULL) && (j < i - 2))
            {
                j++;
                p = p->next;
            }
            if(p == NULL)                                // 未找到第i-1个结点
                return 0;
            else                                        // 找到第i-1个结点p
            {
                q = p->next;                            // q指向要删除的结点
                if(q == NULL)                            // 不存在第i个结点
                    return 0;
                e = q->data;
                // 从链表中删除q结点
                p->next = q->next;
                if(p->next != NULL)
                    p->next->prior = p;
                free(q);
                return 1;
            }
        }
    }
    else                                                // 原双链表为空表时
        return 0;
}

int main()
{
    CDLinkList *h;
    ElemType e;
    
    printf("(1)初始化循环双链表h
");
    InitList(h);
    printf("(2)依次采用尾插入法插入a,b,c,d,e元素
");
    ListInsert(h, 1, 'a');
    ListInsert(h, 2, 'b');
    ListInsert(h, 3, 'c');
    ListInsert(h, 4, 'd');
    ListInsert(h, 5, 'e');
    printf("(3)输出循环双链表h:");
    DispList(h);
    printf("(4)循环双链表h长度=%d
", ListLength(h));
    printf("(5)循环双链表h为%s
", (ListEmpty(h) ? "空" : "非空"));
    GetElem(h, 3, e);
    printf("(6)循环双链表h的第3个元素=%c
", e);
    printf("(7)元素a的位置=%d
", LocateElem(h, 'a'));
    printf("(8)在第4个元素位置上插入f元素
");
    ListInsert(h, 4, 'f');
    printf("(9)输出循环双链表h:");
    DispList(h);
    printf("(10)删除h的第3个元素
");
    ListDelete(h, 3, e);
    printf("(11)输出循环双链表h:");
    DispList(h);
    printf("(12)释放循环双链表h
");
    DestroyList(h);
}

6、将单链表按基准划分

#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode
{
    ElemType data;   //数据域
    struct LNode *next;   //指向后继结点
}LinkNode;   // 声明单链表结点类型

//尾插法建立单链表
void CreateListRear(LinkNode *&L,ElemType a[],int n)
{
    LinkNode *s,*r;
    int i;
    L=(LinkNode *)malloc(sizeof(LinkNode));   //创建头结点
    r=L;   //r始终指向尾结点，开始时指向头结点
    for (int i = 0; i < n; i++)
    {
        //创建新结点s
        s=(LinkNode *)malloc(sizeof(LinkNode));
        s->data=a[i];
        r->next=s;   //将s插入r之后
        r=s;
    }
    r->next=NULL;    //尾结点next域置为NULL
}
//输出单链表
void DispList(LinkNode *L)
{
    LinkNode *p=L->next;   //p指向首节点
    while(p!=NULL)
    {
        printf("%d",p->data );   // p不为NULL,输出p结点的数据域
        p=p->next;    // p移向下一个结点
    }
    printf("
");
}
//销毁单链表
void DestroyList(LinkNode *L)
{
    LinkNode *pre=L,*p=L->next;    //pre指向头结点，p指向首节点
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;   // pre、p同步后移一个结点
    }
    free(pre);    // 此时p为NULL,pre指向尾结点,释放它
}
//将L中所有数据结点按e进行划分 【本题核心代码】
void split(LinkNode *&L,ElemType e)
{
    LinkNode *p=L->next,*q,*r;    //p指向首节点
    //L变为空表
    L->next=NULL;
    // r是新链表的尾结点指针
    r=L;

    while(p!=NULL)
    {
        if(p->data<e)   // 若p结点值小于e,将其插入到开头
        {
            q=p->next;
            p->next=L->next;
            L->next=p;
            // 若p结点是第一个在开头插入的结点,则它是尾结点
            if(p->next==NULL)
                r=p;
            p=q;
        }
        else    // 若p结点值大于或等于e,将其插入到末尾
        {
            r->next=p;
            r=p;
            p=p->next;
        }
    }
    r->next=NULL;
}

int main()
{
    LinkNode *L;
    //ElemType a[] = {1,2,3,5,6,7,8,9};
    ElemType a[] = {1,9,8,6,5,3,7,2};
    int n = 8;
    CreateListRear(L,a,n);
    printf("单链表L:");
    DispList(L);
    ElemType x = 4;
    printf("以%d进行划分
", x);
    split(L,x);
    printf("单链表L:");
    DispList(L);
    DestroyList(L);
}

7、将两个单链表合并成一个单链表

//注意空间复杂度O(1) 即不能开辟新的辅助空间
#include <stdio.h>
#include <malloc.h>

typedef int ElemType;
typedef struct LNode
{
    ElemType data;   //数据域
    struct LNode *next;   //指向后继结点
}LinkNode;   // 声明单链表结点类型

//尾插法建立单链表
void CreateListRear(LinkNode *&L,ElemType a[],int n)
{
    LinkNode *s,*r;
    int i;
    L=(LinkNode *)malloc(sizeof(LinkNode));   //创建头结点
    r=L;   //r始终指向尾结点，开始时指向头结点
    for (int i = 0; i < n; i++)
    {
        //创建新结点s
        s=(LinkNode *)malloc(sizeof(LinkNode));
        s->data=a[i];
        r->next=s;   //将s插入r之后
        r=s;
    }
    r->next=NULL;    //尾结点next域置为NULL
}
//输出单链表
void DispList(LinkNode *L)
{
    LinkNode *p=L->next;   //p指向首节点
    while(p!=NULL)
    {
        printf("%d ",p->data );   // p不为NULL,输出p结点的数据域
        p=p->next;    // p移向下一个结点
    }
    printf("
");
}
//销毁单链表
void DestroyList(LinkNode *L)
{
    LinkNode *pre=L,*p=L->next;    //pre指向头结点，p指向首节点
    while(p!=NULL)
    {
        free(pre);
        pre=p;
        p=pre->next;   // pre、p同步后移一个结点
    }
    free(pre);    // 此时p为NULL,pre指向尾结点,释放它
}
//合并
void MergeList(LinkNode *L1,LinkNode *L2,LinkNode *&L3)
{
    LinkNode *p = L1->next;
    LinkNode *q = L2->next;
    LinkNode *r;

    L3=L1;
    // r指向新建单链表L3的尾结点
    r=L3;
    //释放L2头结点
    free(L2);
    while(p!=NULL&&q!=NULL)
    {
        r->next=p;
        r=p;
        p=p->next;

        r->next=q;
        r=q;
        q=q->next;
    }
    r->next=NULL;
    if(q!=NULL)
        p=q;
    r->next=p;
}

int main()
{
    LinkNode *L1, *L2, *L3;
    ElemType a[] = {1,2,3,4,5,6,7,8};
    int n = 8;

    CreateListRear(L1,a,n);
    printf("单链表L1:");
    DispList(L1);
	
	ElemType b[] = {20,19,18,17};
    n = 4;
    CreateListRear(L2,b,n);
    printf("单链表L2:");
    DispList(L2);
    printf("L1和L2合并产生L3
");
    MergeList(L1,L2,L3);
    printf("单链表L3:");
    DispList(L3);
    DestroyList(L3);
}

8、求集合（用单链表表示）的并集、交集、差集运算

#include <stdio.h>
#include <stdlib.h>

//重点题型，掌握并集、交集、差集的实现

typedef int ElemType;
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LinkList;


/* 单链表的初始化 */
void InitList(LinkList *&L)
{
    L = (LinkList *)malloc(sizeof(LinkList));
    L->next=NULL;
}

//向单链表中插入数据元素
bool ListInsert(LinkList *&L,int x,char e)
{
    int j = 0;
    LinkList *p = L, *s;
    while(p!=NULL && j<x-1)
    {
        p = p->next;
        j++;
    }
    if(p==NULL)
    {
        return false;
    }
    else
    {
        s = (LinkList *)malloc(sizeof(LinkList));
        s->data = e;
        s->next = p->next;
        p->next = s;
        return true;
    }
}

//输出单链表
void DispList(LinkList *L)
{
    LinkList *p = L->next;
    while(p!=NULL)
    {
        printf("%d ",p->data);
        p = p->next;
    }
    printf("
");
}

// 求单链表的长度
int ListLength(LinkList *L)
{
    LinkList *p = L->next;
    int i = 0;
    while(p!=NULL)
    {
        i++;
        p = p->next;
    }
    return i;
}

// 查看单链表是否为空
bool ListEmpty(LinkList *L)
{
    return L->next==NULL;
}

//求单链表中某个数据元素值
bool GetElem(LinkList *L,int i, ElemType &e)
{
    LinkList *p = L;
    int j = 0;
    while(p!=NULL && j < i)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)
    {
        return false;
    }
    else
    {
        e = p->data;
        return true;
    }
}

// 在单链表中查找元素
int LocateElem(LinkList *L,ElemType e)
{
    LinkList *p = L;
    int i = 0;
    while(p!=NULL && p->data!=e)
    {
        p = p->next;
        i++;
    }
    if(p==NULL)
    {
        return 0;
    }
    else
    {
        return i;
    }
}

//删除单链表中第 i 个元素
bool ListDelete(LinkList *&L,int i,ElemType &e)
{
    int j = 0;
    LinkList *p = L, *q;
    while(p!=NULL && j < i - 1)
    {
        p = p->next;
        j++;
    }
    if(p==NULL)
        return false;
    else
    {
        q = p->next;
        if(q==NULL)
            return false;
        e = q->data;
        p->next = q->next;
        free(q);
        return true;
    }
}

//销毁单链表
void DestroyList(LinkList *&L)
{
    LinkList *p = L;
    LinkList *q = p->next;
    while(q!=NULL)
    {
        free(p);
        p = q;
        q = p->next;
    }
    free(p);
}

//将集合 a 和 b 中的元素添加到顺序表 ha 和 hb 中
void CreateListR(LinkList *&L,ElemType e[],int n)
{
    InitList(L);
    int i;
    for(i = 0;i < n; ++i)
    {
        if(!LocateElem(L,e[i]))
            ListInsert(L,i+1,e[i]);
    }
}

//选择排序
void sort(LinkList *&L)
{
    LinkList *p , *pre, *q, *k;
    InitList(p);
    int i = 0;
    int c;
    while(!ListEmpty(L))
    {
        pre = L ->next;
        c = pre->data;
        while(pre!=NULL)
        {
            if(c>=pre->data)
                c = pre->data;
            pre = pre->next;
        }
        ListInsert(p,++i,c);
        int tag = LocateElem(L,c);
        ListDelete(L,tag,c);
    }
    L = p;
}

//并集 
void Union(LinkList *a,LinkList *b,LinkList *&c)
{
    InitList(c);
    LinkList *p = a->next;
    LinkList *q = b->next;
    int k = 0;
    while(p!=NULL && q!=NULL)
    {
        if(p->data < q->data)
        {
            ListInsert(c,k+1,p->data);
            p = p->next;
            k++;
        }
        else if(p->data == q->data)
        {
            ListInsert(c,k+1,p->data);
            p = p->next;
            q = q->next;
            k++;
        }
        else
        {
            ListInsert(c,k+1,q->data);
            q = q->next;
            k++;
        }
    }
    while(p!=NULL)
    {
        ListInsert(c,k+1,p->data);
        p = p->next;
        k++;
    }
    while(q!=NULL)
    {
        ListInsert(c,k+1,q->data);
        q  = q->next;
        k++;
    }
}

//交集 a中元素一个个取出，通过LocateElem函数看b中是否出现，出现则copy至c
void InsterSect(LinkList *a,LinkList *b,LinkList *&c)
{
    DestroyList(c);
    InitList(c);
    LinkList *p = a->next;
    int i = 0;
    while(p!=NULL)
    {
        if(LocateElem(b,p->data))
            ListInsert(c,++i,p->data);
        p = p->next;
    }
}

//差集 a中元素一个个取出，通过LocateElem函数看b中是否出现，不出现则copy至c
void Subs(LinkList *a,LinkList *b,LinkList *&c)
{
    DestroyList(c);
    InitList(c);
    LinkList *p = a->next;
    int i = 0;
    while(p!=NULL)
    {
        if(!LocateElem(b,p->data))
            ListInsert(c,++i,p->data);
        p = p->next;
    }
}


int main( )
{
    LinkList *ha, *hb, *hc;
    ElemType a[]={1,2,3,4};
    ElemType b[]={10,4,22,5,81,2};
    printf("集合的运算如下
");
    CreateListR(ha,a,4);
    CreateListR(hb,b,6);
    printf("原 集 合 A: "); DispList(ha);
    printf("原 集 合 B: "); DispList(hb);
    sort(ha);
    sort(hb);
    printf("有序集合A："); DispList(ha);
    printf("有序集合B："); DispList(hb);
    Union(ha,hb,hc);
    printf("集合的并C："); DispList(hc);
    InsterSect(ha,hb,hc);
    printf("集合的交C："); DispList(hc);
    Subs(ha,hb,hc);
    printf("集合的差C："); DispList(hc);
    DestroyList(ha);
    DestroyList(hb);
    DestroyList(hc);
}

9、求两个多项式的相加运算

#include<stdio.h>
#include<stdlib.h>

//学习自CSDN作者-man_zuo

typedef struct 
{
    float coef;   //系数
    int expn;   //指数   
}Term;
typedef struct Ploynomial
{
    Term term;
    Ploynomial *next;
}Ploynomial,*LinkList;

//初始化单链表
void InitList(LinkList &L)
{
    L= (Ploynomial*)malloc(sizeof(Ploynomial));//头结点
    L->term.coef=0.0;
    L->term.expn=-1;
    L->next=NULL;
}
//比较结点的系数大小函数
int cmp(Term a,Term b)
{
    if (a.expn>b.expn) return -1;
    else if(a.expn==b.expn) return 0;
    else return 1;
}
//将结点插入多项式链表的适当位置，可以同时起到创建链表和多项式相加的功能
void insertNode(LinkList &L,Term e)
{
    Ploynomial *q=L;
    while(q->next!=NULL)
    {   //如果当前结点q的下一个结点的指数 大于 要插入的结点的指数
        if (cmp(q->next->term,e)<0)
        {
           q=q->next; 
        }
        else break;   //此时， q.term.expn>e.expn >=q->next->term.expn
    }
    if (q->next!=NULL&&cmp(q->next->term,e)==0)
    {   //指数相同，系数相加
        q->next->term.coef+=e.coef;
    }
    else
    {
        Ploynomial *node = (Ploynomial *)malloc(sizeof(Ploynomial));
        node->term.coef=e.coef;
        node->term.expn=e.expn;
        if(q->next==NULL)
            node->next=NULL;    //如果q结点为尾结点，则node的指针域设为NULL
        else
            node->next=q->next;     //否则node的指针域指向q的下一个结点
        q->next=node;//将node结点插入链表中
    }
}
//输入m项的系数和指数，建立表示一元多项式的有序链表L，演示功能，无需学习
void CreatePolyn(LinkList &L,int n)
{
    Term e;
    InitList(L);
    for (int i = 1; i <= n; i++)
    {
        printf("
第%d项的系数和指数：",i);
        scanf("%f%d",&e.coef,&e.expn);
        insertNode(L,e);    
    }
}
//用L返回L1+L2的结果
void addPolyn(LinkList &L,LinkList L1,LinkList L2)
{
    Ploynomial *q;
    for (q=L1->next; q!=NULL; q=q->next)
    {
        insertNode(L,q->term);   //将L1的每一项插入到L中
    }
    for (q=L2->next; q!=NULL; q=q->next)
    {
        insertNode(L,q->term);   //将L2的每一项插入到L中
    }
}

//以类数学表达式的形式打印输出一元多项式L,演示功能，无需学习
void visitList(LinkList L)
{
    Ploynomial *q=L;
    int flag;
    while(q->next!=NULL)
    {
        q=q->next;
        flag=1;
        if(q->term.coef==0) continue;//系数为0 不输出
        if(q->term.expn==0&&flag==1) //指数为1
        {
            if(q->term.coef>0)
                printf("+%.2f",q->term.coef);
            else
                printf("%.2f",q->term.coef);
            flag=0;
        }
        if((q->term.coef==1||q->term.coef==-1)&&flag==1)//系数为1
        {
            if(q->term.expn==1){
                if(q->term.coef==1)
                   printf("+X");
                else
                   printf("-X");
            }else{
                if(q->term.coef==1)
                    printf("+X^%d",q->term.expn);
                else
                    printf("-X^%d",q->term.expn);
            }
            flag=0;
        }
        if(flag==1)
        {
            if(q->term.coef>0)
                printf("+%.2fX^%d",q->term.coef,q->term.expn);
            else
                printf("%.2fX^%d",q->term.coef,q->term.expn);
        }

    }
    printf("
");
}

int main()
{
    LinkList L1,L2;
    int n1,n2;
    printf("请输入多项式L1的项数：");
    scanf("%d",&n1);
    CreatePolyn(L1,n1);
    printf("请输入多项式L2的项数：");
    scanf("%d",&n2);
    CreatePolyn(L2,n2);
    printf("
多项式L1:  ");
    visitList(L1);
    printf("
多项式L2:  ");
    visitList(L2);
    LinkList add;
    InitList(add);
    addPolyn(add,L1,L2);
    printf("
L1 + L2:   ");
    visitList(add);
}

10、求两个多项式的相乘运算

//用L返回L1*L2的结果
//将该方法加入第九题中即可，书写主方法即可
void multiplyPolyn(LinkList &L,LinkList L1,LinkList L2)
{
    Ploynomial *p,*q;
    Term term;
    term.coef=0.0;
    term.expn=0;
    for(q=L1->next; q!=NULL; q=q->next)
    {
        for(p=L2->next; p!=NULL; p=p->next)
        {
            term.coef=(q->term.coef)*(p->term.coef);//系数相乘
            term.expn=(q->term.expn)+(p->term.expn);// 指数想加
            insertNode(L,term);
        }
    }
}

11、用单链表实现两个大整数的相加运算

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#define MAX_SIZE 50

//学习于CSDN作者-静能生悟，本题重点在于学习add操作，以及为什么要reverse

typedef struct node
{
    int data;
    struct node *next;
}NodeType;

//创建整数单链表
void createList(NodeType *&h,char a[],int n)
{
    NodeType *p,*r;
    int i=0;
    //创建头结点
    h=(NodeType *)malloc(sizeof(NodeType));
    r=h;   //r指向新创建的头结点
    while(i<n)
    {
        //创建新结点p
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=a[n-i-1]-'0';
        //将p插入r之后
        r->next=p;
        //r指向新结点
        r=p;
        i++;
    }
    r->next=NULL;
}
//输出单链表
void dispList(NodeType *h)
{
    NodeType *p = h->next; // p指向整数单链表的第一个数据结点

    while(p != NULL)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("
");
}
//销毁单链表
void destoryList(NodeType *&h)
{
    NodeType *pre=h;   // pre指向整数单链表的头结点
    NodeType *p=pre->next;   // p指向整数单链表的第一个数据结点(首节点)
    while(p!=NULL)
    {
        free(pre);
        pre=p;   //pre,p同步后移一个结点
        p=p->next;
    }
    free(pre);
}
//两整数单链表h1和h2相加得到h
void addList(NodeType *h1,NodeType *h2,NodeType *&h)
{
    NodeType *p1=h1->next;   //p1指向单链表h1中的第一个数据结点
    NodeType *p2=h2->next;   //p2指向单链表h2中的第一个数据结点
    NodeType *p,*r;
    int carry = 0;

    //创建头结点
    h=(NodeType *)malloc(sizeof(NodeType));
    // r指向新创建头结点
    r=h;
    while(p1!=NULL&&p2!=NULL)
    {
        //创建新结点p
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=(p1->data+p2->data+carry)%10;   // 求余
        // 将新结点p插入到r指向的头结点之后
        r->next=p;
        // r后移一个结点
        r=p;
        carry=(p1->data+p2->data+carry)/10;   //求商
        // p1和p2指向下一个结点
        p1 = p1->next;
        p2 = p2->next;
    }
    if(p1!=NULL)
        p1=p2;
    while(p1!=NULL)
    {
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=(p1->data+carry)%10;    // 数据域
        // 将新结点p插入到r指向的头结点之后
        r->next=p;
        // r后移一个结点
        r=p;
        carry=(p1->data+carry)/10;
        p1=p1->next;
    }
    // 最后carry不为0时,创建一个结点存放它
    if(carry>0)
    {
        p=(NodeType *)malloc(sizeof(NodeType));
        p->data=carry;
        // 将新结点p插入到r指向的头结点之后
        r->next = p;
        // r后移一个结点
        r = p;
    }
    r->next=NULL;
}
//逆置整数单链表h
void reverseList(NodeType *&h)
{
    NodeType *p=h->next,*q;
    h->next=NULL;
    while(p!=NULL)
    {
        q=p->next;
        p->next=h->next;
        h->next=p;
        p=q;
    }
}

//求整数单链表h的中间位
/**
*   算法设计思路:
*   定义快指针quick和慢指针slow,初始时都指向头结点,当快指针没有
*   扫描完整数单链表h时,每次让慢指针slow前进一个结点,快指针quick前进两个
*   结点.当快指针到达链表尾时,慢指针slow指向的结点就是中间结点.
*/
int midList(NodeType *h)
{
    NodeType *slow=h;   //定义慢指针
    NodeType *quick=h;   //定义快指针
    while(quick!=NULL&&quick->next!=NULL)
    {
        slow=slow->next;   // 慢指针slow前进一个结点
        quick=quick->next->next;   // 快指针quick前进两个结点
    }
    return slow->data;
}

int main(int argc, char const *argv[])
{
    NodeType *h1,*h2,*h;
    char s[MAX_SIZE],t[MAX_SIZE];
    printf("(1)输入大整数a: ");
    scanf("%s", s);
    printf("(2)输入大整数b: ");
    scanf("%s", t);
    createList(h1,s,strlen(s));
    createList(h2,t,strlen(t));
    printf("(3)整数单链表a: ");
    dispList(h1);
    printf("(4)整数单链表b: ");
    dispList(h2);
    addList(h1,h2,h);
    printf("(5)结果单链表c: ");
    dispList(h);
    reverseList(h);
    printf("(6)对应的整数c: ");
    dispList(h);
    printf("(7)中间位: %d", midList(h));
    destoryList(h);
    destoryList(h1);
    destoryList(h2);

    return 0;
}