链表的实现和应用-线性链表实现C++

一、实验目的：

（1）应用线性表的链式存储结构，设计并实现链表的基本操作与运算。

二、实验设备：

计算机（x86）

Visual Studio（运行环境）

GCC（编译器）

三、实验内容：

（1）编写程序实现链表的各种基本操作。

①建立线性表。

②输出线性表元素。

③在线性表中查找某个元素。

④向线性表指定位置插入元素。

⑤删除指定位置元素。

（2）链表的应用的操作。

问题描述：设计一个一元多项式计算器，要求能够：①输入并建立多项式；②输出多项式；③执行两个多项式相加；④（选做）执行两个多项式相减；⑤（选做）执行两个多项式相乘。

四、实验过程（程序代码）：

（1）

#include <iostream>

#include <stdlib.h>

#include <stdio.h>

using namespace std;

#define List_INT_size 100

//注defin不可加；

typedef int ElemType;

//定义链表接口

typedef struct {

    ElemType* data;

    int length;

    int listsize;

}Sqlist;

//声明结构体名称SQList

//使用typ转义

void InitList(Sqlist& L)

//链表初始化

{

    L.data = (ElemType*)malloc(List_INT_size * sizeof(ElemType));

    if (!L.data)

         exit(1);

    L.length = 0;

    L.listsize = List_INT_size;



}

int ListInsert(Sqlist& L, int i, ElemType e)

//插入数据

//L为引用链表 i为位置对应length Elym对应数据类型

//此时为int，e为数据对应data

{

    if (i<1 || i>L.length + 1)

         //位置处于1至最大链表位对应INT_SIZE

         return 0;

    if (L.length >= L.listsize)

         //判断链表是否超限INT_SIZE 删除函数不需要

         return 0;

    for (int j = L.length; j >= i; j--)

         //以j位计数器 共移动length-i次

         L.data[j] = L.data[j - 1];

    L.data[i - 1] = e;//赋值

    L.length++;

    return 1;

}

void output(Sqlist L)

{

    int i;

    std::cout << "删除后的链表数据：" << endl;

    for (i = 1; i <= L.length; i++)

         std::cout << L.data[i - 1] << " ";

    std::cout << endl;



}

int  ListLocate(Sqlist L, ElemType x)//查找函数

//有返回值 返回查找值的位置序号

{

    int i;

    for (i = 1; i <= L.length; i++)

         if (L.data[i - 1] == x)

             return i;

    return 0;

}

int ListDeleta(Sqlist& L, int i, ElemType& e)

//删除函数 有返回值

{

    int j;

    if (i<1 || i>L.length)

         return 0;

    //判断数据是否存在

    e = L.data[i - 1];

    //求出所删除的值

    for(j=i;j<L.length;j++)

         L.data[j - 1] = L.data[j];

    //覆盖式移动链表

    L.length--;

    return 1;

}

int main()

{

    Sqlist a;

    ElemType x,e,k;

    int i, t;

    InitList(a);

    std::cout << "依次插入数据";

    i = 1;

    std::cin >> x;

    while (x < 100)

    {

         ListInsert(a, i, x);

         std::cin >> x;

         i++;

    }

    output(a);

    std::cout << "输入需要查找的数据" << endl;

    std::cin >> e;

    k = ListLocate(a, e);

    if (k == 0)

         std::cout << e << "未在链表中" << endl;

    else

    std::cout << e << "在链表中的位置为" << k << endl;

    std::cout << "需要删除的数据位置序号是" << endl;

    std::cin >>t;

    ListDeleta(a, t, e);

    std::cout << "删除的数据是" << e << endl;

    output(a);

    free(a.data);

    return 0;

}

（2）

#include <iostream>

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

using namespace  std;

typedef struct ploy

{

    float coef;//系数

    int expn;//指数

    struct ploy* next;

}Ploy;

Ploy add_ploy(Ploy* La, ploy* Lb)

//返回值为链表

{

    Ploy* Lc, * pc, * pa, * pb, * ptr;

    float x;

    Lc = pc = La;

    pa = La->next;//a指a的后继

    pb = Lb->next;//b同

    while (pa != NULL && pb != NULL)

    {

         if (pa->expn < pb->expn)//<为判断

         {

             pc->next = pa;

             pc = pa;

             pa = pa->next;

         }

         else if (pa->expn > pb->expn)

         {

             pc->next = pb;

             pc = pb;

             pb = pb->next;

         }

         else//相等的时候合并

         {

             x = pa->coef + pb->coef;

             if (fabs(x) <= 1.0e-6)

                  //系数和为0时

             {

                  ptr = pa;

                  pa = pa->next;

                  free(ptr);

                  ptr = pb;

                  pb = pb->next;

                  free(ptr);

             }

             else

                  //系数不为0时

             {

                  pc->next = pa;

                  pa->coef = x;

                  pc = pa;

                  pa = pa->next;

                  ptr = pb;

                  pb = pb->next;

                  free(ptr);

             }

         }

    }

    if (pa == NULL)

         pc->next = pb;

    else

         pc->next = pa;

    free(Lb);

    return* Lc;

}

//Ploy指链表 ploy为结构体

void CreataList_L(Ploy& L, int n)

{

    int i;

    Ploy* p;

    //(L)= (Ploy*)malloc(sizeof(Ploy));

    L.next= NULL;



    for (i = n; i > 0; i--)

    {

         p = (Ploy*)malloc(sizeof(Ploy));

         std::cin >> p->coef;

         std::cin >> p->expn;

         p->next = L.next;

         L.next = p;

    }

}

void output(Ploy& L)

{

    Ploy* p;

    p = L.next;

    std::cout << "输出该表：" << endl;

    if (p == NULL)

         std::cout << "为空表" << endl;

    while (p!=NULL)

    {

         std::cout << p->coef << " " << p->expn<<" ";



         p = p->next;

    }

}

void xiaohui(Ploy* L)

{

    Ploy* p;

    p = L->next;

    while (p)

    {

         L->next = p->next;

         free(p);

         p = L->next;

    }

    free(L);

}

int  main()

{

    Ploy La, Lb, Lc;

    std::cout << "输入La：";

    CreataList_L(La, 4);

    output(La);

    std::cout << endl;

    std::cout << "输入Lb：";

    CreataList_L(Lb, 4);

    output(Lb);

    std::cout << endl;

    Lc = add_ploy(&La,&Lb);

    output(Lc);

    std::cout << endl;

    xiaohui(&La);

    xiaohui(&Lb);

    xiaohui(&Lc);

    return 0;



    return 0;

}

五、实验结果：

（1）

（2）

六、实验心得：

1.使用函数时要注意是地址还是数据或是指针

2.malloc函数前为指针类型