数据结构实验2

合集下载

迷宫问题 火车车厢重排问题 实验报告

迷宫问题 火车车厢重排问题 实验报告

实验报告了便于从列车上卸掉相应的车厢,车厢的编号应与车站的编号相同,这样,在每个车站只要卸掉最后一节车厢。

所以,给定任意次序的车厢,必须重新排列它们。

车厢的重排工作可以通过转轨站完成。

在转轨站中有一个入轨、一个出轨和k个缓冲轨,缓冲轨位于入轨和出轨之间。

假定缓冲轨按先进先出的方式运作,设计算法解决火车车厢重排问题。

②基本要求●设计存储结构表示n个车厢、k个缓冲轨以及入轨和出轨;●设计并实现车厢重排算法;●分析算法的时间性能。

③思考●如果缓冲轨按后进先出的方式工作,即用栈表示缓冲轨,应如何解决火车车厢重排问题?二、数据结构设计迷宫问题和火车重排问题可以通过栈与队列实现的。

迷宫的进出和车厢的出入轨和缓冲轨主要是对栈与队列的判断和操作。

int empty( STLink top[],int n) /*判断是否为空*/{return (top[n]==NULL);}int push(STLink top[],int A,int m) /*入栈*/{STLink p;if(!(p=(STLink)malloc(LEN)))return 0;else{p->data=A;p->link=top[m];top[m]=p;return 1;}}int pop(STLink top[],int m) /*出栈*/{int A;STLink p;p=top[m];A=p->data;top[m]=top[m]->link;free(p);return A;}struct Node{ /定义队列int data;Node* next;};三、算法设计1.迷宫问题:进入格子后,需要判断此时格子位置周围障碍物的位置,对其进行压栈,判断,然后看是否满足条件,满足就进栈,不满足就弹出,然后输出不能通过建立迷宫:typedef struct LStack{Element elem;struct LStack *next;}*PLStack;int InitStack(PLStack &S){S=NULL;return 1;}int StackEmpty(PLStack S){if(S==NULL)return 1;elsereturn 0;}int Push(PLStack &S, Element e){PLStack p;p=(PLStack)malloc(sizeof(LStack));p->elem=e;p->next=S;S=p;return 1;}(2).输出路径2.火车车厢排序六、实验收获与思考通过本次实验,进一步增强了对栈和队列的理解,明白的栈的先进后出和队列先进先出的方式,对压栈和出入栈与队列有了深刻认识。

数据结构实验2报告总结

数据结构实验2报告总结

一实验目的和要求理解二叉树的基本概念,熟练使用多种表示法构造二叉树,掌握采用二叉链表存储结构实现二叉树的构造、遍历、插入、删除等操作算法;理解线索二叉树的作用,掌握获得线索二叉树节点在指定遍历次序下的前驱或后继结点的方法;理解哈弗曼编码和哈弗曼树的作用,掌握由指定文本求得哈弗曼编码的方法。

理解树的基本概念,熟悉树的多种存储结构,掌握采用孩子兄弟链表存储结构实现树的遍历、插入、删除等操作算法。

通过研究树和二叉树,深刻理解链式存储结构用于表达非线性结构的作用,掌握采用递归算法实现递归数据结构基本操作的设计方法。

二题目及题意分析题目:插入x元素作为p结点的第i个孩子分析:以中国城市作为元素,以插入孩子结点的方式构造一棵树,找到结点p,p不为空时,若p的孩子结点为空,则直接插入x元素作为p的孩子;若p的孩子结点不为空,插入的x元素的位置n小于等于1时,将x元素直接插在最前面;若n大于1时,查找插入的位置执行插入。

三设计方案和功能说明源程序如下:TreeNode.htemplate<class T>class TreeNode //数的孩子兄弟链表结点类{public: //数据域,保存元素T data;TreeNode<T>* child,*sibling; //指针域,分别指向孩子兄弟结点TreeNode<T>(T data,TreeNode<T>*child=NULL,TreeNode<T>*sibling=NULL){this->data=data;this->child=child;this->sibling=sibling;}};Tree.h#include<iostream.h>#include"TreeNode.h" //树的孩子兄弟链表节点类template<class T>class Tree //树类{public:TreeNode<T>*root; //指向根结点Tree(); //构造空树bool isEmpty();//判断是否空树TreeNode<T>* insertChild(TreeNode<T>*p,T value); // 插入value作为结点p的孩子TreeNode<T>* insertChild(TreeNode<T>*p,T x,int i);// 插入x元素作为p结点的第i 个孩子friend ostream&operator<<(ostream&out,Tree<T>&tree);//先根次序遍历树并以树的横向凹入表示法输出树void preOrder(TreeNode<T> *p,int i);};template<class T>Tree<T>::Tree() //构造空树{root=NULL;}template<class T>bool Tree<T>::isEmpty()//判断是否空树{return root==NULL;}template<class T>TreeNode<T>* Tree<T>::insertChild(TreeNode<T>*p,T value) //插入value作为结点p的孩子{TreeNode<T>*q=NULL;if(p!=NULL){q=new TreeNode<T> (value);if(p->child==NULL)p->child=q;else{p=p->child;while(p->sibling!=NULL)p=p->sibling;p->sibling=q;}}return q;}template<class T>TreeNode<T>*Tree<T>::insertChild(TreeNode<T>* p,T x,int i)// 插入x元素作为p结点的第i 个孩子{TreeNode<T>*q=NULL;if(p!=NULL){q=new TreeNode<T>(x);if(p->child==NULL)p->child=q;else{{if(i<=1)//带有容错功能{p->child=new TreeNode<T>(x,NULL,p->child);return p->child;}p=p->child;for(int j=1;p->sibling!=NULL&&j<i-1;j++)p=p->sibling;if( p->sibling==NULL)p->sibling=q;elsep->sibling=new TreeNode<T>(x,NULL,p->sibling);}}}return q;}template<class T>void Tree<T>::preOrder(TreeNode<T> *p,int i){if(p!=NULL){for(int j=0;j<i;j++)cout<<"\t";cout<<p->data<<endl;preOrder(p->child,i+1);preOrder(p->sibling,i);}}template<class T>ostream&operator<<(ostream&out,Tree<T> &tree)//先根次序遍历树并以树的横向凹入表示法输出树{tree.preOrder(tree.root,0);return out;}Main.cpp#include "Tree.h"TreeNode<char*>*aa;void make(Tree<char*>&tree){tree.root=new TreeNode<char*>("中国");tree.insertChild(tree.root,"北京");tree.insertChild(tree.root,"上海");TreeNode<char*>*js=tree.insertChild(tree.root,"江苏省");tree.insertChild(js,"南京市");tree.insertChild(js,"苏州市");TreeNode<char*> *zj=tree.insertChild(tree.root,"浙江省");tree.insertChild(zj,"杭州市");tree.insertChild(zj,"宁波市");TreeNode<char*> *sx=tree.insertChild(tree.root,"山西省");tree.insertChild(sx,"太原市");tree.insertChild(sx,"大同市");aa=zj;}int main(){Tree<char*>tree;make(tree);cout<<tree;tree.insertChild(aa,"无锡市",2);cout<<tree;return 0;}四运行结果及分析1插入位置小于等于1(即n<=1)n=-2时n=0时n=1时2插入位置大于1(即n>1)n=2时五实验总结通过实验理解了树及二叉树的存储结构熟悉掌握了孩子兄弟链表的存储结构实现,以及遍历、查找、删除等操作,深刻理解实现链式存储结构表达非线性的树存储结构。

