北理工数据结构作业2

第三章作业

1、写出下列程序段的输出结果。

viod main ( )

{ Stack S;

char x, y;

InitStack (S);

x=’c’; y=’k’;

Push(S, x); Push(S, ’a’); Push(S, y);

Pop(S, x); Push(S, ’t’); Push(S, x);

Pop(S, x); Push(S, ’s’);

while ( ! StackEmpty(S) )

{ Pop(S, y);

printf (y);

}

printf(x);

}

答：stack

2、简述下列算法的功能（栈的元素类型SElemType为int）。（1）Ststus algo1(Stack S)

{ int I, n, A[255];

n=0;

while ( ! StackEmpty(S) )

{ n++; Pop(S, A[n]);

}

for ( i=1; i<=n; i++ )

Push(S, A[n]);

}

答：实现栈中元素的逆置

（2）Status algo2(Stack S, int e)

{ Stack T; int d;

InitStack (T);

while ( ! StackEmpty(S) )

{ Pop(S, d);

if ( d!=e ) Push(T, d);

}

while ( ! StackEmpty(T) )

{ Pop (T, d);

Push (S, d);

}

}

答：通过栈T的辅助删除栈S中所有值为e的元素

3、设有4个元素1、2、3、4依次进栈，而出栈操作可随时进行（进出栈可任意

交错进行，但要保证进栈次序不破坏1、2、3、4的相对次序），请写出所有可能的出栈次序。

答：共14种情况，顺序如下：

1234，1243，1324，1342，1432，2134，2143，2314，2341，2431，3421，3241，3214，4321。

4、写出下列程序段的输出结果（队列中的元素类型QelemType为char）。

viod main ( )

{ Queue Q; InitQueue(Q);

char x=’e’, y=’c’;

EnQueue(Q, ’h’); EnQueue(Q, ’r’); EnQueue(Q, y);

DeQueue(Q, x); EnQueue(Q, x);

DeQueue(Q, x); EnQueue(Q,’a’);

while ( ! QueueEmpty(Q) )

{ DeQueue(Q, y);

printf(y);

}

}

答：cha

5、简述下列算法的功能（栈和队列的元素类型均为int）。

void algo3(Queue &Q)

{ Stack S; int d;

InitStack (S);

while ( ! QueueEmpt(Q) )

{ DeQueue(Q, d); Push(S, d);

}

while ( ! StackEmpty(S) )

{ Pop(S, d); EnQueue(Q, d);

}

}

答：利用栈S将队列Q中的元素进行逆置。

6、为了充分利用空间，将两个栈共同存储在长度为n的一维数组中，共享数组

空间。设计两个栈共享一维数组的存储表示方式，画出示意图。

答：设计两个栈Stack1和Stack2共享数组空间，Stack1的栈底放在数组的首端，Stack2的栈底放在数组的尾端，分别向两个栈中存储相应的元素，两个栈的栈顶分别向数组中间扩展。当总的存储空间不大于数组长度时，数组空间将得到最大利用。当两个栈占满整个数组空间时，这时两个栈共享一个长度为n的数组空间，再向栈中放元素时会发生上溢。

实验二

1、简单计算器。

请按照四则运算加、减、乘、除、幂（^）和括号的优先关系和惯例，编写计算器程序。要求：

①从键盘输入一个完整的表达式，以回车作为表达式输入结束的标志。

②输入表达式中的数值均为大于等于零的整数。中间的计算过程如果出现

小数也只取整。

例如，输入：4+2*5= 输出：14

输入：(4+2)*(2-10)= 输出：-48

程序如下：

#include

#include

#include

#define OK 1

#define ERROR 0

#define OVERFLOW -2

#define STACK_INIT_SIZE 100 //存储空间初始分配量

#define STACKINCREMENT 10 //存储空间分配增量

typedef struct{//定义运算符栈数据类型

char *base;

char *top;

int stacksize;

}SqStack1;

typedef struct{//定义操作数栈数据类型

int *base;

int *top;

int stacksize;

}SqStack2;

int InitStack1(SqStack1 &S){//构造一个空的运算符栈

S.base=(char *)malloc(STACK_INIT_SIZE*sizeof(char));

if(!S.base) exit(OVERFLOW);

S.top=S.base;

S.stacksize=STACK_INIT_SIZE;

return OK;

}//InitStack1

int InitStack2(SqStack2 &S){//构造一个空的操作数栈

S.base=(int *)malloc(STACK_INIT_SIZE*sizeof(int));

if(!S.base) exit(OVERFLOW);

S.top=S.base;

S.stacksize=STACK_INIT_SIZE;

return OK;

}//InitStack2

char GetTop1(SqStack1 S){//若栈不空，则用char型元素e返回S的栈顶元素，并返回OK；否则返回ERROR

char e;

if(S.top==S.base) return ERROR;

e=*(S.top-1);

return e;

}//GetTop1

int GetTop2(SqStack2 S){//若栈不空，则用int型元素e返回S的栈顶元素，并返回OK；否则返回ERROR

int e;

if(S.top==S.base) return ERROR;

e=*(S.top-1);

return e;

}//GetTop2

int Push1(SqStack1 &S,char e){//插入char型元素e为新的栈顶元素if(S.top-S.base>=S.stacksize){

S.base=(char

*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(char));

if(!S.base) exit(OVERFLOW);

S.top=S.base+S.stacksize;

S.stacksize+=STACKINCREMENT;

}

