南京邮电大学数据结构实验一(线性表的基本运算及多项式的算术运算)(代码篇)

这篇具有很好参考价值的文章主要介绍了南京邮电大学数据结构实验一(线性表的基本运算及多项式的算术运算)(代码篇)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

〇、写在前面

小伙伴们要多多体会,不要全部借鉴哦!文章来源地址https://www.toymoban.com/news/detail-719951.html

一、顺序表的初始化、查找、插入、删除、输出、撤销

/*
_* _ coding : utf - 8 _ * _

Time : 2022/9/4 21 : 15
Author : Yan Fanyu
Version : V 0.1
File : main.cpp
Describe : Github link : https://github.com/YanFanYu2001
*/

#include<stdio.h>
#include<stdlib.h>
#define ERROR 0
#define OK 1
typedef int ElemType;
typedef int Status;



// 1、参照课本程序2.1~2.7,编写程序,完成顺序表的初始化、查找、插入、删除、输出、撤销等操作。

typedef struct {
	int n;               //顺序表的长度
	int maxLength;       //顺序表的最大长度
	ElemType* element;   //存放动态分配一维数组首地址
}SeqList;


//顺序表初始化

Status Init(SeqList* L, int mSize) {
	
	L->maxLength = mSize;		// 容量设为mSize

	L->n = 0;					// 大小设为0

	L->element = (ElemType*)malloc(sizeof(ElemType) * mSize);	// 申请容量大小的动态空间

	if (L->element)			// 如果申请成功,返回OK
		return OK;
	exit(0);				// 申请不成功,退出
}


//顺序表的查找
Status Find(SeqList seqList, int i, ElemType* x) {
	if (i < 0 || i > seqList.n - 1) {
		return ERROR;    //判断元素下标i是否越界
	}
	*x = seqList.element[i];     //取出element[i]的值通过参数x返回
	return OK;
}

//初始化插入
Status Insert(SeqList* seqList, int i, ElemType x) {
	int j;
	if (i<-1 || i>seqList->n - 1)                      //判断下标i是否越界
		return ERROR;
	if (seqList->n == seqList->maxLength)                    //判断顺序表存储空间是否已满
		return ERROR;
	for (j = seqList->n - 1; j > i; j--) {
		seqList->element[j + 1] = seqList->element[j];   //从后往前逐个后移元素
	}
	seqList->element[i + 1] = x;                       //将新元素放入下标为i+1的位置
	seqList->n++;                           //长度+1
	return OK;
}


//顺序表的删除
Status Delete(SeqList* seqList, int i) {
	int j;
	if (i<0 || i>seqList->n - 1) {                   //下标i是否越界
		return ERROR;
	}
	if (!seqList->n) {                           //顺序表是否为空
		return ERROR;
	}
	for (j = i + 1; j < seqList->n; j++) {
		seqList->element[j - 1] = seqList->element[j];   //从前往后逐个前移元素
	}
	seqList->n--;                              //表长减1
	return OK;
}


//顺序表输出
int Output(SeqList seqList) {
	int i;
	if (!seqList.n)
		return ERROR;                 //判断顺序表是否为空
	for (i = 0; i <= seqList.n - 1; i++)
		printf("%d ", seqList.element[i]);  //从前往后逐个输出元素
	return OK;
}



// 顺序表的撤销
void Destroy(SeqList* L) {
	(*L).n = 0;
	(*L).maxLength = 0;
	free((*L).element);
}



int main()
{
	int i, findResult;
	SeqList list;
	Init(&list, 10);
	                   //对线性表初始化,初始化容量为10
	for (i = 0; i < 10; i++) {
		Insert(&list, i - 1, i);			//将0-8插入到顺序表中
	}
	printf("插入0~10后,表为:\n");
	Output(list);
	printf("\n");
	Delete(&list, 0);                       //删除0
	printf("删除下表为0处的元素后,表为:\n");
	Output(list);
	Find(list, 2, &findResult);				//查找下标为2的元素并输出
	printf("\n下表为2处的元素值为:");
	printf("%d", findResult);
	Destroy(&list);
	return 0;
}