数据结构实验报告2

数据结构实验报告2

数据结构实验报告2数据结构实验报告21、实验目的本次实验的目的是通过使用数据结构来解决一个特定的问题。

具体而言,我们将会使用某种数据结构(例如链表、堆栈、队列等)来实现一个特定功能,并对其性能进行评估。

2、实验背景在本次实验中,我们将会探索数据结构在解决实际问题中的应用。

数据结构是计算机科学的重要组成部分,它提供了一种组织和管理数据的方式,以便能够高效地访问和操作这些数据。

3、实验内容在本次实验中,我们选择了一种经典的数据结构,以实现一个特定的功能。

具体而言,我们将会使用链表来实现一个简单的联系人管理系统。

3.1 数据结构选择我们选择了链表作为联系人管理系统的数据结构。

链表是一种灵活的数据结构,它能够动态地增加或删除元素,并且支持高效的插入和删除操作。

3.2 实现功能我们的联系人管理系统将会具有以下功能:- 添加联系人:用户可以输入联系人的姓名、方式号码等信息,并将其添加到联系人列表中。

- 删除联系人:用户可以选择要删除的联系人,并从列表中删除该联系人。

- 查找联系人:用户可以根据姓名或方式号码来查找联系人,并显示相关信息。

- 显示所有联系人:系统将会将所有联系人按照姓名的字母顺序进行排序,并将其显示在屏幕上。

4、实验步骤下面是本次实验的具体步骤:4.1 初始化联系人管理系统在系统开始之前,我们需要初始化联系人管理系统。

这包括创建一个空的联系人列表,并提供用户菜单来选择相应功能。

4.2 添加联系人用户可以选择添加联系人的功能,并输入联系人的相关信息。

系统将会将联系人添加到联系人列表中。

4.3 删除联系人用户可以选择删除联系人的功能,并输入要删除联系人的姓名或方式号码。

系统将会在联系人列表中查找并删除相应联系人。

4.4 查找联系人用户可以选择查找联系人的功能,并输入要查找联系人的姓名或方式号码。

系统将会在联系人列表中查找相应联系人,并显示其相关信息。

4.5 显示所有联系人用户可以选择显示所有联系人的功能。

数据结构实验报告2

数据结构实验报告2

数据结构实验报告2一、实验目的本次数据结构实验旨在通过实际操作和编程实践,深入理解和掌握常见的数据结构,如链表、栈、队列、树等,并能够运用所学知识解决实际问题,提高编程能力和算法设计能力。

二、实验环境本次实验使用的编程语言为C++,开发环境为Visual Studio 2019。

三、实验内容(一)链表的实现与操作1、单向链表的创建首先,定义了链表节点的结构体,包含数据域和指向下一个节点的指针域。

然后,通过函数实现了单向链表的创建,从用户输入获取节点的数据,依次创建新节点并连接起来。

2、链表的遍历编写函数实现对单向链表的遍历,依次输出每个节点的数据。

3、链表的插入与删除实现了在指定位置插入节点和删除指定节点的功能。

插入操作时,需要找到插入位置的前一个节点,修改指针完成插入。

删除操作时,同样找到要删除节点的前一个节点,修改指针并释放删除节点的内存。

(二)栈的实现与应用1、栈的基本操作使用数组实现了栈的数据结构,包括入栈、出栈、判断栈空和获取栈顶元素等操作。

2、表达式求值利用栈来实现表达式求值的功能。

将表达式中的数字和运算符分别入栈,按照运算规则进行计算。

(三)队列的实现与应用1、队列的基本操作使用循环数组实现了队列,包括入队、出队、判断队空和队满等操作。

2、模拟银行排队系统通过创建队列来模拟银行客户的排队情况,实现客户的入队和出队操作,统计平均等待时间等。

(四)二叉树的遍历1、二叉树的创建采用递归的方式创建二叉树,用户输入节点数据,构建二叉树的结构。

2、先序、中序和后序遍历分别实现了二叉树的先序遍历、中序遍历和后序遍历,并输出遍历结果。

四、实验结果与分析(一)链表实验结果成功创建、遍历、插入和删除单向链表。

通过对链表的操作,深入理解了链表的动态存储特性和指针的运用。

在插入和删除操作中,能够正确处理指针的修改和内存的释放,避免了内存泄漏和指针错误。

(二)栈实验结果栈的基本操作运行正常,能够正确实现入栈、出栈等功能。

数据结构实验二

数据结构实验二

数据结构实验二数据结构实验二:线性表的顺序存储结构实现一、实验目的本实验旨在通过实践,掌握线性表的顺序存储结构实现方法,加深对数据结构中线性表概念的理解,以及顺序存储结构的特点和操作。

二、实验内容1. 了解线性表的顺序存储结构的定义和特点;2. 设计并实现线性表的顺序存储结构的初始化操作;3. 设计并实现线性表的顺序存储结构的插入操作;4. 设计并实现线性表的顺序存储结构的删除操作;5. 设计并实现线性表的顺序存储结构的查找操作;6. 设计并实现线性表的顺序存储结构的修改操作;7. 设计并实现线性表的顺序存储结构的打印操作;8. 编写测试用例,验证线性表的顺序存储结构的各项操作是否正确。

三、实验步骤1. 定义线性表的顺序存储结构,包括表头指针、表长度和表最大容量等成员变量;2. 实现线性表的顺序存储结构的初始化操作,包括动态分配内存空间、初始化表头指针、表长度和表最大容量等;3. 实现线性表的顺序存储结构的插入操作,包括判断插入位置的合法性、移动元素、插入新元素等;4. 实现线性表的顺序存储结构的删除操作,包括判断删除位置的合法性、移动元素、修改表长度等;5. 实现线性表的顺序存储结构的查找操作,包括按值查找和按位置查找两种方式;6. 实现线性表的顺序存储结构的修改操作,包括判断修改位置的合法性、修改元素值等;7. 实现线性表的顺序存储结构的打印操作,按照从头到尾的顺序输出线性表中的元素;8. 编写测试用例,包括插入、删除、查找、修改和打印等操作的测试,验证线性表的顺序存储结构的正确性。

四、实验结果经过测试,线性表的顺序存储结构实现了初始化、插入、删除、查找、修改和打印等操作,并且各项操作的结果与预期一致。