*S.top++=e;

return OK;

}//Push1

int Push2(SqStack2 &S,int e){//插入int型元素e为新的栈顶元素

if(S.top-S.base>=S.stacksize){

S.base=(int

*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(int));

if(!S.base) exit(OVERFLOW);

S.top=S.base+S.stacksize;

S.stacksize+=STACKINCREMENT;

}

*S.top++=e;

return OK;

}//Push2

int Pop1(SqStack1 &S,char &e){//若栈不空，则删除S的栈顶元素，用char型元素e返回其值，并返回OK；否则返回ERROR

if(S.top==S.base) return ERROR;

e=*--S.top;

return OK;

}//Pop1

int Pop2(SqStack2 &S,int &e){//若栈不空，则删除S的栈顶元素，用int型元素e

返回其值，并返回OK；否则返回ERROR

if(S.top==S.base) return ERROR;

e=*--S.top;

return OK;

}//Pop2

char Precede(char a,char b){//比较两个相继出现的运算符a和b间的优先级关系switch(a){

case '+':

switch(b){

case'+':return'>';break;

case'-':return'>';break;

case'*':return'<';break;

case'/':return'<';break;

case'(':return'<';break;

case')':return'>';break;

case'=':return'>';break;

case'^':return'<';break;

}

case'-':

switch(b){

case'+':return'>';break;

case'-':return'>';break;

case'*':return'<';break;

case'/':return'<';break;

case'(':return'<';break;

case')':return'>';break;

case'=':return'>';break;

case'^':return'<';break;

}

case'*':

switch(b){

case'+':return'>';break;

case'-':return'>';break;

case'*':return'>';break;

case'/':return'>';break;

case'(':return'<';break;

case')':return'>';break;

case'=':return'>';break;

case'^':return'<';break;

}

case'/':

switch(b){

case'+':return'>';break;

case'-':return'>';break;

case'*':return'>';break;

case'/':return'>';break;

case'(':return'<';break;

case')':return'>';break;

case'=':return'>';break;

case'^':return'<';break;

}

case'^':

switch(b){

case'+':return'>';break;

case'-':return'>';break;

case'*':return'>';break;

case'/':return'>';break;

case'(':return'<';break;

case')':return'>';break;

case'=':return'>';break;

case'^':return'>';break;

}

case'(':

switch(b){

case'+':return'<';break;

case'-':return'<';break;

case'*':return'<';break;

case'/':return'<';break;

case'(':return'<';break;

case')':return'=';break;

case'^':return'<';break;

}

case')':

switch(b){

case'+':return'>';break;

case'-':return'>';break;

case'*':return'>';break;

case'/':return'>';break;

case')':return'>';break;

case'=':return'>';break;

case'^':return'>';break;

}

case'#':

switch(b){

case'+':return'<';break;

case'-':return'<';break;

case'*':return'<';break;

case'/':return'<';break;

case'(':return'<';break;

case'=':return'=';break;

case'^':return'<';break;

}

}

}//Precede

int pow(int a,int b){//求幂函数

int x;

for(x=1;b>0;b--) x=x*a;

return x;

}//pow

int Operate(int a,char theta,int b){//操作数a和b进行运算switch(theta){

case'+':return(a+b);

case'-':return(a-b);

case'*':return(a*b);

case'/':return(a/b);

case'^':return(pow(a,b));

}

}//Operate

int In(char c){//判断字符c是否为运算符

if(c!='+'&&c!='-'&&c!='*'&&c!='/'&&c!='^'&&c!='='&&c!='('&&c!=')') return ERROR;

else return OK;

}//In

int EvaluateExpression(){

int x,a,b;

char c,theta;

SqStack1 OPTR;

SqStack2 OPND;

InitStack1(OPTR);

InitStack2(OPND);

Push1(OPTR,'#');

c=getchar();

while(c!='\n'){

x=0;

if(!In(c))//c是操作数

{

while(!In(c))

{

x=x*10+c-48;

c=getchar();

}

Push2(OPND,x);

}

else//c是算符

switch(Precede(GetTop1(OPTR),c))

{

case'<':Push1(OPTR,c);c=getchar();break;//栈顶元素优先权低

case'=':Pop1(OPTR,c);c=getchar();break;//脱括号并接受下一个字符

case'>'://退栈并将运算结果入栈

Pop1(OPTR,theta);

Pop2(OPND,b);Pop2(OPND,a);

Push2(OPND,Operate(a,theta,b));

break;

}//switch

}//while

return GetTop2(OPND);

}//EvaluateExpression

main()

{ printf("%d",EvaluateExpression());} //注：本程序存为.cpp方可运行

北京理工大学《数据结构与算法设计》实验报告实验四

《数据结构与算法设计》 实验报告 ——实验四 学院： 班级： 学号： 姓名：