/*

1、数据结构:
顺序表SeqList的数据结构为C语言结构体, 
内含三个数据成员n(线性表的实际大小), maxLength(线性表的存储容量), element(线性表存储元素的首地址)



核心算法:

1、首先创建一个线性表结构体变量SeqList list; 调用Init(SeqList* L, int mSize)对线性表进行存储容量的设置和
存储空间内存的申请。
2、插入算法:调用 Insert(SeqList* seqList, int i, ElemType x), 将传入的元素的值 x 放到 顺序表第 i+1 个位置上。
首先从线性表的最后一个元素开始从后往前逐个后移元素,直到将第i+1个元素移动到第i+2个位置,然后将要插入的元素插入到线性表的
第i+1个位置上。
3、删除算法:	调用 Delete(SeqList* seqList, int i), 传入坐标处的元素删除。
首先从线性表的第i+1的未知开始, 依次将元素前移。
 

 Status Init(SeqList* L, int mSize);
 Status Find(SeqList seqList, int i, ElemType* x);
 Status Insert(SeqList* seqList, int i, ElemType x);
 int Output(SeqList seqList);
 void Destroy(SeqList* L);


*/

二、带表头结点单链表的初始化、查找、插入、删除、输出、撤销

/*
_* _ coding : utf - 8 _ * _

Time : 2022/9/4 21 : 15
Author : Yan Fanyu
Version : V 0.1
File : main.cpp
Describe : Github link : https://github.com/YanFanYu2001
*/


#include<stdio.h>
#include<stdlib.h>
#define ERROR 0
#define OK 1
typedef int ElemType;
typedef int Status;

//2、已知带表头结点单链表的类型定义如下:	 
//参照课本程序2.8~2.14,编写程序,完成带表头结点单链表的初始化、查找、插入、删除、输出、撤销等操作。

typedef struct Node {
    ElemType element;     //结点的数据域
    struct Node* link;   //结点的指针域
}Node;

typedef struct {
    struct Node* head;    //表头结点
    int n;
}ListHeader;


Status Init(ListHeader* h);
Status Find(ListHeader* h, int i, ElemType* x);
Status Insert(ListHeader* h, int i, ElemType x);
Status Delete(ListHeader* h, int i);
Status Output(ListHeader* h);
void Destroy(ListHeader* h);


//带表头结点单链表的初始化
Status Init(ListHeader* h) {
    h->head = (Node*)malloc(sizeof(Node));      //生成表头结点
    if (!h->head) {
        return ERROR;
    }
    h->head->link = NULL;                     //设置单链表为空表
    h->n = 0;
    return OK;
}


//带表头结点单链表的查找
Status Find(ListHeader* h, int i, ElemType* x) {
    Node* p;
    int j;
    if (i < 0 || i > h->n - 1) {
        return ERROR;
    }
    p = h->head->link;
    for (j = 0; j < i; j++) {
        p = p->link;
    }
    *x = p->element;
    return OK;
}


//带表头结点单链表的插入
Status Insert(ListHeader* h, int i, ElemType x) {
    Node* p, * q;
    int j;
    if (i<-1 || i>h->n - 1)
        return ERROR;
    p = h->head;                      //从头结点开始找ai元素所在的结点p
    for (j = 0; j <= i; j++) {
        p = p->link;
    }
    q = (Node*)malloc(sizeof(Node));  //生成新结点q
    q->element = x;
    // 将 q 插在 p 和 p->link 之间
    q->link = p->link;                //新结点q插在p之后
    p->link = q;
    h->n++;
    return OK;
}


//带表头结点单链表的删除
Status Delete(ListHeader* h, int i) {
    int j;
    Node* p, * q;
    if (!h->n) {
        return ERROR;
        if (i<0 || i>h->n - 1) {
            return ERROR;
        }
    }
    q = h->head;
    for (j = 0; j < i; j++) {
        q = q->link;
    }
    p = q->link;
    // 将 q->link 改为 q->link->link;  即q的下一个节点的下一个,再将q的下一个节点删除
    q->link = q->link->link;            
    free(p);                       
    h->n--;
    return OK;
}


//带表头结点单链表的输出
Status Output(ListHeader* h) {
    Node* p;
    if (!h->n)
        return ERROR;
    p = h->head->link;
    printf("the linklist is:");
    while (p) {
        printf("%d ", p->element);
        p = p->link;
    }
    printf("\n");
    return OK;
}


//带表头结点单链表的撤销
void Destroy(ListHeader* h) {
    Node* p, * q;
    while (h->head->link) {
        q = h->head->link;
        p = h->head->link->link;
        free(h->head->link);
        h->head = q;
    }
}



