数据结构与算法实验 ——（一）实验一 动态链表的设计与应用

这是我写的关于动态链表最全面的代码了，包括增删改查逆置合并等等。
由于第九题和第十一题很简单，延伸发展一下就行了，所以我没有深入写下去。
如果有类似的题目建议不要抄我的应付了事，毕竟做学问还得在自身。
一、实验目的、要求
1．掌握握单链表的基本操作：插入、删除、查找等运算。

2．掌握单向链表的存储特点及其实现。

二、实验内容
1．随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）。

2．遍历单向链表。

3．把单向链表中元素逆置（不允许申请新的结点空间）。

4．在单向链表中删除所有的偶数元素结点。

5．编写在非递减有序链表中插入一个元素使链表元素仍有序的函数，并利用该函数建立一个

非递减有序单向链表。

6．利用算法5建立两个非递减有序单向链表，然后合并成一个非递增链表。

7．利用算法5建立两个非递减有序单向链表，然后合并成一个非递减链表。

8．利用算法1建立的链表，实现将其分解成两个链表，其中一个全部为奇数，另一个全部为

      偶数（尽量利用已知的存储空间）。

• 9．采用单向链表实现一元多项式的存储并实现两个多项式相加并输出结果。

10．在主函数中设计一个简单的菜单，分别调试上述算法。

*11．综合训练：利用单向循环链表实现一个班级学生信息管理（数据录入、插入、删除、排

       序、查找等，并能够实现将数据存储到文件中）

三、实验说明
1．类型定义

    #include <stdio.h>

    typedef int  ElemType；//元素类型

    typedef struct LNode

      {ElemType data;

       struct LNode *next;

      }LNode,*LinkList;

 2．为了算法实现简单，最好采用带头结点的单向链表。

四、注意问题
1．重点理解链式存储的特点及指针的含义。

2．注意比较顺序存储与链式存储的各自特点。

3．注意比较带头结点、无头结点链表实现插入、删除算法时的区别。