五、实验总结通过本次实验,我深入理解了线性表的顺序存储结构的实现原理和操作方法。

顺序存储结构具有随机访问的优点,但插入和删除操作需要移动大量元素,效率较低。

在实际应用中,需要根据具体场景选择合适的存储结构。

数据结构实验报告2篇

数据结构实验报告2篇

数据结构实验报告数据结构实验报告精选2篇(一)实验目的:1. 熟悉数据结构的基本概念和基本操作;2. 掌握线性表、栈、队列、链表等经典数据结构的实现方法;3. 掌握数据结构在实际问题中的应用。

实验内容:本次实验主要包括以下几个部分:1. 线性表的实现方法,包括顺序表和链表,分别使用数组和链表来实现线性表的基本操作;2. 栈的实现方法,包括顺序栈和链式栈,分别使用数组和链表来实现栈的基本操作;3. 队列的实现方法,包括顺序队列和链式队列,分别使用数组和链表来实现队列的基本操作;4. 链表的实现方法,包括单链表、双链表和循环链表,分别使用指针链、双向链和循环链来实现链表的基本操作;5. 综合应用,使用各种数据结构来解决实际问题,例如使用栈来实现括号匹配、使用队列来实现马铃薯游戏等。

实验步骤及结果:1. 线性表的实现方法:a) 顺序表的基本操作:创建表、插入元素、删除元素、查找元素等;b) 链表的基本操作:插入节点、删除节点、查找节点等;c) 比较顺序表和链表的优缺点,分析适用场景。

结果:通过实验,确认了顺序表适用于频繁查找元素的情况,而链表适用于频繁插入和删除节点的情况。

2. 栈的实现方法:a) 顺序栈的基本操作:进栈、出栈、判空、判满等;b) 链式栈的基本操作:进栈、出栈、判空、判满等。

结果:通过实验,掌握了栈的基本操作,并了解了栈的特性和应用场景,例如括号匹配。

3. 队列的实现方法:a) 顺序队列的基本操作:入队、出队、判空、判满等;b) 链式队列的基本操作:入队、出队、判空、判满等。

结果:通过实验,掌握了队列的基本操作,并了解了队列的特性和应用场景,例如马铃薯游戏。

4. 链表的实现方法:a) 单链表的基本操作:插入节点、删除节点、查找节点等;b) 双链表的基本操作:插入节点、删除节点、查找节点等;c) 循环链表的基本操作:插入节点、删除节点、查找节点等。

结果:通过实验,掌握了链表的基本操作,并了解了链表的特性和应用场景。

数据结构实验二_栈的基本操作

数据结构实验二_栈的基本操作

青岛理工大学课程实验报告及实验步骤只要X不为0重复做下列动作将X%R入栈X=X/R只要栈不为空重复做下列动作栈顶出栈输出栈顶元素调试过程及实验结果根据输入的十进制数通过桟的基本操作可以转换成二进制、八进制、十六进制的数。

在上机过程中程序的调用没有太大的问题,按照课本的基本算法就可以将程序正确的运行。

总结程序可以完成基本的功能,可以将十进制数转换为其他进制的数,基本掌握了桟的几种常用的操作;但程序存在缺陷,就是不能持续进行操作,输入了一个十进制数只能进行一次数制转换,程序就会退出,有待改进。

附录#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define stack_init_size 100#define stackincrement 10typedef struct sqstack{int *base;int *top;int stacksize;} sqstack;int StackInit(sqstack *s){s->base=(int *)malloc(stack_init_size *sizeof(int));if(!s->base)return 0;{return 0;}}int conversion(sqstack *s){int n,e=0,flag=0;printf("输入要转化的十进制数:\n");scanf("%d",&n);printf("要转化为多少进制:2进制、8进制、16进制填数字!\n");scanf("%d",&flag);printf("将十进制数%d转化为%d进制是:\n",n,flag);while(n){s->top=s->base;s->stacksize=stack_init_size;return 1;}int Push(sqstack *s,int e){if(s->top-s->base>=s->stacksize){s->base=(int*)realloc(s->base,(s->stacksize+stackincrement)*sizeof(int)); if(!s->base)return 0;s->top=s->base+s->stacksize;s->stacksize+=stackincrement;}*(s->top++)=e;return e;}int Pop(sqstack *s,int e){if(s->top==s->base)return 0;e=*--s->top;return e;}int stackempty(sqstack *s){if(s->top==s->base){return 1;}elsePush(s,n%flag);n=n/flag;}while(!stackempty(s)) {e=Pop(s,e);switch(e){case 10: printf("A");break;case 11: printf("B");break;case 12: printf("C");break;case 13: printf("D");break;case 14: printf("E");break;case 15: printf("F");break;default: printf("%d",e); }}printf("\n");return 0;}int main(){sqstack s;StackInit(&s); conversion(&s);return 0;}。

数据结构实验二

数据结构实验二

数据结构实验二数据结构实验二:队列与栈的实现一、实验目的本实验旨在通过实现队列和栈数据结构,加深对队列和栈实现原理的理解,并熟练掌握队列和栈的基本操作。

二、实验要求1.使用C/C++语言实现队列的基本操作:初始化队列、入队、出队、判空、判满等。

2.使用C/C++语言实现栈的基本操作:初始化栈、入栈、出栈、判空、判满等。

3.验证队列和栈的实现是否正确。

4.分析队列和栈的时间复杂度,并给出实验结果。

5.撰写实验报告,包括实验目的、实验原理、实验步骤、程序源代码、实验结果和分析、实验总结等内容。

三、实验原理1.队列:队列是一种先进先出(FIF0)的数据结构。

在队列中,数据元素按照进入队列的顺序排列,首元素是最先进入的元素,尾元素是最后进入的元素。

队列的基本操作有:初始化队列、入队、出队、判空、判满等。

2.栈:栈是一种后进先出(LIFO)的数据结构。

在栈中,数据元素按照进入栈的顺序排列,但是只能从栈顶进出,即最后进入的元素最先出栈。

栈的基本操作有:初始化栈、入栈、出栈、判空、判满等。

四、实验步骤1.实现队列的基本操作:1.初始化队列:创建一个空队列,并设置相关指针。

2.入队:将新元素插入到队尾。

3.出队:将队头元素删除,并返回其值。

4.判空:判断队列是否为空。

5.判满:判断队列是否已满。

2.实现栈的基本操作:1.初始化栈:创建一个空栈,并设置相关指针。

2.入栈:将新元素压入栈顶。

3.出栈:将栈顶元素弹出,并返回其值。

4.判空:判断栈是否为空。

5.判满:判断栈是否已满。

3.编写测试代码,验证队列和栈的基本操作是否正确。

4.进行性能测试,分析队列和栈的时间复杂度。