int main()
{
    int i, x;
    ListHeader list;
    Init(&list);
    for (i = 0; i < 9; i++) {
        Insert(&list, i - 1, i);    //插入0~8
    }
    printf("插入0~8,表为:\n");
    Output(&list);
    printf("\n");
    Delete(&list, 0);                //删除0
    printf("删除下标为0处的元素,表为:\n");
    Output(&list);
    printf("\n");

    Delete(&list, 0);                //删除0
    printf("删除下标为0处的元素,表为:\n");
    Output(&list);
    printf("\n");

    Find(&list, 0, &x);               //查找下标为0的元素
    printf("查找下标为0的元素值为:\n");
    printf("%d ", x);
    printf("\n");

    Destroy(&list);
    printf("\n\n\n");
    return 0;
}

/*
   参照课本程序2.8~2.14,编写程序,完成带表头结点单链表的初始化、查找、插入、删除、输出、撤销等操作。
    1、初始化:先为表头节点申请一个节点的空间,
*/

三、多项式

/*
_* _ coding : utf - 8 _ * _

Time : 2022/9/4 21 : 15
Author : Yan Fanyu
Version : V 0.1
File : main.cpp
Describe : Github link : https://github.com/YanFanYu2001
*/

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

typedef struct PNode {
    int coef;             //系数
    int exp;              //指数
    struct PNode* link;
}PNode;

typedef struct {
    struct PNode* head;
}Polynominal;


//多项式的创建
void Create(Polynominal* p) {
    PNode* pn, * pre, * q;
    p->head = (PNode*)malloc(sizeof(PNode));
    p->head->exp = -1;
    p->head->link = p->head;               //对教材做了修改
    //p->head->link = NULL;                //教材原代码
    printf("请输入表达式的项数\n");
    int nn = 0;
    scanf_s("%d", &nn);
    for (int i = 0; i < nn; i++)
    {
        pn = (PNode*)malloc(sizeof(PNode));
        printf("\n请输入系数:\n");
        scanf_s("%d", &pn->coef);
        printf("请输入阶数:\n");
        scanf_s("%d", &pn->exp);
        if (pn->exp == -1) break;
        pre = p->head;
        q = p->head->link;
        while (q && q->exp > pn->exp) {
            pre = q;
            q = q->link;
        }
        pn->link = q;
        pre->link = pn;
    }
}


//多项式输出
void Output(Polynominal p) {
    printf("expression = ");
    PNode* q;
    int flag = 1;                                   //打标记,记录是否为第一项
    q = p.head->link;
    if (!q) {
        return;
    }
    while (q != p.head) {
        if (!flag && (q->coef > 0)) printf("+");    //在非第一项的正系数前输出+号
        flag = 0;                                   //flag置为0,表示不是第一项
        if (q->coef == 0) {                           //当前项系数为0
            return;
        }
        if (q->coef != 1) {       //当前项系数不为0&&不为1
            printf("%d", q->coef);
        }
                       
        switch (q->exp) {                             //判断当前项指数
        case 0:break;                           //当前项指数为0,退出
        case 1:printf("X"); break;               //当前项指数为1,输出X
        default:printf("X^%d", q->exp); break;    //当前项指数不为0,也不为1
        }
        q = q->link;
    }
    printf("\n");
}


//多项式的相加,结果存入qx中
void Add(Polynominal* px, Polynominal* qx) {
    PNode* q, * q1 = qx->head, * p, * p1, * temp;    //q1指向qx的表头结点
    p = px->head->link;                       //p指向多项式px的第一个结点
    p1 = px->head;
    q = q1->link;                             //q1是q的前驱
    while (p->exp >= 0) {
        while (p->exp < q->exp) {               //跳过q->exp大的项
            q1 = q;
            q = q->link;
        }
        // 如果两多项式的阶数相等,则对应系数相加,结果存放在qx中
        if (p->exp == q->exp) {                
            q->coef = q->coef + p->coef;
            // 如果相加后系数为0
            if (q->coef == 0) {                 
                q1->link = q->link;           //删除q
                free(q);                      //释放q的空间
                q = (PNode*)malloc(sizeof(PNode));
                q = q1->link;                 //重置q指针
                p = p->link;
            }
            else {                             //若相加后系数不为0
                q1 = q;                       //q1后移
                q = q->link;
                p = p->link;                  //p也后移
            }
        }
        else {                                 //p->exp > q->exp的情况
            temp = (PNode*)malloc(sizeof(PNode));     //以p的系数和指数生成新结点
            temp->coef = p->coef;
            temp->exp = p->exp;
            temp->link = q1->link;
            q1->link = temp;
            q1 = q1->link;
            p = p->link;
        }
    }
}