一、实验目的 1. 通过实验实践、巩固线性表的相关操作； 2. 熟悉VC 环境，加强编程、调试的练习； 3. 用C 语言实现线性表的抽象数据类型，实现线性表构造、插入、取数据等基本操作； 4. 理论知识与实际问题相结合，利用上述基本操作实现三种排序并输出。 二、实验内容 从键盘输入10个数，编程实现分别用插入排序、交换排序、选择排序算法进行排序，输出排序后的序列。 三、程序设计 1、概要设计 为了实现排序的功能，需要将输入的数字放入线性表中，进行进一步的排序操作。 (1)抽象数据类型： ADT SqList{ 数据对象：D={|,1,2,,,0}i i a a ElemSet i n n ∈=≥ 数据关系：R1=11{,|,,1,2,,}i i i i a a a a D i n --<>∈= 基本操作： InPut(SqList &L) 操作结果：构造一个线性表L 。 OutPut(SqList L) 初始条件：线性表L 已存在。 操作结果：按顺序在屏幕上输出L 的数据元素。 InsertSort(SqList &L) 初始条件：线性表L 已存在。 操作结果：对L 的数据元素进行插入排序。 QuickSort(SqList &L) 初始条件：线性表L 已存在。 操作结果：对L 的数据元素进行快速排序。 SelectSort(SqList &L) 初始条件：线性表L 已存在。 操作结果：对L 的数据元素进行选择排序。 }ADT SqList ⑵主程序流程 由主程序首先调用InPut(L)函数创建顺序表，调用InsertSort(L)函数进行插入排序， 调用OutPut(L)函数显示排序结果。调用QuickSort(L)函数进行交换排序，调用OutPut(L) 函数显示排序结果。调用SelectSort(L)函数进行选择排序，调用OutPut(L)函数显示排序 结果。 ⑶模块调用关系 由主函数模块调用创建顺序表模块，排序模块与显示输出模块。

数据结构实验4

（一）题目 1. 按下述原则编写快排的非递归算法： (1) 一趟排序之后，若子序列已有序(无交换)，则不参加排序，否则先对长度较短的子序列进行排序，且将另一子序列的上、下界入栈保存； (2) 若待排记录数<=3，则不再进行分割，而是直接进行比较排序。 测试实例：{49 38 65 97 76 13 27 49 88 21 105} （二）算法思路 (1) 建立存储序列上下界的栈序列。 (2) 对栈顶作如下判断： A. 若栈顶中记录的头与尾相距小于3，对对应的子序列进行排序，然后出栈，进入(3)； B. 若栈顶中记录的头与尾相距大于等于3，则进行分块，判断分块是否有序， a.若两分块都有序，则出栈，进入(3)； b.若只有一分块有序，则改变栈顶内容为无序分块内容，进入(3)； c.若两分块都无序，则改变栈顶内容为较长的无序块，然后把较短的无序块 压进栈。进入(3) (3)重复(2)的操作，直至栈空，得到最终结果。 （三）程序结构 定义的结构体及声明 （四）源码

using namespace std; typedef struct _stack{ int left; //lowerbound int right; //upperbound struct _stack *next; }qstack; //to store the child sequence's left and right void sort(int *arr, int left, int right){ //sort child sequence less than 3 for(int i = left; i <= right; i++){ int k = i; for(int j = i+1; j <= right; j++){ if(arr[k] > arr[j]) k = j; } if(k != i){ int t; t = arr[k]; arr[k] = arr[i]; arr[i] = t; } } } bool sorted(int *arr, int left, int right){ for(int i = left; i < right; i++){ if(arr[i] > arr[i+1]) return false; } return true; } void qsort(int *arr, int left, int right){ qstack *head; head = new qstack; head->left = left; head->right = right; head->next = NULL; qstack *p; while(head != NULL){ if(head->right - head->left < 3){ //if less than 3, sort and pop sort(arr, head->left, head->right);

数据结构实验

实验2 查找算法的实现和应用?实验目的 1. 熟练掌握静态查找表的查找方法； 2. 熟练掌握动态查找表的查找方法; 3. 掌握hash表的技术. ?实验内容 1.用二分查找法对查找表进行查找； 2.建立二叉排序树并对该树进行查找； 3.确定hash函数及冲突处理方法，建立一个hash表并实现查找。 程序代码 #include using namespace std; int main() { int arraay[10]={1,2,3,4,5,6,7,8,9,10}; int binary_search(int a[10],int t); cout<<"Enter the target:"; int target; cin>>target; binary_search(arraay,target); return 0; } int binary_search(int a[10],int t) { int bottom=0,top=9; while(bottom

cout<<"Not present!"; } return 0; } 结果 二叉排序树 #include #include #include using namespace std; typedef int keyType; typedef struct Node { keyType key; struct Node* left; struct Node* right; struct Node* parent; }Node,*PNode; void inseart(PNode* root, keyType key) { PNode p = (PNode)malloc(sizeof(Node)); p -> key = key;

数据结构实验报告全集

数据结构实验报告全集 实验一线性表基本操作和简单程序 1．实验目的 （1）掌握使用Visual C++ 6.0上机调试程序的基本方法； （2）掌握线性表的基本操作：初始化、插入、删除、取数据元素等运算在顺序存储结构和链表存储结构上的程序设计方法。 2．实验要求 （1）认真阅读和掌握和本实验相关的教材内容。 （2）认真阅读和掌握本章相关内容的程序。 （3）上机运行程序。 （4）保存和打印出程序的运行结果，并结合程序进行分析。 （5）按照你对线性表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果 实验代码： 1）头文件模块 #include iostream.h>//头文件 #include//库头文件-----动态分配内存空间 typedef int elemtype;//定义数据域的类型 typedef struct linknode//定义结点类型 { elemtype data;//定义数据域 struct linknode *next;//定义结点指针 }nodetype; 2）创建单链表