五、实验结果与分析1.队列的时间复杂度:●初始化队列:O(1)●入队:O(1)●出队:O(1)●判空:O(1)●判满:O(1)2.栈的时间复杂度:●初始化栈:O(1)●入栈:O(1)●出栈:O(1)●判空:O(1)●判满:O(1)3.根据实验结果可以看出,队列和栈的基本操作的时间复杂度都是O(1),即常数时间复杂度,具有高效性。

数据结构第二章实验报告

数据结构第二章实验报告

数据结构第二章实验报告一、实验目的数据结构第二章主要涉及线性表的相关知识,本次实验的目的在于通过实际操作和编程实现,深入理解线性表的概念、存储结构以及基本操作,巩固所学的理论知识,并提高编程能力和问题解决能力。

二、实验环境本次实验使用的编程语言为C++,编程环境为Visual Studio 2019。

三、实验内容(一)顺序表的实现顺序表是一种用顺序存储方式实现的线性表。

在实验中,我们定义了一个结构体来表示顺序表,包括存储数据的数组和表示表长度的变量。

实现了顺序表的初始化、插入、删除、查找等基本操作。

(二)链表的实现链表是一种通过指针链接实现的线性表。

我们分别实现了单向链表和双向链表。

在单向链表中,每个节点包含数据和指向下一个节点的指针;双向链表则在此基础上增加了指向前一个节点的指针,使得链表的操作更加灵活。

(三)线性表的应用运用实现的线性表解决了一些实际问题,如数据排序、查找特定元素等。

四、实验步骤(一)顺序表的实现步骤1、定义顺序表结构体,包括数据数组和长度变量。

2、实现顺序表的初始化函数,将长度初始化为 0。

3、插入操作:首先判断表是否已满,如果未满,在指定位置插入元素,并将后续元素后移。

4、删除操作:首先判断指定位置是否合法,然后将该位置元素删除,并将后续元素前移。

5、查找操作:遍历表中的元素,找到目标元素返回其位置,否则返回-1。

(二)链表的实现步骤1、单向链表定义单向链表节点结构体,包含数据和指向下一个节点的指针。

实现链表的初始化函数,创建头节点。

插入操作:分为头插法和尾插法,根据插入位置的不同选择相应的方法。

删除操作:找到要删除的节点,将其前后节点连接起来,释放删除节点的内存。

查找操作:遍历链表,找到目标元素返回节点指针,否则返回NULL。

2、双向链表定义双向链表节点结构体,包含数据、指向前一个节点和指向下一个节点的指针。

初始化函数与单向链表类似,但需要同时处理前后指针。

插入和删除操作:在单向链表的基础上,同时更新前后节点的指针。

数据结构实验二链表

数据结构实验二链表

数据结构实验二1、实验目的∙熟练掌握线性表的链式存储结构定义及基本操作∙理解循环链表和双链表的特点和基本运算2、实验内容:建立单链表,完成链表(带表头结点)的基本操作:建立链表、插入、删除、查找、输出、求前驱、求后继、两个有序链表的合并操作。

其他基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、搜索结点。

1.问题描述:利用线性表的链式存储结构,设计一组输入数据(假定为一组整数),能够对单链表进行如下操作:∙初始化一个带表头结点的空链表;∙创建一个单链表是从无到有地建立起一个链表,即一个一个地输入各结点数据,并建立起前后相互链接的关系。

又分为逆位序(插在表头)输入n 个元素的值和正位序(插在表尾)输入n 个元素的值;∙插入结点可以根据给定位置进行插入(位置插入),也可以根据结点的值插入到已知的链表中(值插入),且保持结点的数据按原来的递增次序排列,形成有序链表。

∙删除结点可以根据给定位置进行删除(位置删除),也可以把链表中查找结点的值为搜索对象的结点全部删除(值删除);∙输出单链表的内容是将链表中各结点的数据依次显示,直到链表尾结点;∙求前驱结点是根据给定结点的值,在单链表中搜索其当前结点的后继结点值为给定的值,将当前结点返回;∙求后继结点是根据给定结点的值,在单链表中搜索其当前结点的值为给定的值,将后继结点返回;∙两个有序链表的合并是分别将两个单链表的结点依次插入到第3 个单链表中,继续保持结点有序;编写主程序,实现对各不同的算法调用。

其它的操作算法描述略。

2.实现要求:对链表的各项操作一定要编写成为C(C++)语言函数,组合成模块化的形式,还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价。

∙“初始化算法”的操作结果:构造一个空的线性表L,产生头结点,并使L 指向此头结点;∙“建立链表算法”初始条件:空链存在;操作结果:选择逆位序或正位序的方法,建立一个单链表,并且返回完成的结果;∙“链表(位置)插入算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中第i 个位置之前插入元素e;∙“链表(位置)删除算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中,删除第i 个元素,并由e 返回其值;∙“输出算法”初始条件:链表L 已存在;操作结果:依次输出链表的各个结点的值;∙“求前驱算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是第一个,则用pre_e 返回它的前驱;∙“求后继算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是最后一个,则用next_e 返回它的后继;∙“两个有序链表的合并算法”初始条件: 线性表单链线性表La 和Lb 的元素按值非递减排列;操作结果:归并La 和Lb 得到新的单链表。

数据结构实验报告

数据结构实验报告

数据结构实验报告数据结构实验报告1.实验目的1.1 理解数据结构的基本概念和原理1.2 掌握数据结构的常用算法和操作方法1.3 培养编写高效数据结构代码的能力2.实验背景2.1 数据结构的定义和分类2.2 数据结构的应用领域和重要性3.实验内容3.1 实验一:线性表的操作3.1.1 线性表的定义和基本操作3.1.2 实现顺序存储结构和链式存储结构的线性表 3.1.3 比较顺序存储结构和链式存储结构的优缺点3.2 实验二:栈和队列的实现3.2.1 栈的定义和基本操作3.2.2 队列的定义和基本操作3.2.3 比较栈和队列的应用场景和特点3.3 实验三:树的操作3.3.1 树的定义和基本概念3.3.2 实现二叉树的遍历和插入操作3.3.3 比较不同类型的树的存储结构和算法效率3.4 实验四:图的遍历和最短路径算法3.4.1 图的定义和基本概念3.4.2 实现深度优先搜索和广度优先搜索算法3.4.3 实现最短路径算法(例如Dijkstra算法)4.实验步骤4.1 实验一的步骤及代码实现4.2 实验二的步骤及代码实现4.3 实验三的步骤及代码实现4.4 实验四的步骤及代码实现5.实验结果与分析5.1 实验一的结果和分析5.2 实验二的结果和分析5.3 实验三的结果和分析5.4 实验四的结果和分析6.实验总结6.1 实验心得体会6.2 实验中存在的问题及解决方案6.3 对数据结构的理解和应用展望7.附件实验所使用的源代码、运行截图等相关附件。

8.法律名词及注释8.1 数据结构:指计算机中数据的存储方式和组织形式。

8.2 线性表:一种数据结构,其中的元素按照顺序排列。