// 多项式乘法 (结果存放在qx1中)
void Multiply(Polynominal* px, Polynominal* qx) {
    Polynominal qx1, qx2;
    PNode* q1, * q2, * q3, * q4, * pre = (PNode*)malloc(sizeof(PNode)), * q;
    qx1.head = (PNode*)malloc(sizeof(PNode));       //生成新多项式qx1
    qx1.head->exp = -1;
    qx1.head->link = qx1.head;                      //qx1改造成循环链表
    q1 = px->head;                            //q1指向px的第一项
    q2 = qx->head;                            //q2指向qx的第一项
    while (q2->exp != -1) {                           //当q2的指数不为-1时,px先和qx的每一项相乘
        q3 = (PNode*)malloc(sizeof(PNode));         //q3存放相乘的结果
        // 系数相乘,阶数相加
        q3->coef = q1->coef * q2->coef;
        q3->exp = q1->exp + q2->exp;

        if (qx1.head->link->exp == -1) {              //q3插入到qx1多项式第一项中
            q3->link = qx1.head->link;
            qx1.head->link = q3;
            pre = qx1.head->link;
        }

        else {                                       //q3插入到qx1多项式最后一项中
            q3->link = qx1.head;
            pre->link = q3;
            pre = pre->link;
        }

        q2 = q2->link;
    }
    // q1 指向 q1表达式的下一项
    q1 = q1->link;                                 //q1后移一位
    while (q1->exp != -1) {                          //px剩下来每一项都和qx每一项相乘
        q2 = q2->link;
        qx2.head = (PNode*)malloc(sizeof(PNode));  //生成新多项式qx2
        qx2.head->exp = -1;
        qx2.head->link = qx2.head;                // 指向自己

        // 遍历 q2 的每一项
        while (q2->exp != -1) {
            q4 = (PNode*)malloc(sizeof(PNode));
            q4->coef = q1->coef * q2->coef;
            q4->exp = q1->exp + q2->exp;
            if (qx2.head->link->exp == -1) {
                q4->link = qx2.head->link;
                qx2.head->link = q4;
                pre = qx2.head->link;
            }
            else {
                q4->link = qx2.head;
                pre->link = q4;
                pre = pre->link;
            }
            q2 = q2->link;
        }
        Add(&qx2, &qx1);                            //合并同类项
        q1 = q1->link;
    }
    Output(qx1);
}


int main() {
    Polynominal p, q;
    int x;
    printf("请输入第一个表达式:\n");
    Create(&p);
    Output(p);
    printf("\n\n请输入第二个表达式\n");
    Create(&q);
    Output(q);
    printf("请输入选项\n 1: 加法   2:乘法\n");
    scanf_s("%d", &x);
    switch (x) {       
    case 0: break;
        //选择加法还是乘法功能
    case 1:printf("加法结果:\n");
        Add(&p, &q);
        Output(q);
        break;
    case 2:printf("乘法结果:\n");
        Multiply(&p, &q);
        break;
    default: break;
    }
    return 0;
}

/*
* typedef struct PNode {
    int coef;             //系数
    int exp;              //指数
    struct PNode* link;
}PNode;

typedef struct {
    struct PNode* head;
}Polynominal;
* 
先创建结构体PNode 表示多项式的某一项,内含三个成员变量,分别是coef(项的系数),exp(项的阶数),link(下一项的地址)

再创建多项式结构体Polynominal,内含一个成员变量head(多项式首项的地址)

算法:
1、先创建两个表达式结构体指针变量Polynominal* p q;
2、p q 分别调用 Creat(Polynominal*) 函数对多形式进行初始化 
初始化算法如下:
为多项式的头指针即多项式结构体的成员变量进行动态空间申请。将头指针即多项式的第一项的阶数初始化为-1
从控制台获取用户要输入的多项式的项数,记为nn
循环 nn 次,用户依次输入系数,阶数,系数,阶数······ 直至输入完毕
算法对输入的多项式实行按该项阶数降序的顺序进行顺序存储。
算法实现过程是:

1、多项式的创建
*/