nodetype *create()//建立单链表，由用户输入各结点data域之值，//以0表示输入结束 { elemtype d;//定义数据元素d nodetype *h=NULL,*s,*t;//定义结点指针 int i=1; cout<<"建立一个单链表"<> d; if(d==0) break;//以0表示输入结束 if(i==1)//建立第一个结点 { h=(nodetype*)malloc(sizeof(nodetype));//表示指针h h->data=d;h->next=NULL;t=h;//h是头指针 } else//建立其余结点 { s=(nodetype*) malloc(sizeof(nodetype)); s->data=d;s->next=NULL;t->next=s; t=s;//t始终指向生成的单链表的最后一个节点

数据结构实验答案1

重庆文理学院软件工程学院实验报告册 专业：_____软件工程__ _ 班级：_____软件工程2班__ _ 学号：_____201258014054 ___ 姓名：_____周贵宇___________ 课程名称：___ 数据结构 _ 指导教师：_____胡章平__________ 2013年 06 月 25 日

实验序号 1 实验名称实验一线性表基本操作实验地点S-C1303 实验日期2013年04月22日 实验内容1.编程实现在顺序存储的有序表中插入一个元素（数据类型为整型）。 2.编程实现把顺序表中从i个元素开始的k个元素删除（数据类型为整型）。 3.编程序实现将单链表的数据逆置，即将原表的数据（a1,a2….an）变成 (an,…..a2,a1)。（单链表的数据域数据类型为一结构体，包括学生的部分信息：学号，姓名，年龄） 实验过程及步骤1. #include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define ElemType int #define MAXSIZE 100 /*此处的宏定义常量表示线性表可能达到的最大长度*/ typedef struct

{ ElemType elem[MAXSIZE]; /*线性表占用的数组空间*/ int last; /*记录线性表中最后一个元素在数组elem[ ]中的位置（下标值），空表置为-1*/ }SeqList; #include "common.h" #include "seqlist.h" void px(SeqList *A,int j); void main() { SeqList *l; int p,q,r; int i; l=(SeqList*)malloc(sizeof(SeqList)); printf("请输入线性表的长度:"); scanf("%d",&r); l->last = r-1; printf("请输入线性表的各元素值:\n"); for(i=0; i<=l->last; i++) { scanf("%d",&l->elem[i]); } px(l,i); printf("请输入要插入的值:\n");

数据结构实验报告

数据结构实验报告 一．题目要求 1）编程实现二叉排序树，包括生成、插入，删除； 2）对二叉排序树进行先根、中根、和后根非递归遍历； 3）每次对树的修改操作和遍历操作的显示结果都需要在屏幕上用树的形状表示出来。 4）分别用二叉排序树和数组去存储一个班(50人以上)的成员信息(至少包括学号、姓名、成绩3项),对比查找效率，并说明在什么情况下二叉排序树效率高,为什么? 二．解决方案 对于前三个题目要求，我们用一个程序实现代码如下 #include #include #include #include "Stack.h"//栈的头文件，没有用上 typedefintElemType; //数据类型 typedefint Status; //返回值类型 //定义二叉树结构 typedefstructBiTNode{ ElemType data; //数据域 structBiTNode *lChild, *rChild;//左右子树域 }BiTNode, *BiTree; intInsertBST(BiTree&T,int key){//插入二叉树函数 if(T==NULL) { T = (BiTree)malloc(sizeof(BiTNode)); T->data=key; T->lChild=T->rChild=NULL; return 1; } else if(keydata){ InsertBST(T->lChild,key); } else if(key>T->data){ InsertBST(T->rChild,key); } else return 0; } BiTreeCreateBST(int a[],int n){//创建二叉树函数 BiTreebst=NULL; inti=0; while(i

北京理工大学数据结构编程练习答案

1.一元多项式相加(10分) 成绩: 10 / 折扣: 0.8 题目说明： 编写一元多项式加法运算程序。要求用线性链表存储一元多项式（参照 课本）。该程序有以下几个功能： 1. 多项式求和 输入：输入三个多项式，建立三个多项式链表Pa、Pb、Pc （提示：调用CreatePolyn(polynomial &P,int m)。 输出：显示三个输入多项式Pa、Pb、Pc、和多项式Pa+Pb、多项式Pa+Pb+Pc （提示：调用AddPolyn(polynomial &Pa, polynomial Pb), 调用 PrintPolyn(polynomial P))。 0. 退出 输入： 根据所选功能的不同，输入格式要求如下所示（第一个数据是功能选择编号，参见测试 用例）： ? 1 多项式A包含的项数，以指数递增的顺序输入多项式A各项的系数（整数）、指数（整数） 多项式B包含的项数，以指数递增的顺序输入多项式B各项的系数（整数）、指数（整数） 多项式C包含的项数，以指数递增的顺序输入多项式C各项的系数（整数）、指数（整数） ?0 －－－操作终止，退出。 输出： 对应一组输入，输出一次操作的结果（参见测试用例）。 ? 1 多项式输出格式：以指数递增的顺序输出: <系数,指数>,<系数,指数>,<系数,指数>,参见测试用例。零多项式的输出格式为<0,0> ?0 无输出 1.

#include #include using std::cin; using std::cout; using std::endl; struct date { int a; int b; struct date* pnext; }; typedef struct date DATE; typedef struct date* PDATE; void output(PDATE p) { int f=0; p=p->pnext; while(p!=NULL) { if(p->a!=0) { f=1; cout<<"<"<a<<","<b<<">"; if(p->pnext==NULL) cout<pnext; } if(f==0) cout<<"<0,0>"<

数据结构实验报告(四)