8.3 栈:一种特殊的线性表,只能在一端进行插入和删除操作。

8.4 队列:一种特殊的线性表,按照先进先出的顺序进行插入和删除操作。

8.5 树:一种非线性的数据结构,由节点和边组成。

8.6 图:一种非线性的数据结构,由顶点和边组成。

数据结构实验2——栈和队列实验报告

数据结构实验2——栈和队列实验报告

数据结构实验报告实验名称:实验2——栈和队列1 实验目的通过选择下面五个题目之一进行实现,掌握如下内容:进一步掌握指针、模板类、异常处理的使用掌握栈的操作的实现方法掌握队列的操作的实现方法学习使用栈解决实际问题的能力学习使用队列解决实际问题的能力2 实验内容利用栈结构实现八皇后问题。

八皇后问题19世纪著名的数学家高斯于1850年提出的。

他的问题是:在8*8的棋盘上放置8个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行、同一列、同一斜线上。

请设计算法打印所有可能的摆放方法。

提示:1、可以使用递归或非递归两种方法实现2、实现一个关键算法:判断任意两个皇后是否在同一行、同一列和同一斜线上2. 程序分析主程序:#include<iostream>using namespace std;const int StackSize=8; //皇后的个数int num=0;template <class T>class SeqStack //定义顺序栈模板类{public:SeqStack(){top=-1;} //构造函数,初始化空栈void Push(T x); //入栈操作void Pop();//出栈操作void PlaceQueen(int row); //放置皇后bool Judgement();//判断是否符合条件void Print();//输出符合条件的皇后排列bool Empty(){if(top==-1) return true;else return false;}; //判断栈是否为空private:T data[StackSize]; //定义数组int top; //栈顶指针};template <class T>void SeqStack<T>::Push(T x) //入栈操作{if(top>=StackSize-1) throw"上溢";top++;//栈顶指针上移data[top]=x;}template <class T>void SeqStack<T>::Pop()//出栈操作{if(Empty()) throw"下溢";top--;//栈顶指针下移}template <class T>bool SeqStack<T>::Judgement()//判断该位置是否合适{for(int i=0;i<top;i++)if(data[top]==data[i]||(abs(data[top]-data[i]))==(top-i))//判断是否满足任意两个皇后不在同列同一斜线return false;return true;}template <class T>void SeqStack<T>::PlaceQueen(int row) //放置皇后{for (int i=0;i<StackSize;i++){Push(i); //入栈if (Judgement())//判断位置是否合适{if (row<StackSize-1)PlaceQueen(row+1); //如果合适满足条件则放置一个皇后,递归调用else{num++;//不满足条件则到下一行Print();//输出符合条件的皇后}}Pop();//出栈}}template <class T>void SeqStack<T>::Print()//输出皇后函数{cout<<"NO."<<num<<":"<<endl; for(int i=0;i<StackSize;i++){for(int j=0;j<data[i];j++){cout<<"□";}cout<<"■";for(int j=StackSize-1;j>data[i];j--){cout<<"□";}cout<<endl;}cout<<endl;}void main(){SeqStack<int> Queen;Queen.PlaceQueen(0);cout<<"总共有"<<num<<"种摆放方法。

厦门理工学院数据结构实验2

厦门理工学院数据结构实验2

《数据结构》实验报告实验序号:2 实验项目名称:顺序表的实现四、实验结果与数据处理1.设A、B均为用数组实现的List类型的有序顺序表,试设计一个函数Alternate,从A、B读取值,构件数组C,使得C的值也有序。

要求:用不同的方式实现(至少两种),并比较算法的效率。

(1)运行结果:图1:先合并之后再排序图2:合并时排序(2)问题分析:在这一问题中,A顺序表和B顺序表的合并方法可以分为先将这两个顺序表合并后排序或者在输入时就对其进行比较元素大小排序。

这里第一种方法,因为上一次实验学习过了快速排序,所以这一次我采用了另一种方法——希尔排序,希尔排序法是对直接插入排序法的优化,通过设置一个增量,对原始序列进行分组,对每组用直接插入排序法排序再整合,再缩小增量,周而复始直至增量为1,完成排序,因此又叫“缩小增量排序法”。

希尔排序的算法性能在面对大量数据时会高于快速排序,它的平均时间复杂度为n*log2n,整体范围为n^(1.3—2)之间。

第二种方法是我们在输入时就对新顺序表进行排序,在输入A顺序表的时候我们正常接收数据,而在输入B顺序表时,我们通过遍历一次当前顺序表同时结合插入数据函数来将B顺序表输入的数据放到正确的位置上,来使整个顺序表能够有序,整体时间复杂度为n^2左右,可见第一种方法的算法效率会更高一些。

2.顺序表表示和实现线性表的如下:【要求】(1)实现顺序表的插入、删除、按值查找等基本操作;(2)假设构建的是非递增有序顺序表,设计算法实现从该有序顺序表中删除所有其值重复的元素,使得表中所有元素的值均不同。

(3)设有一元素为整数的线性表L=(a1,a2,a3,…,an),存放在一维数组A[N]中,设计一个算法,以表中an作为参考元素,将该表分为左、右两部分,其中左半部分每个元素小于等于an,右半部分每个元素都大于an, an位于分界位置上(要求结果仍存放在A[N]中)。

(4)分析以上算法的时间复杂性。

数据结构课程实验报告

数据结构课程实验报告

数据结构课程实验报告数据结构课程实验报告引言:数据结构是计算机科学中非常重要的一门课程,它研究了数据的组织、存储和管理方法。

在数据结构课程中,我们学习了各种数据结构的原理和应用,并通过实验来加深对这些概念的理解。

本文将对我在数据结构课程中的实验进行总结和分析。

实验一:线性表的实现与应用在这个实验中,我们学习了线性表这种基本的数据结构,并实现了线性表的顺序存储和链式存储两种方式。

通过实验,我深刻理解了线性表的插入、删除和查找等操作的实现原理,并掌握了如何根据具体应用场景选择合适的存储方式。

实验二:栈和队列的实现与应用栈和队列是两种常见的数据结构,它们分别具有后进先出和先进先出的特点。

在这个实验中,我们通过实现栈和队列的操作,加深了对它们的理解。

同时,我们还学习了如何利用栈和队列解决实际问题,比如迷宫求解和中缀表达式转后缀表达式等。

实验三:树的实现与应用树是一种重要的非线性数据结构,它具有层次结构和递归定义的特点。

在这个实验中,我们学习了二叉树和二叉搜索树的实现和应用。

通过实验,我掌握了二叉树的遍历方法,了解了二叉搜索树的特性,并学会了如何利用二叉搜索树实现排序算法。

实验四:图的实现与应用图是一种复杂的非线性数据结构,它由节点和边组成,用于表示事物之间的关系。

在这个实验中,我们学习了图的邻接矩阵和邻接表两种存储方式,并实现了图的深度优先搜索和广度优先搜索算法。