4．单向链表的操作是数据结构的基础，一定要注意对这部分的常见算法的理解`

#include <bits/stdc++.h>
using namespace std;

typedef int  ElemType; //元素类型
typedef struct LNode
{
    ElemType data; //数据
    struct LNode *next; //next为指针

}LNode,*LinkList;//LinkList为指针

LNode* createlist1(){
    LNode *head;//头指针
    LNode *p1,*p2;//p1为新节点指针，p2为上一个节点的指针
    int n = 0; //临时变量n来记录节点个数
    head = NULL;//初链表为空所以head设为NULL
    p1 = p2 =(LNode *)malloc(sizeof(LNode));//使用内存块函数malloc开辟第一个节点，并让p1、p2指向它
    cout<<"请输入节点的值,输入0结束:"<<endl;
    cin>>(p1->data);
    while(p1->data!=0)
    {
        n++;
        if(n==1)
        {
            head = p1;//设置头指针
        }
        else
        {
            p2->next=p1;
        }
        p2 = p1;
        p1 = (LNode *)malloc(sizeof(LNode));
        cout<<"请输入节点的值,输入0结束:"<<endl;
        cin>>(p1->data);
    }
    p2->next=NULL;//p2为最后一个节点
    return head;//可以将声明换成void同时不返回
}

LNode* createlist2(){
    LNode *head;//头指针
    LNode *p1,*p2;//p1为新节点指针，p2为上一个节点的指针
    int n = 0; //临时变量n来记录节点个数
    head = NULL;//初链表为空所以head设为NULL
    p1 = p2 =(LNode *)malloc(sizeof(LNode));//使用内存块函数malloc开辟第一个节点，并让p1、p2指向它
    cout<<"请输入节点的值,输入0结束:"<<endl;
    cin>>(p1->data);
    while(p1->data!=0)
    {
        n++;
        if(n==1)
        {
            head = p1;//设置头指针
        }
        else
        {
            p2->next=p1;
        }
        p2 = p1;
        p1 = (LNode *)malloc(sizeof(LNode));
        cout<<"请输入节点的值,输入0结束:"<<endl;
        cin>>(p1->data);
    }
    p2->next=NULL;//p2为最后一个节点
    return head;//可以将声明换成void同时不返回
}

void DisplayList(LinkList& L)//遍历单链表
{
    if(L == NULL)
    {
        cout<<"链表为空。";
    }
    else
    {
        LNode* p = L;
        while(p->next!=NULL) {
            cout << "当前节点数据为：" << p->data<<" ";
            p = p->next;
        }
        cout << "当前节点数据为：" << p->data<<" ";
    }
    cout<<endl;
}

void reverseList(LinkList& L)//单链表逆置
{
    if(L == NULL)
    {
        cout<<"链表为空。";
    }
    else
    {
        LNode* p,*q,*r;
        p=L;
        q=NULL;
        r=NULL;
        while(p!=NULL)
        {
            q = p;
            p = p->next;//p指向链表下一个节点
            q->next = r;//将该节点指向前一个节点
            r = q;//设置前一节点的指向
        }
        L = q;//将首地址赋给逆置后的第一节点
    }
}

LNode* del_even_node(LinkList& p)//删除偶数元素
{
    if(p == NULL)
    {
        cout<<"链表为空。";
    }
    else
    {
        LNode* q,*r;
        q = p;
        r = p;
        if(q->data%2==0)//首地址
        {
            q=q->next;
            p = q;
        }
        while(q->next!=NULL)
        {
            r=q;
            q=q->next;
            if(q->data%2==0)
            {
                if(q->next!=NULL)
                {
                    q=q->next;
                    r->next = q;
                }
                else{
                    r->next=NULL;
                }
            }
        }


    }
    return p;
}

void insert(LinkList& L)
{
    LNode* p,*q,*r;
    p=L->next;
    q=L;//记录前驱节点
    LNode temp;
    cout<<"请输入你要插入的元素值："<<endl;
    cin>>temp.data;
    while(p!=NULL)
    {
        if(p->data<temp.data)
        {
            q=p;
            p=p->next;
        } else{
            break;
        }
    }
    r = (LNode *)malloc(sizeof(LNode));
    q->next = r;
    r->data = temp.data;
    r->next = p;
}

LNode* del_odd_node(LinkList& p)//删除偶数元素
{
    if(p == NULL)
    {
        cout<<"链表为空。";
    }
    else
    {
        LNode* q,*r;
        q = p;
        r = p;
        if(q->data%2==1)//首地址
        {
            q=q->next;
            p = q;
        }
        while(q->next!=NULL)
        {
            r=q;
            q=q->next;
            if(q->data%2==1)
            {
                if(q->next!=NULL)
                {
                    q=q->next;
                    r->next = q;
                }
                else{
                    r->next=NULL;
                }
            }
        }


    }
    return p;
}

void merge(LinkList& L1,LinkList& L2)
{
    LNode* p1,*p2,*q;
    p1=L1;
    p2=L2;
    while(p1->next!=NULL)
    {
        p1=p1->next;
    }
    p1->next=p2;
}

int main() {
    struct LNode* p,*q;
    int op=1;
    while(op!=0)
    {
        cout<<"请输入你的选择："<<endl;
        cout<<"1. 创建链表1"<<endl;
        cout<<"2. 创建链表2"<<endl;
        cout<<"3. 遍历链表1"<<endl;
        cout<<"4. 遍历链表2"<<endl;
        cout<<"5. 删除链表1中偶数节点并返回链表首地址给链表1"<<endl;
        cout<<"6. 删除链表1中奇数节点并返回链表首地址给链表2"<<endl;
        cout<<"7. 非递减插入到链表1"<<endl;
        cout<<"8. 合并链表1、2到链表1"<<endl;
        cout<<"9. 逆置链表1"<<endl;
        cout<<"0. 退出"<<endl;
        cin>>op;
        switch(op)
        {
            case 1:p = createlist1();break;
            case 2:q = createlist2();break;
            case 3:DisplayList(p);break;
            case 4:DisplayList(q);break;
            case 5:p=del_even_node(p);break;
            case 6:q=del_odd_node(q);break;
            case 7:insert(p);break;
            case 8:merge(p,q);break;
            case 9:reverseList(p);break;
            case 0:break;
        }
    }
    return 0;
}