《数据结构》实验报告 班级： 学号： 姓名：

实验四二叉树的基本操作实验环境：Visual C++ 实验目的： 1、掌握二叉树的二叉链式存储结构； 2、掌握二叉树的建立，遍历等操作。 实验内容： 通过完全前序序列创建一棵二叉树，完成如下功能： 1)输出二叉树的前序遍历序列； 2)输出二叉树的中序遍历序列； 3)输出二叉树的后序遍历序列； 4)统计二叉树的结点总数； 5)统计二叉树中叶子结点的个数； 实验提示： //二叉树的二叉链式存储表示 typedef char TElemType; typedef struct BiTNode{ TElemType data; struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;

一、程序源代码 #include #include #define MAXSIZE 30 typedef char ElemType; typedef struct TNode *BiTree; struct TNode { char data; BiTree lchild; BiTree rchild; }; int IsEmpty_BiTree(BiTree *T) { if(*T == NULL) return 1; else return 0;

} void Create_BiTree(BiTree *T){ char ch; ch = getchar(); //当输入的是"#"时，认为该子树为空 if(ch == '#') *T = NULL; //创建树结点 else{ *T = (BiTree)malloc(sizeof(struct TNode)); (*T)->data = ch; //生成树结点 //生成左子树 Create_BiTree(&(*T)->lchild); //生成右子树 Create_BiTree(&(*T)->rchild); } } void TraverseBiTree(BiTree T) { //先序遍历 if(T == NULL) return;

数据结构实验二11180

理工学院实验报告 系部计算机系班级学号 课程名称数据结构实验日期 实验名称链表的基本操作成绩 实验目的： （1）掌握线性表的链式存储结构的特点； （2）掌握线性表的基本操作：初始化、插入、删除、查找数据元素等运算在链式存储结构上的实现。 实验条件：计算机一台，vc++6.0 实验容与算法思想： 容： 建立一有序的链表，实现下列操作： 1.把元素x插入表中并保持链表的有序性； 2.查找值为x的元素，若找到将其删除； 3.输出表中各元素的值。 算法思想：先创建并初始化一个顺序表（void init_linklist(LinkList)），通过循环，输入一串数据void CreateFromTail(LinkList L);创建主函数；编写算法，完成子函数（查找locate，插入insList，删除DelList，输出output）模块；调用子函数，完成实验要求 运行结果：

附：源程序： #include #include #define OK 1 #define ERROR 0 typedef char ElemType; typedef struct Node { ElemType data; struct Node* next; }Node,*LinkList; void init_linklist(LinkList *l) { *l=(LinkList)malloc(sizeof(Node)); (*l)->next=NULL; } void CreateFromTail(LinkList L) { Node *r, *s; char c; int flag =1; r=L; while(flag) { c=getchar(); if(c!='$') {

数据结构实验一 实验报告

班级：：学号： 实验一线性表的基本操作 一、实验目的 1、掌握线性表的定义； 2、掌握线性表的基本操作，如建立、查找、插入和删除等。 二、实验容 定义一个包含学生信息（学号，，成绩）的顺序表和链表（二选一），使其具有如下功能： (1) 根据指定学生个数，逐个输入学生信息； (2) 逐个显示学生表中所有学生的相关信息； (3) 根据进行查找，返回此学生的学号和成绩； (4) 根据指定的位置可返回相应的学生信息（学号，，成绩）； (5) 给定一个学生信息，插入到表中指定的位置； (6) 删除指定位置的学生记录； (7) 统计表中学生个数。 三、实验环境 Visual C++ 四、程序分析与实验结果 #include #include #include #include #define OK 1 #define ERROR 0 #define OVERFLOW -2

typedef int Status; // 定义函数返回值类型 typedef struct { char num[10]; // 学号 char name[20]; // double grade; // 成绩 }student; typedef student ElemType; typedef struct LNode { ElemType data; // 数据域 struct LNode *next; //指针域 }LNode,*LinkList; Status InitList(LinkList &L) // 构造空链表L { L=(struct LNode*)malloc(sizeof(struct LNode)); L->next=NULL; return OK;

北理工889数据结构考纲

889数据结构 考试内容： 数据结构主要考查考生以下几个方面： 1.理解数据结构的基本概念；掌握数据的逻辑结构、存储结构及其差异，以及各种基本操作的实现。 2.掌握基本的数据处理原理和方法的基础上，能够对算法进行设计与分析。 3.能够选择合适的数据结构和方法进行问题求解。 应掌握的具体内容为： 一、线性表 （一）线性表的定义和基本操作 （二）线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 二、栈、队列和数组 （一）栈和队列的基本概念 （二）栈和队列的顺序存储结构 （三）栈和队列的链式存储结构 （四）栈和队列的应用 （五）特殊矩阵的压缩存储 三、树与二叉树 （一）树的概念 （二）二叉树 1.二叉树的定义及其主要特征 2.二叉树的顺序存储结构和链式存储结构 3.二叉树的遍历 4.线索二叉树的基本概念和构造 5.二叉排序树 6.平衡二叉树 （三）树、森林 1.书的存储结构 2.森林与二叉树的转换 3.树和森林的遍历 （四）树的应用 1.等价类问题 2.哈夫曼（Huffman）树和哈夫曼编码 四、图 （一）图的概念 （二）图的存储及基本操作 1.邻接矩阵法

2.邻接表法 （三）图的遍历 1.深度优先搜索 2.广度优先搜索 （四）图的基本应用及其复杂度分析 1.最小（代价）生成树 2.最短路径 3.拓扑排序 4.关键路径 五、查找 （一）查找的基本概念 （二）顺序查找法 （三）折半查找法 （四）B-树 （五）散列（Hash）表及其查找 （六）查找算法的分析及应用 六、内部排序 （一）排序的基本概念 （二）插入排序 1.直接插入排序 2.折半插入排序 （三）起泡排序（bubble sort） （四）简单选择排序 （五）希尔排序（shell sort） （六）快速排序 （七）堆排序 （八）二路归并排序（merge sort） （九）基数排序 （十）各种内部排序算法的比较 （十一）内部排序算法的应用 题型和分值 填空题20分、选择题30分、问答题70分、算法题30分 参考书目 数据结构（C语言版）严蔚敏吴伟民清华大学出版社

数据结构实验二

洛阳理工学院实验报告 系部计算机系班级学号姓名 课程名称数据结构实验日期 实验名称链表的基本操作成绩 实验目的： （1）掌握线性表的链式存储结构的特点； （2）掌握线性表的基本操作：初始化、插入、删除、查找数据元素等运算在链式存储结构上的实现。 实验条件：计算机一台，vc++6.0 实验内容与算法思想： 内容： 建立一有序的链表，实现下列操作： 1.把元素x插入表中并保持链表的有序性； 2.查找值为x的元素，若找到将其删除； 3.输出表中各元素的值。 算法思想：先创建并初始化一个顺序表（void init_linklist(LinkList)），通过循环，输入一串数据void CreateFromTail(LinkList L);创建主函数；编写算法，完成子函数（查找locate，插入insList，删除DelList，输出output）模块；调用子函数，完成实验要求 运行结果：

附：源程序： #include #include #define OK 1 #define ERROR 0 typedef char ElemType; typedef struct Node { ElemType data; struct Node* next; }Node,*LinkList; void init_linklist(LinkList *l) { *l=(LinkList)malloc(sizeof(Node)); (*l)->next=NULL; } void CreateFromTail(LinkList L) { Node *r, *s; char c; int flag =1; r=L; while(flag) { c=getchar(); if(c!='$') {

数据结构实验

长春大学计算机学院网络工程专业 数据结构实验报告 实验名称：实验二栈和队列的操作与应用 班级：网络14406 姓名：李奎学号：041440624 实验地点：日期： 一、实验目的： 1．熟练掌握栈和队列的特点。 2．掌握栈的定义和基本操作，熟练掌握顺序栈的操作及应用。 3．掌握链队的入队和出队等基本操作。 4．加深对栈结构和队列结构的理解，逐步培养解决实际问题的编程能力。 二、实验内容、要求和环境： 注：将完成的实验报告重命名为：班级+学号+姓名+（实验二），（如：041340538张三（实验二）），发邮件到：ccujsjzl@https://www.wendangku.net/doc/655319603.html,。提交时限：本次实验后24小时之内。 阅读程序，完成填空，并上机运行调试。 1、顺序栈，对于输入的任意一个非负十进制整数，打印输出与其等值的八进制数 (1)文件SqStackDef. h 中实现了栈的顺序存储表示 #define STACK_INIT_SIZE 10 /* 存储空间初始分配量*/ #define STACKINCREMENT 2 /* 存储空间分配增量*/ typedef struct SqStack { SElemType *base; /* 在栈构造之前和销毁之后，base 的值为NULL */ SElemType *top; /* 栈顶指针*/ int stacksize; /* 当前已分配的存储空间，以元素为单位*/ }SqStack; /* 顺序栈*/ (2)文件SqStackAlgo.h 中实现顺序栈的基本操作（存储结构由SqStackDef.h 定义） Status InitStack(SqStack &S) { /* 构造一个空栈S */ S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType)); if(!S.base) exit(OVERFLOW); /* 存储分配失败*/ S.top=S.base; S.stacksize=STACK_INIT_SIZE; return OK; } int StackLength(SqStack S) { // 返回S 的元素个数，即栈的长度, 编写此函数

北京理工大学2013级数据结构B试题(A卷)-答案

一、选择题 1、从逻辑结构上可以把数据结构分为【 C 】。 A、动态结构和静态结构 B、紧凑结构和非紧凑结构 C、线性结构和非线性结构 D、内部结构和外部结构 2、在一个长度为n的顺序存储的线性表中，向第i个元素（1≤i≤n+1）之前插入一个新元素时，需要从后向前依次后移【 B 】个元素。 A、n-i B、n-i+1 C、n-i-1 D、i 3、链表结构不具有下列【 B 】特点。 A、插入和删除无需移动元素 B、可随机访问链表中的任意元素 C、无需实现分配存储空间 D、所需空间与结点个数成正比。 4、在一个单链表中，已知q所指结点是p所指结点的前驱结点，若在q和p之间插入s结点，则执行【 C 】。 A、s->next = p->next; p->next = s; B、p->next = s->next; s->next = p; C、q->next = s; s->next = p; D、p->next = s; s->next = q; 5、一个栈的入栈序列是1，2，3，4，5，则栈不可能输出的序列是【C 】。 A、54321 B、45321 C、43512 D、12345 6、判断一个队列Q（元素最多为M个）为空的条件是【 C 】。 A、Q->rear – Q->front = M B、Q->rear – Q->front -1 ==M C、Q->rear == Q->front D、Q->rear + 1 == Q->front 7、在一个链队列中，假设f和r分别指向队首和队尾，则插入s所指结点的运算是【A 】。 A、r->next = s; r=s; B、f->next = s; f=s; C、s->next = r; r=s; D、s->next = f; f=s; 8、深度为5的二叉树至多有【 A 】个结点。 A、31 B、32 C、16 D、10 9、在一非空二叉树的中序遍历序列中，根结点的右边【A 】。

数据结构实验4_99XXX

《数据结构》实验报告 实验序号：4 实验项目名称：栈的操作

附源程序清单： 1. #include #define MaxSize 100 using namespace std; typedef char ElemType; typedef struct { ElemType data[MaxSize]; int top; }SqStack; void InitStack(SqStack *st) //初始化栈 { st->top=-1; } int StackEmpty(SqStack *st) //判断栈为空{ if(st->top == -1) return 0;//为空 else return -1;//不为空 } void Push(SqStack *st,ElemType x) //元素进栈{ if(st->top==MaxSize-1)

{ printf("栈上溢出!\n"); } else { st->top++; //移动栈顶位置 st->data[st->top]=x; //元素进栈 } } void Pop(SqStack *st,ElemType &e) //出栈 { if(st->top==-1) { printf("栈下溢出\n"); } else { e=st->data[st->top]; //元素出栈 st->top--; //移动栈顶位置} } int main() { SqStack L; SqStack *st=&L; ElemType c; int i; InitStack(st); printf("输入回车结束入栈"); while((c=getchar())!='\n') { if(c=='(') Push(st,c); if((i=StackEmpty(st))==-1) { if(c==')') Pop(st,c); } if(c==')' && (i=StackEmpty(st))==0) { printf("右括号多出,配对失败"); goto loop;

数据结构实验报告

姓名： 学号： 班级： 2010年12月15日

实验一线性表的应用 【实验目的】 1、熟练掌握线性表的基本操作在顺序存储和链式存储上的实现。、； 2、以线性表的各种操作（建立、插入、删除、遍历等）的实现为重点； 3、掌握线性表的动态分配顺序存储结构的定义和基本操作的实现； 4、通过本章实验帮助学生加深对C语言的使用（特别是函数的参数调用、指针类型的 应用和链表的建立等各种基本操作）。 【实验内容】 约瑟夫问题的实现：n只猴子要选猴王，所有的猴子按1,2，…，n编号围坐一圈，从第一号开始按1,2…，m报数，凡报到m号的猴子退出圈外，如此次循环报数，知道圈内剩下一只猴子时，这个猴子就是猴王。编写一个程序实现上述过程，n和m由键盘输入。【实验要求】 1、要求用顺序表和链表分别实现约瑟夫问题。 2、独立完成，严禁抄袭。 3、上的实验报告有如下部分组成： ①实验名称 ②实验目的 ③实验内容：问题描述：数据描述：算法描述：程序清单：测试数据 算法： #include #include typedef struct LPeople { int num; struct LPeople *next; }peo; void Joseph(int n,int m) //用循环链表实现 { int i,j; peo *p,*q,*head; head=p=q=(peo *)malloc(sizeof(peo)); p->num=0;p->next=head; for(i=1;inum=i;q->next=p;p->next=head; } q=p;p=p->next; i=0;j=1; while(i

北理工《实用数据结构与算法》在线作业

北理工《实用数据结构与算法》在线作业 一、单选题： 1.（单选题）当两个元素比较出现反序时就相互交换位置的排序方法称为()。 (满分 A归并排序 B选择排序 C交换排序 D插入排序 正确:C 2.（单选题）设数组Data[0..m]作为循环队列SQ的存储空间，front为队头指针，rear为队尾指针，则执行出队操作的语句为() (满分 Afront=front+1 Bfront=(front+1)%m Crear=(rear+1)%m Dfront=(front+1)%(m+1) 正确:D 3.（单选题）快速排序方法在()情况下最不利于发挥其长处。 (满分 A被排序的数据量太大 B被排序数据中含有多个相同值 C被排序数据已基本有序 D被排序数据数目为奇数 正确:C 4.（单选题）具有65个结点的完全二叉树其深度为（根的层次号为1）()。 (满分 A8 B7 C6 D5 正确: 5.（单选题）稀疏矩阵一般的压缩存储方法有两种，即()。 (满分 A二维数组和三维数组 B三元组表和散列表 C三元组表和十字链表 D散列表和十字链表 正确: 6.（单选题）从未排序序列中依次取出一个元素与已排序序列中的元素依次进行比较，然后将其放在已排序序列的合适位置，该排序方法称为()排序法。 (满分:) A插入 B选择 C交换 D二路归并 正确: 7.（单选题）下列排序方法中效率最高的排序方法是()。 (满分:) A起泡排序 B堆排序 C快速排序 D直接插入排序 正确: 8.（单选题）栈与一般的线性表的区别在于()。 (满分:) A数据元素的类型不同 B运算是否受限制 C数据元素的个数不同

数据结构(第4版)习题及实验参考答案数据结构复习资料完整版(c语言版)

数据结构基础及深入及考试 复习资料 习题及实验参考答案见附录 结论 1、数据的逻辑结构是指数据元素之间的逻辑关系。即从逻辑关系上描述数据，它与数据的存储无关，是独立于计算机的。 2、数据的物理结构亦称存储结构，是数据的逻辑结构在计算机存储器内的表示（或映像）。它依赖于计算机。存储结构可分为4大类：顺序、链式、索引、散列 3、抽象数据类型：由用户定义，用以表示应用问题的数据模型。它由基本的数据类型构成，并包括一组相关的服务（或称操作）。它与数据类型实质上是一个概念，但其特征是使用与实现分离，实行封装和信息隐蔽（独立于计算机）。 4、算法：是对特定问题求解步骤的一种描述，它是指令的有限序列，是一系列输入转换为输出的计算步骤。 5、在数据结构中，从逻辑上可以把数据结构分成（ C ） A、动态结构和表态结构 B、紧凑结构和非紧凑结构 C、线性结构和非线性结构 D、内部结构和外部结构 6、算法的时间复杂度取决于（ A ） A、问题的规模 B、待处理数据的初态 C、问题的规模和待处理数据的初态 线性表 1、线性表的存储结构包括顺序存储结构和链式存储结构两种。 2、表长为n的顺序存储的线性表，当在任何位置上插入或删除一个元素的概率相等时，插入一个元素所需移动元素的平均次数为（ E ），删除一个元素需要移动的元素的个数为（ A ）。 A、(n-1)/2 B、n C、n+1 D、n-1 E、n/2 F、(n+1)/2 G、(n-2)/2 3、“线性表的逻辑顺序与存储顺序总是一致的。”这个结论是（ B ） A、正确的 B、错误的 C、不一定，与具体的结构有关 4、线性表采用链式存储结构时，要求内存中可用存储单元的地址（ D ） A、必须是连续的 B、部分地址必须是连续的C一定是不连续的D连续或不连续都可以 5、带头结点的单链表为空的判定条件是（ B ） A、head==NULL B、head->next==NULL C、head->next=head D、head!=NULL 6、不带头结点的单链表head为空的判定条件是（ A ） A、head==NULL B、head->next==NULL C、head->next=head D、head!=NULL 7、非空的循环单链表head的尾结点P满足（ C ） A、p->next==NULL B、p==NULL C、p->next==head D、p==head 8、在一个具有n个结点的有序单链表中插入一个新结点并仍然有序的时间复杂度是（ B ） A、O(1) B、O(n) C、O(n2) D、O(nlog2n) 9、在一个单链表中，若删除p所指结点的后继结点，则执行（ A ）

数据结构实验二-

实 验 报 告 一、实验目的 1) 加深对图的表示法和图的基本操作的理解，并可初步使用及操作； 2) 掌握用图对实际问题进行抽象的方法，可以解决基本的问题； 3) 掌握利用邻接表求解非负权值、单源最短路径的方法，即利用Dijkstra 算法求最短 路径，同时掌握邻接表的建立以及使用方法，能够解决相关的问题； 4) 学会使用STL 中的map 抽象实际问题，掌握map ，List,，priority_queue 等的应 用。 二、实验内容与实验步骤 （1） 实验内容： 使用图这种抽象的数据结构存储模拟的欧洲铁路路线图，通过Dijkstra 算法求出欧洲旅行最少花费的路线。该实验应用Dijkstra 算法求得任意两个城市之间的最少路费，并给出路费最少的路径的长度和所经过的城市名。 （2） 抽象数据类型及设计函数描述 1) 抽象数据类型 class City ： 维护一个城市的信息，包括城市名name ，是否被访问过的标记visted ，从某个城市到达该城市所需的总费用total_fee 和总路径长度total_distance ，求得最短路径后路径中到达该城市的城市名from_city 。 class RailSystem ： 用邻接表模拟欧洲铁路系统，该邻接表使用数据结构map 实现，map 的key-value 课程名称：数据结构 班级： 实验成绩： 实验名称：欧洲旅行 学号： 批阅教师签字： 实验编号：实验二 姓名： 实验日期：2013 年6 月 18 日 指导教师： 组号： 实验时间：

值对的数据类型分别为string和list<*Service>，对应出发城市名和该城市与它能 够到达的城市之间的Service链表。 class Service： 为铁路系统模拟了两个城市之间的直接路线，包括两个城市之间直接到达的费用 fee，两城市之间的直接距离distance。 部分设计函数描述 ●RailSystem(const string& filename) 构造函数，调用load_services(string const &filename)函数读取数据 ●load_services(string const &filename) 读取传入的文件中的数据并建立上述两个map以模拟欧洲铁路路线图 ●reset(void) 遍历cities图，初始化所有城市的信息：visted未访问，total_distance最大 值，total_fee费用最大值，from_city为空 ●~RailSystem(void) 析构函数，用delete将两个map中所有使用new操作符开辟的空间删除 ●void output_cheapest_route(const string& from, const string& to, ostream& out); 输出两城市间的最少费用的路径，调用calc_route(string from, string to)函 数计算最少费用 ●calc_route(string from, string to) 使用Dijkstra算法计算from和to两个城市间的最少费用的路径 （3）采用的存储结构 1)map > outgoing_services 用来保存由一个城市出发可以直接到达的城市名及这两个城市之间的路径信息。 2)list 以service为指针的list表，保存两城市间的路径。 3)map cities 用来保存所有城市信息，通过城市名查找该城市有关信息。 4)priority_queue, Cheapest> candidates 存储候选的遍历城市，City*是优先队列存储的对象类型，vector是该对象的向量集合，Cheapest是比较规则。 三、实验环境 操作系统：Windows 8 调试软件：Microsoft visual studio 2012 上机地点：综合楼311 机器台号：笔记本