通过实验,我深入理解了图的遍历方法和最短路径算法,并学会了如何利用图解决实际问题,比如社交网络分析和地图导航等。

实验五:排序算法的实现与比较排序算法是数据结构中非常重要的一部分,它用于将一组无序的数据按照某种规则进行排列。

在这个实验中,我们实现了常见的排序算法,比如冒泡排序、插入排序、选择排序和快速排序等,并通过实验比较了它们的性能差异。

通过实验,我深入理解了排序算法的原理和实现细节,并了解了如何根据具体情况选择合适的排序算法。

结论:通过这些实验,我对数据结构的原理和应用有了更深入的理解。

数据结构实验报告(实验)

数据结构实验报告(实验)

数据结构实验报告(实验)数据结构实验报告(实验)1. 实验目的1.1 理解数据结构的基本概念和操作1.2 学会使用数据结构解决实际问题1.3 掌握常用数据结构的实现和应用2. 实验环境2.1 操作系统:Windows 102.2 编程语言:C++2.3 开发工具:Visual Studio3. 实验内容3.1 实验一:线性表的实现和应用3.1.1 设计并实现线性表的基本操作函数3.1.2 实现线性表的插入、删除、查找等功能 3.1.3 实现线性表的排序算法3.1.4 应用线性表解决实际问题3.2 实验二:栈和队列的实现和应用3.2.1 设计并实现栈的基本操作函数3.2.2 设计并实现队列的基本操作函数3.2.3 实现栈和队列的应用场景3.2.4 比较栈和队列的优缺点3.3 实验三:树的实现和应用3.3.1 设计并实现二叉树的基本操作函数3.3.2 实现二叉树的创建、遍历和查找等功能3.3.3 实现树的遍历算法(前序、中序、后序遍历)3.3.4 应用树解决实际问题4. 数据结构实验结果4.1 实验一的结果4.1.1 线性表的基本操作函数实现情况4.1.2 线性表的插入、删除、查找功能测试结果4.1.3 线性表的排序算法测试结果4.1.4 线性表解决实际问题的应用效果4.2 实验二的结果4.2.1 栈的基本操作函数实现情况4.2.2 队列的基本操作函数实现情况4.2.3 栈和队列的应用场景测试结果4.2.4 栈和队列优缺点的比较结果4.3 实验三的结果4.3.1 二叉树的基本操作函数实现情况4.3.2 二叉树的创建、遍历和查找功能测试结果 4.3.3 树的遍历算法测试结果4.3.4 树解决实际问题的应用效果5. 实验分析与总结5.1 实验问题与解决方案5.2 实验结果分析5.3 实验总结与心得体会6. 附件附件一:实验源代码附件二:实验数据7. 法律名词及注释7.1 版权:著作权法规定的对原创作品享有的权利7.2 专利:国家授予的在一定时间内对新型发明享有独占权利的证书7.3 商标:作为标识企业商品和服务来源的标志的名称、符号、图案等7.4 许可协议:指允许他人在一定条件下使用自己的知识产权的协议。

国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案