到了这里,关于南京邮电大学数据结构实验一(线性表的基本运算及多项式的算术运算)(代码篇)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 南京邮电大学算法与设计实验一:分治策略(最全最新,与题目要求一致)

    实验原理: 1、用分治法实现一组无序序列的两路合并排序和快速排序。要求清楚合并排序及快速排序的基本原理,编程实现分别用这两种方法将输入的一组无序序列排序为有序序列后输出。 2、采用基于“五元中值组取中值分割法”(median-of-median-of-five partitioning)的线性时

    2024年04月17日
    浏览(109)
  • 南京邮电大学Web技术双语实验一(客户端HTML脚本编写)

    实验目的: (1) 通过上机实践,熟悉 HTML 和 JavaScript 脚本实现技术。 (2) 加深对 Web 编程的认识 实验要求: 1 编写个人主页,要求包含如下信息。 (1) 标题“欢迎访问×××的主页” (2) 个人简介,包含照片。 (3) 个人经历简介,以有序列表形式显示。 (4) 个人最

    2024年02月05日
    浏览(65)
  • 南京邮电大学算法与设计实验二:贪心算法(最全最新,与题目要求一致)

    三、实验原理及内容 实验原理: 1 、用贪心法实现求两序列的一般背包问题。要求掌握贪心法思想在实际中的应用,分析一般背包的问题特征,选择算法策略并设计具体算法,编程实现贪心选择策略的比较,并输出最优解和最优解值。 2 、用贪心法求解带时限的 ( 单位时间

    2024年02月05日
    浏览(50)
  • 南京邮电大学算法与设计实验四:回溯法(最全最新,与题目要求一致)

    要求用回溯法求解8-皇后问题,使放置在8*8棋盘上的8个皇后彼此不受攻击,即:任何两个皇后都不在同一行、同一列或同一斜线上。请输出8皇后问题的所有可行解。 用回溯法编写一个递归程序解决如下装载问题:有n个集装箱要装上2艘载重分别为c1和c2的轮船,其中集装箱i的

    2024年02月05日
    浏览(60)
  • 南京邮电大学电工电子(数电)实验报告——计数器 & 移位寄存器

    1、掌握计数器的逻辑功能及应用方法 2、掌握任意进制计数器的设计方法 3、掌握数字电路多个输出波形相位关系的正确测试方法 4、了解非均匀周期信号波形的测试方法 设计一个分频比N=5的整数分频电路,观察并记录时钟脉冲和输出波形。 选用cb4cle二进制计数器模块,采用

    2024年02月03日
    浏览(89)
  • 南京邮电大学电工电子基础B实验四(戴维南与诺顿定理)

    一、 实验目的 1、学习几种常用的等效电源的测量方法 2、比较几种测量方法所适用的情况 3、分析各种方法的误差大小及其产生的原因 二、 主要仪器设备及软件 硬件:交流电源、电容、电感、电阻、波特图仪。 软件:Multisim14.0 三、 75页实验表格 四、 仿真电路 五、 测量方

    2023年04月15日
    浏览(57)
  • 南京邮电大学电工电子(数电)实验报告——数字电路与模拟电路的综合应用

    1、了解D/A转换器的基本工作原理和基本结构 2、了解大规模集成D/A转换器的功能及其典型应用方法 3、掌握综合性电路的调测方法 实验内容∶设计一个可编程波形发生器技术指标∶ ① 输出信号波形受K2和K1控制 开关K2K1=01时,输出信号波形为正斜率锯齿波。开关K2K1=10时,输出

    2024年02月06日
    浏览(57)
  • 南京邮电大学汇编语言程序设计实验二(用户登录验证程序的设计)

    1.掌握循环程序的编写以及结束循环的方法。 2.掌握DOS、BIOS功能调用的使用方法。 用户登录验证程序的实现 程序执行后,给出提示操作,请用户键入用户名和密码;用户在键入密码时,程序不回显键入字符;只有当用户键入的用户名,密码字符串和程序内定的字符串相同时

    2023年04月18日
    浏览(57)
  • 南京邮电大学汇编语言程序设计实验一(汇编语言语法练习与代码转换)

    排除语法错误:给出的是一个通过比较法完成8位二进制数转换成十进制数送屏幕显示功能的汇编语言源程序,但有很多语法错误。要求实验者按照原样对源程序进行编辑,汇编后,根据TASM给出的信息对源程序进行修改,知道没有语法错误为止。然后进行链接,并执行相应可

    2024年02月08日
    浏览(62)
  • 南京邮电大学数据库第一次课后作业

    1.单选题 (5分) ( B )是存储在计算机内有结构的数据的集合。 (A)数据库系统 (B)数据库 (C)数据库管理系统 (D)数据结构 2.单选题 (5分) 数据库的特点之一是数据的共享,严格的讲,这里的数据共享是指( D )。 (A)同—个应用中的多个程序共享一个数据集合 (B)多个用户

    2024年02月01日
    浏览(57)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包