国家开放大学《数据结构》课程实验报告(实验2——线性表)参考答案
printf("\n");
//在链表中删除最高分和最低分结点
for(q=head,p=head->next;p!=NULL;q=p,p=p->next)
{
if(p==pmin) { q->next=p->next; p=q; } //删除最低分结点
};
typedef struct pw PW;
//定义链表结点
struct node
{
PW data;
struct node * next;
};
typedef struct node NODE;
NODE *create(int n); //建立单链表
void input(NODE *s,int i); //输入第i个评委信息
(5)遍历链表,累加求和,计算总分及平均分,并输出相关信息。
完整程序
//实验1.1线性表的链接存储结构
#include
#include
#include
#define PWRS 5 //定义评委人数
//定义评委信息
struct pw
{
char name[8]; //姓名
short age; //年龄
float score; //评分
NODE *create(int n)
{
NODE *head,*p,*q;
inti;
p=(NODE*)malloc(sizeof(NODE));
head=p; q=p; p->next=NULL;
for(i=1; i<=n; i++)
{
p=(NODE*)malloc(sizeof(NODE));

《数据结构》实验报告二(样例参考)

《数据结构》实验报告二(样例参考)

《数据结构》实验报告二系别:班级:学号:姓名:日期:指导教师:一、上机实验的问题和要求:单链表的查找、插入与删除。

设计算法,实现线性结构上的单链表的产生以及元素的查找、插入与删除。

具体实现要求:1.从键盘输入10个字符,产生不带表头的单链表,并输入结点值。

2.从键盘输入1个字符,在单链表中查找该结点的位置。

若找到,则显示“找到了”;否则,则显示“找不到”。

3.从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出单链表所有结点值,观察输出结果。

4.从键盘输入1个整数,表示欲删除结点的位置,输出单链表所有结点值,观察输出结果。

5.(★)将单链表中值重复的结点删除,使所得的结果表中各结点值均不相同,输出单链表所有结点值,观察输出结果。

6.(★)删除其中所有数据值为偶数的结点,输出单链表所有结点值,观察输出结果。

7.(★)将单链表分解成两个单链表A和B,使A链表中含有原链表中序号为奇数的元素,而B链表中含有原链表中序号为偶数的元素,且保持原来的相对顺序,分别输出单链表A和单链表B的所有结点值,观察输出结果。

二、程序设计的基本思想,原理和算法描述:(包括程序的结构,数据结构,输入/输出设计,符号名说明等)1.程序结构:定义一个主函数和五个子函数(分别用来实现单链表的创建、查找、插入、删除及单链表的打印)。

2.数据结构:定义一个结构体,作为单链表的结点。

typedef struct stu /*DataType可以是任何相应的数据类型如int, float或char*/ {char Name[Max]; /*定义了数据域,这里存放的是一个字符型数组*/struct stu *next; /*定义了指针域*/}student;3.输入输出设计:创建单链表函数:student *create();输入:通过scanf( )函数及for语句为数据域定义,并定义指针域的指针所指的下一个结点。

数据结构 实验二:单链表的基本操作

数据结构 实验二:单链表的基本操作

数据结构实验二:单链表的基本操作数据结构实验二:单链表的基本操作实验二:单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。

2、掌握建立单链表和显示单链表元素的算法。

3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表,手动输入10个数,并从屏幕显示单链表元素列表。

2、从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置;如果不存在,给出相应提示。

3、删除上述单链表中指定位置的元素。

以下就是程序部分代码,恳请调试并补足并使之恰当运转:1.linlist.htypedefstructnode{datatypedata;structnode*next;}slnode;voidlistinitiate(slnode**head)/*初始化*/{/*如果有内存空间,申请头结点空间并使头指针head指向头结点*/if((*head=(slnode*)malloc(sizeof(slnode)))==null)exit(1);(*head)->next=null;/*置链尾标记null*/}intlistlength(slnode*head){slnode*p=head;/*p指向首元结点*/intsize=0;/*size初始为0*/while(p->next!=null)/*循环计数*/{p=p->next;size++;}returnsize;}intlistinsert(slnode*head,inti,datatypex)/*在带头结点的单链表head的数据元素ai(0≤i≤size)结点前*//*填入一个存放数据元素x的结点*/{slnode*p,*q;intj;p=head;/*p指向首元结点*/j=-1;/*j起始为-1*/while(p->next!=null&&j<i-1)/*最终让指针p指向数据元素ai-1结点*/{p=p->next;j++;}if(j!=i-1){printf(\填入边线参数弄错!\return0;}/*生成新结点由指针q指示*/if((q=(slnode*)malloc(sizeof(slnode)))==null)exit(1);q->data=x;q->next=p->next;/*给指针q->next赋值*/p->next=q;/*给指针p->next重新赋值*/return1;}intlistdelete(slnode*head,inti,datatype*x)/*删除带头结点的单链表head的数据元素ai(0≤i≤size-1)结点*//*删除结点的数据元素域值由x带回。

数据结构实验二 线性表

数据结构实验二 线性表

数据结构实验二线性表数据结构实验二线性表1. 实验目的1.1 理解线性表的概念和特性1.2 学习线性表的顺序存储结构和链式存储结构1.3 掌握线性表的基本操作:初始化、插入、删除、查找、修改、遍历等1.4 熟悉线性表的应用场景2. 实验内容2.1 线性表的顺序存储结构实现2.1.1 定义线性表结构体2.1.2 初始化线性表2.1.3 插入元素2.1.4 删除元素2.1.5 查找元素2.1.6 修改元素2.1.7 遍历线性表2.2 线性表的链式存储结构实现2.2.1 定义链表节点结构体2.2.2 初始化链表2.2.3 插入元素2.2.4 删除元素2.2.5 查找元素2.2.6 修改元素2.2.7 遍历链表3. 实验步骤3.1 实现顺序存储结构的线性表3.2 实现链式存储结构的线性表3.3 编写测试程序,验证线性表的各种操作是否正确3.4 进行性能测试,比较两种存储结构的效率差异4. 实验结果与分析4.1 执行测试程序,检查线性表的操作结果是否正确4.2 对比顺序存储结构和链式存储结构的性能差异4.3 分析线性表的应用场景,总结线性表的优缺点5. 实验总结5.1 总结线性表的定义和基本操作5.2 回顾实验中遇到的问题和解决方法5.3 提出对线性表实现的改进方向和思考附件:请参考附件中的源代码和实验报告模板。

法律名词及注释:1. 版权:指对某一作品享有的法律上的权利,包括复制权、发行权、改编权等。

2. 法律责任:指违反法律或合同规定所承担的责任。

3. 保密义务:指个人或组织根据法律、法规、合同等规定需要承担的保密责任。

4.知识产权:指人们在社会实践中所创造的智力劳动成果所享有的权利,包括专利权、著作权、商标权等。

数据结构实验报告(二)栈的应用

数据结构实验报告(二)栈的应用

数据结构实验报告(⼆)栈的应⽤实验说明数据结构实验⼆ 栈的实验——栈的简单应⽤⼀、实验⽬的通过本实验使学⽣了解栈的简单应⽤,熟悉栈的特性及栈在顺序存储上的操作特点,深刻理解栈的基本操作与⽤栈解决应⽤问题的关系;特别训练学⽣使⽤栈解决实际问题的能⼒,为今后⽤栈解决相关问题奠定基础。

⼆、实验内容1.编程实现对给定的⼀组括号序列判断其是否匹配正确。

要求:(1)它必须成对出现,如“(”“)”是⼀对,“[”与“]”是⼀对;(2)出现时有严格的左右关系;(3)可以以嵌套的⽅式同时出现多组多括号,但必须是包含式嵌套,不允许交叉式嵌套。

⽐如“( )”、“[([][])]”这样是正确的,“[(])”或“([()))”或 “(()]”是不正确的。

(4)将处理的括号扩展为针对“()”“[]”“{}”三类。

2.编程实现⼀个简单的⾏编辑功能:⽤户可以输⼊⼀⾏内容,并可进⾏简易编辑。

要求:(1)遇到输⼊部分内容有误时操作退格符“#”表⽰前⼀位⽆效;(2)“@”表⽰之前的内容均⽆效。

实验报告1.实现功能描述编程实现对给定的⼀组括号序列判断其是否匹配正确,将处理的括号扩展为针对“()”“[]”“{}”三类,遇到输⼊部分内容有误时操作退格符“#”表⽰前⼀位⽆效;“@”表⽰之前的内容均⽆效。

2.⽅案⽐较与选择(1)可以使⽤栈和队列来实现。

因为栈的功能⾜以完成题⽬要求,所以初步打算使⽤栈来实现。

(2)因为编写⼀个标准的栈⽐较繁琐,⽽且本题中也没有⽤到所有栈的标准操作,所以通过模拟栈来完成本题。

(3)可以使⽤数组或链表来模拟栈。

因为括号匹配只有3对,所需空间不是很⼤,⼜因为特殊操作#、@可以在数组中通过-1和赋0值实现,因此选择了数组法来模拟栈。

3.设计算法描述(1)定义3个变量,分别⽤于记录()、[]、{}的出现次数。

遇到左符号时变量++,遇到右符号时--,变量为0时表⽰空栈。

当读到#时,再往前读⼀个字符,如果是()、[]、{}中的⼀种,则对其进⾏反向运算,即遇到右符号时++,遇到左符号时--。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

《数据结构》实验报告实验序号:2 实验项目名称:顺序表的操作l->length=0;l->ListSize=LIST_INIT_SIZE;printf("ok");return 0;}}int ListInsert_Sq(sqlist *L,int i, ElemType e){ ElemType *q,*p;if(i<1 || i>L->length+1) return 1;if(L->length>=L->ListSize) {ElemType *newbase;newbase=( ElemType *)realloc(L->elem,(L->ListSize+LISTINCREMENT)*sizeof(ElemType));if(!newbase) return 1;L->elem=newbase;L->ListSize+=LISTINCREMENT;}q=&(L->elem[i-1]);for(p=&(L->elem [L->length-1]);p>=q;--p) *(p+1)=*p;*q=e;++L->length;return 0;}【要求】1、实现顺序表的插入、删除、按值查找等操作;2、假设构建的是非递减顺序表,设计算法实现从该有序顺序表中删除所有其值重复的元素,使得表中所有元素的值均不同。

四、实验结果与数据处理1:2:附源程序清单:1.#include<stdio.h>#include<stdlib.h>#define LIST_INIT_SIZE100 // 数组最大值#define INIT_ERROR-1 //初始化出错判断用typedef struct tadDATALIST//顺序表结构体{int nLength; //长度int anData[LIST_INIT_SIZE]; //数组int *pElem;}List, *pList;List C; //A和B组合后的新数组int InitList(pList D){int nLength = 0;int nInput = 0;char cOverSign ;//读取所有整数,输入回车结束输入while (1){if (scanf("%d", &nInput) != 1) //对于非法出入给出判断{printf("非法输入\n");return INIT_ERROR;}D-> anData[nLength] = nInput; //赋值nLength ++;if ((cOverSign = getchar()) == '\n') //按下回车键,结束输入{return nLength; //返回长度}}}int Alternate(pList anData_A, pList anData_B){C.nLength = 0; //初始化新数组的长度为0int nIndex1 = 0;int nIndex2 = 0;while((nIndex1 < anData_A -> nLength) && (nIndex2 < anData_B -> nLength)) //当有一个数组到达长度限制后,退出执行后两个while语句中的一个{C.anData[C.nLength] = anData_A->anData[nIndex1]; //先把A的第一个元素给cnIndex1 ++;C.nLength++;C.anData[C.nLength] = anData_B->anData[nIndex2]; //接着把B的第一个元素给CnIndex2 ++;C.nLength++;}while (nIndex1 < anData_A->nLength){C.anData[C.nLength] = anData_A->anData[nIndex1];nIndex1 ++;C.nLength++;}while (nIndex2 < anData_B->nLength){C.anData[C.nLength] = anData_B->anData[nIndex2];nIndex2 ++;C.nLength++;}return 0;}int main(){int nIndex = 0;List A; //创建结构体的对象List B;printf("输入顺序表A的元素,以回车结束输入: ");if ((A.nLength = InitList(&A)) == INIT_ERROR) //判断是否初始化出错{printf("初始化出错\n");return 0;}printf("输入顺序表B的元素,以回车结束输入: "); //判断是否初始化出错if ((B.nLength = InitList(&B)) == INIT_ERROR){printf("初始化出错\n");return 0;}/* printf("%d\n", A.nLength);printf("%d\n", B.nLength);for (nIndex = 0; nIndex < A.nLength; nIndex++){printf("%d ", A.anData[nIndex]);}printf("\n");for (nIndex = 0; nIndex <B.nLength; nIndex++){printf("%d ", B.anData[nIndex]);}printf("\n");*/Alternate(&A ,&B); //合成新数组printf("新的顺序表C为 : ");for (nIndex = 0; nIndex < C.nLength; nIndex++){printf("%d ", C.anData[nIndex]);}printf("\n");return 0;}2.#include<stdio.h>#include<stdlib.h># define LIST_INIT_SIZE100 //顺序表初始化大小# define LIS_TINCREMENT_SIZE 50 //空间不够时,增加大小#define INIT_ERROR -1#define INIT_SUCCESS0#define ERROR-1#define SUCCESS0typedef struct tagDataList//顺序表结构体封装数据{int *pBaseAddr; //基地址int nlength; //长度int nListSize; //分配大小}SqList, *pSqList;int InitList(pSqList List) //顺序表初始化函数{int nInput;char cOverSign;List->pBaseAddr = (int *)malloc(LIST_INIT_SIZE * sizeof(int)); //开辟空间大小if (!List->pBaseAddr) //判断是否开辟成功{return INIT_ERROR;}List->nlength = 0; //长度初始化为0List->nListSize = LIST_INIT_SIZE;//读取所有整数,输入回车结束输入while (1){if (scanf("%d", &nInput) != 1) //对于非法出入给出判断{printf("非法输入\n");return INIT_ERROR;}List->pBaseAddr[List->nlength] = nInput; //赋值List->nlength++; //自增if ((cOverSign = getchar()) == '\n') //按下回车键,结束输入{return INIT_SUCCESS;}}}int SqListInsert(pSqList List) //插入数据函数{int nIndex;int nVar;int *npNewBaseAddr = NULL; //新基地址int *npInsertPlace = NULL; //要插入的位置int *npTemp = NULL; //中间过渡变量printf("请输入要插入的位置和要插入的数: ");scanf("%d%d", &nIndex, &nVar);if (nIndex < 0 || nIndex > List->nlength + 1 ) //判断是否在范围内{printf("要插入的位置不在顺序表的范围\n");return ERROR;}if (List->nlength >= List->nListSize) //当超出初始化分配空间大小时,分配更大空间{printf("空间不够,重新分配大空间\n");npNewBaseAddr = (int *)realloc(List->pBaseAddr, (LIS_TINCREMENT_SIZE +LIST_INIT_SIZE) * sizeof(int));if (!npNewBaseAddr) //判断重新分配是否成功{printf("重新分配空间失败\n");return ERROR;}List->pBaseAddr = npNewBaseAddr; //把重新分配的基地址给原先的List->nListSize += LIS_TINCREMENT_SIZE;}npInsertPlace = &(List->pBaseAddr[nIndex - 1]); //记录要插入的位置的地址for(npTemp = &(List->pBaseAddr[List->nlength - 1]); npTemp >= npInsertPlace; npTemp--) {*(npTemp + 1) = *npTemp; //把相对于插入位置后面的数据往右边移动一个单位}*npInsertPlace = nVar; //把要插入的值赋值给相应位置List->nlength++;return SUCCESS;}int SqListDelete(pSqList List) //删除数据{int nIndex;int *npDeletePlace = NULL;int *npTemp = NULL;printf("请输入你要删除的位置: ");scanf("%d", &nIndex);if (nIndex < 0 || nIndex > List->nlength) //判断位置是否合法{printf("要删除的位置不在顺序表的范围\n");return ERROR;}npDeletePlace = &(List->pBaseAddr[nIndex - 1]); //记录位置npTemp = List->pBaseAddr + List->nlength - 1; //空间大小for (++npDeletePlace; npDeletePlace <= npTemp; ++npDeletePlace){*(npDeletePlace - 1) = *npDeletePlace; //相应元素往左边移动一个单位}List ->nlength--; //自减return SUCCESS;}int SqListFindVar(pSqList List, int nVar) //按值查找函数{int nIndex;int nSign = 0;int *npFindPlace = NULL;int *npTemp = NULL;for (nIndex = 0; nIndex < List->nlength; nIndex++){if (nVar == List->pBaseAddr[nIndex]) //找到就给出提示{printf("你要的数在第 %d 个位置,该数为: %d \n", nIndex + 1, List->pBaseAddr[nIndex]);nSign = 1;break;}else{continue;}}if (!nSign) //没找到给出提示{printf("该数值不存在于顺序表中\n");}return SUCCESS;}/*对非递减顺序表,设计算法实现从该有序顺序表中删除所有其值重复的元素,使得表中所有元素的值均不同*/int SqListDeleteTheSame(pSqList List){int nIndex1 = 0;int nIndex2 = 0;int nSign = 0;int *npDeletePlace = NULL;int *npTemp = NULL;for (nIndex1 = 0; nIndex1 < List ->nlength - 1; nIndex1++) //冒泡法实现。

相关文档
最新文档