数据结构 广义表的建立与输出

合集下载

数据结构第5章 串和广义表

数据结构第5章 串和广义表

5.1 串的定义和基本运算
• (4)串的连接StrCat(S,T)。 • 初始条件:串S和T存在。 • 操作结果:将串T的值连接在串S的后面。 • (5)求子串SubString(Sub,S,pos,len)。 • 初始条件:串S存在,1≤pos≤StrLength(S)且
1≤len≤StrLength(S)-pos+1。 • 操作结果:用Sub返回串S的第pos个字符起长度为len的
1≤len≤StrLength(S)-pos+1。 • 操作结果:从串S中删除第pos个字符起长度为len的子串。 • (9)串的替换StrReplace(S,T,V)。 • 初始条件:串S,T和V存在,且T是非空串。 • 操作结果:用V替换串S中出现的所有与T相等的不重叠子
串。 • (10)判断串空StrEmpty(S)。 • 初始条件:串S存在。 • 操作结果:若串S为空串,则返回1;否则返回0。
• (1)非紧凑存储。设串S="Hello boy",计算机字长为32 位(4个Byte),用非紧凑格式一个地址只能存一个字符, 如图5-2所示。其优点是运算处理简单,但缺点是存储空 间十分浪费。
• (2)紧凑存储。同样存储S="Hello boy",用紧凑格式一 个地址能存四个字符,如图5-3所示。紧凑存储的优点是 空间利用率高,缺点是对串中字符处理的效率低。
•}
5.3 串的基本运算的实现
• (3)求子串操作。求串S从第pos位置开始,长度为len的 子串,并将其存入到串Sub中。操作成功返回1,不成功 返回0。其算法描述如下:
• int SubString(String *S,String *Sub,int pos,int len)

数据结构实验报告(C语言)(强力推荐)

数据结构实验报告(C语言)(强力推荐)

数据结构实验实验内容和目的:掌握几种基本的数据结构:集合、线性结构、树形结构等在求解实际问题中的应用,以及培养书写规范文档的技巧。

学习基本的查找和排序技术。

让我们在实际上机中具有编制相当规模的程序的能力。

养成一种良好的程序设计风格。

实验教材:数据结构题集(C语言版)清华大学出版社2007年实验项目:实验一、栈和循环队列㈠、实验内容:①栈掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等,栈的顺序存储结构和链式存储结构,以便在实际问题背景下灵活应用。

本程序采用的是链栈结构,具有初始化一个栈、PUSH、POP、显示所有栈里的元素四个功能。

②循环队列掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等,学会循环队列的实现,以便在实际问题背景下灵活运用。

本程序具有初始化一个队列、入队、出队、显示队列的所有元素、队列长度五个功能。

㈡、实验代码①栈程序代码:#include <stdio.h>#include <malloc.h>#define Stack_Size 6#define ERROR 0#define OK 1typedef int SElemType;typedef struct SNode{SElemType data;struct SNode *next;}SNode,*LinkStack;int CreatTwo(LinkStack &head,int n){int i;SNode *p;head=(LinkStack)malloc(sizeof(SNode));head->next=NULL;printf("请输入数据(数字):\n");for(i=n;i>0;--i){p=(SNode *)malloc(sizeof(SNode));scanf("%d",&p->data);p->next=head->next;head->next=p;}return 1;}int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}int Push(LinkStack &top,SElemType e){SNode *q;q=(LinkStack)malloc(sizeof(SNode));if(!q){printf("溢出!\n");return(ERROR);}q->data=e;q->next=top->next;top->next=q;return(OK);}int Pop(LinkStack &top,SElemType &e){SNode *q;if(!top->next){printf("error!\n");return(ERROR);}e=top->next->data;q=top->next;top->next=q->next;free(q);return(OK);}void main(){ int e;LinkStack top;printf("1.初始化一个栈;\n2.PUSH;\n3.POP;\n4.显示所有栈里的元素;\n5.结束;\n");while(1){switch(menu_select()){case 1:if(CreatTwo(top,Stack_Size))printf("Success!\n");break; case 2:printf("Push:\n");scanf("%d",&e);if(Push(top,e))printf("Success!\n");break;case 3:if(Pop(top,e))printf("Success!\n");printf("%d\n",e);break;case 4:LinkStack p;printf("所有栈里的元素:\n");p=top;while(p->next){p=p->next;printf("%7d",p->data);}printf("\n");break;case 5:return;}}}运行结果:②循环队列程序代码:#include<stdlib.h>#include<stdio.h>#define OVERFLOW -1#define OK 1#define ERROR 0#define MAXSIZE 100typedef struct{int *elem;//队列存储空间int front;int rear;}SqQueue;//判断选择是否正确int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}//参数(传出)SqQueue &Q,循环队列(空)int InitQueue(SqQueue &Q){Q.elem=(int *)malloc(MAXSIZE*sizeof(int));if(!Q.elem)exit(OVERFLOW);Q.front=Q.rear=-1;for(int i=0;i<MAXSIZE;i++)Q.elem[i]=-1;return OK;}//返回Q的元素个数int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;}//显示队列的元素void Display(SqQueue Q){for(int i=0;i<=QueueLength(Q);i++)if(Q.elem[i]!=-1)printf("%d ",Q.elem[i]);printf("\n");}//入队int EnQueue(SqQueue &Q,int e){Q.rear=(Q.rear+1)%MAXSIZE;if(Q.rear==Q.front)return ERROR;Q.elem[Q.rear]=e;return OK;}//出队int DeQueue(SqQueue &Q,int &e){if(Q.front==Q.rear)return ERROR;e=Q.elem[Q.front+1];Q.elem[Q.front+1]=-1;Q.front=(Q.front+1)%MAXSIZE;return OK;}void main(){SqQueue Q;InitQueue(Q);int elem,e;printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);printf("1.初始化一个队列;\n2.入队;\n3.出队;\n4.显示队列的所有元素;\n5.队列长度:\n6.结束;\n");while(1){switch(menu_select()){case 1:printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);fflush(stdin);break;case 2:scanf("%d",&elem);EnQueue(Q,elem);printf("队列为:\n");Display(Q);fflush(stdin);break;case 3:DeQueue(Q,elem);printf("队列为:\n");Display(Q);break;case 4:printf("\n队列的所有元素:\n");Display(Q);break;case 5:printf("%d\n",QueueLength(Q));break;case 6:return;}}}运行结果:实验二、数组㈠、实验内容:数组一般不做插入或删除操作,也就是说,一旦建立了数组,则结构中的数据元素个数和元素之间的关系就不再发生变动。

国家开放大学本科末考试数据结构历年试题与参考答案15秋至19秋精选全文完整版

国家开放大学本科末考试数据结构历年试题与参考答案15秋至19秋精选全文完整版

可编辑修改精选全文完整版国家开放大学(中央广播电视大学)2015年秋季学期“开放本科”期末考试数据结构(本)试题2016年1月一、单项选择题(每小题2分,共30分)1.对稀疏矩阵进行压缩存储,可采用三元组表,一个有10行的稀疏矩阵A共有97个零元素,其相应的三元组表共有3个元素。

该矩阵A有( )列。

A.8 C.7B.9 D.10答案:102.子串“acd”在主串“abdcacdefac”中的位置是( )。

A.3 C.7B.5 D.1答案:53.序列12,16,8,4按顺序依次进栈,按该栈的可能输出序列依次入队列,该队列的不可能输出序列是( )。

(进栈、出栈可以交替进行)。

A.16,12,8,4B.4,8,12,16C.8,4,16,12D.16,12,4,8答案:B.4,8,12,164.在一个不带头结点的链队中,假设f和r分别为队头和队尾指针,对该队列进行出队操作,并把结点的值保存在变量e中,其运算为( )。

A.e=f->data;r=r->nextB.e=f->data;r->next=rC.e=f->data;f=f->nextD.e=f一>data;f一>next=f答案:C.e=f->data;f=f->next5.数据的逻辑结构在计算机内存中的表示是( )。

A.给相关变量分配存储单元C.数据的逻辑结构B.数据的存储结构D.算法的具体体现答案:数据的存储结构6.以下说法正确的是( )。

A.线性表的链式存储结构必须占用连续的存储空间B.一种逻辑结构可以有不同的存储结构C.一种逻辑结构只能有唯一的存储结构D.线性表的顺序存储结构不必占用连续的存储空间答案:一种逻辑结构可以有不同的存储结构7.在一个单链表中要删除p所指结点的后继结点,可执行q=p一>next;和( )。

A.p一>next=q->nextB.p=q->nextC.p->next=qD.p->next=q答案:A.p一>next=q->next8.在数据结构和算法中,与所使用的计算机有关的是( )。

数据结构——用C语言描述(第3版)教学课件第5章 数组与广义表

数据结构——用C语言描述(第3版)教学课件第5章 数组与广义表
第5章 数组和广义表
5.1 数组的定义和运算 5.2 数组的顺序存储和实现 5.3 特殊矩阵的压缩存储
5.3.1 三角矩阵 5.3.2 带状矩阵 5.3.3 稀疏矩阵 5.4 广义表 5.5 总结与提高
5.1 数组的定义和运算
数组是一种数据类型。从逻辑结构上看,数组可以 看成是一般线性表的扩充。二维数组可以看成是线 性表的线性表。例如:
Am×n=
a12 a12 ┅
a1j
┅ a1n
a21 a22 ┅
a2j
┅ a2n
┇┇
ai1 ai2 ┅
aij
┇┇
┅ ain
am1 am2 ┅
amj
┅ amn
矩阵Am×n看成n个列向量的线性表,即j=(a1j,a2j, …,amj)
我们还可以将数组Am×n看成另外一个线性表: B=(1,,2,,… ,m),其中i(1≤i ≤m)本身也是一个线性表, 称为行向量,即: I= (ai1,ai2, …,aij ,…,ain)。
Loc[j1,j2,j3]=Loc[c1,c2,c3]+ α1*(j1-c1)+ α2*(j2-c2)+ α3(j3-c3)
=Loc[c1,c2,c3]+ Σαi*(ji-ci) (1≤i≤3)
由公式可知Loc[j1,j2,j3]与j1,j2,j3呈线性关系。 对于n维数组A(c1:d1,c2:d2,…,cn,dn),我们只要把上式推 广,就可以容易地得到n维数组中任意元素aj1j2…jn的存储 地址的计算公式。
疏矩阵。
0 12 9 0 0 0 0
0 0 3 0 0 15
0 0 0 00 0 0
12 0 0 0 18 0
M6×7= -3 0 0 0 0 14 0

数据结构第五章 数组与广义表

数据结构第五章 数组与广义表
an-1,n-1
压缩存储方法:只需要存储下三角 (含对角线)上的元素。可节省一 半空间。
可以使用一维数组Sa[n(n+1)/2]作为n阶对称矩阵A的存 储结构,且约定以行序为主序存储各个元素,则在Sa[k]和矩
阵元素aij之间存在一一对应关系: (下标变换公式)
i(i+1)/2 + j 当i≥j k = j(j+1)/2 + i 当i<j
q = cpot[col];
T.data[q].i = M.data[p].j; T.data[q].j = M.data[p].i; T.data[q].e = M.data[p].e; ++cpot[col]; }
分析算法FastTransposeSMatrix的时间 复杂度:
for (col=1; col<=M.nu; ++col) … … for (t=1; t<=M.tu; ++t) … … for (col=2; col<=M.nu; ++col) … … for (p=1; p<=M.tu; ++p) … …
//对当前行中每一个非零元

brow=M.data[p].j;

if (brow < N.nu ) t = N.rpos[brow+1];
M
else { t = N.tu+1 }

for (q=N.rpos[brow]; q< t; ++q) { ccol = N.data[q].j; // 乘积元素在Q中列号
一、三元组顺序表
对于稀疏矩阵,非零元可以用三元组表示, 整个稀疏矩阵可以表示为所有非零元的三元组所 构成的线性表。例如:

数据结构 5数组和广义表A

数据结构 5数组和广义表A
12
1 Status Locate(Array A,va_list ap,int &off) 2{ 3 //若ap指示的各下标值合法,则求出该元素在A中,相对地
址off
4 off=0; 5 for(i=0;i<A.dim;++i) 6 { 7 ind=va_arg(ap,int); 8 if(ind<0||ind>A.bounds[i]) return OVERFLOW; 9 off+=A.constants[i] *ind; 10 } 11 return OK; 12 }
行数 总列数,即 第2维长度 元素个数
ij
补充:计算二维数组元素地址的通式
设一般的二维数组是A[c1..d1, c2..d2],这里c1,c2不一定是0。
单个元素 长度
二维数组列优先存储的通式为: LOC(aij)=LOC(ac1,c2)+[(j-c2)*(d1-c1+1)+i-c1)]*L
6
例1〖软考题〗:一个二维数组A[1..6, 0..7],每个数组元素
16
5.4
1、定义:
广义表的定义
广义表是线性表的推广,也称为列表(lists) 记为: LS = ( a1 , a2 , ……, an ) 广义表名 表头(Head) 表尾 (Tail) n是表长
在广义表中约定:
① 第一个元素是表头,而其余元素组成的表称为表尾; ② 用小写字母表示原子类型,用大写字母表示列表。
13
1 Status Value(Array A,ElemType &e,…){ 2 //A是n维数组,e为元素变量,随后是n个下标值,若各下
标不超界,则e赋值为所指定的A的元素值,即将指定元素值 读到e变量中。

数据结构递归与广义表

数据结构递归与广义表

第5章递归与广义表一、复习要点本章主要讨论递归过程和广义表。

一个递归的定义可以用递归的过程计算,一个递归的数据结构可以用递归的过程实现它的各种操作,一个递归问题也可以用递归的过程求解。

因此,递归算法的设计是必须掌握的基本功。

递归算法的一般形式:void p ( 参数表) {if( 递归结束条件)可直接求解步骤;基本项else p( 较小的参数);归纳项}在设计递归算法时,可以先考虑在什么条件下可以直接求解。

如果可以直接求解,考虑求解的步骤,设计基本项;如果不能直接求解,考虑是否可以把问题规模缩小求解,设计归纳项,从而给出递归求解的算法。

必须通过多个递归过程的事例,理解递归。

但需要说明的是,递归过程在时间方面是低效的。

广义表是一种表,它的特点是允许表中套表。

因此,它不一定是线性结构。

它可以是复杂的非线性结构,甚至允许递归。

可以用多重链表定义广义表。

在讨论广义表时,特别注意递归在广义表操作实现中的应用。

本章复习的要点:1、基本知识点要求理解递归的概念:什么是递归?递归的定义、递归的数据结构、递归问题以及递归问题的递归求解方法。

理解递归过程的机制与利用递归工作栈实现递归的方法。

通过迷宫问题,理解递归解法,从而掌握利用栈如何实现递归问题的非递归解法。

在广义表方面,要求理解广义表的概念,广义表的几个性质,用图表示广义表的方法,广义表操作的使用,广义表存储结构的实现,广义表的访问算法,以及广义表的递归算法。

2、算法设计求解汉诺塔问题,掌握分治法的解题思路。

求解迷宫问题、八皇后问题,掌握回溯法的解题思路。

对比单链表的递归解法和非递归解法,掌握单向递归问题的迭代解法。

计算广义表结点个数,广义表深度,广义表长度的递归算法。

输出广义表各个原子所在深度的非递归算法。

判断两个广义表相等的递归算法。

广义表的按深度方向遍历和按层次(广度)方向遍历的递归算法。

使用栈的广义表的按深度方向遍历的非递归算法。

递归的广义表的删除算法二、难点与重点1、递归:递归的定义、递归的数据结构、递归问题用递归过程求解链表是递归的数据结构,可用递归过程求解有关链表的问题2、递归实现时栈的应用递归的分层(树形)表示:递归树递归深度(递归树的深度)与递归工作栈的关系单向递归与尾递归的迭代实现3、广义表:广义表定义、长度、深度、表头、表尾用图形表示广义表的存储结构广义表的递归算法,包括复制、求深度、求长度、删除等算法三、教材中习题的解析5-1 已知A[n]为整数数组,试写出实现下列运算的递归算法:(1) 求数组A中的最大整数。

数据结构广义表

数据结构广义表

结点结构是无论什么结点都有三个域:
第一个域是结点类型标志tag; 第二个域是指向一个列表的指针(当tag=1时) 或一个原子(当tag=0时); 第三个域是指向下一个结点的指针tp。
3 广义表的存储结构
形式描述为:
typedef enum{ ATOM, LIST }ElemTag typedef struct GLNode { //定义广义表结点 ElemTage tag; //公共部分,用以区分 原子结点和表结点 Unin{ //原子结点和表结点的联合部分 AtomType atom;//原子类型结点域, // AtomType由用户定义 struct GLNode *hp,; //表结点的表头指针域 }; struct GLNode *tp; //指向下一个结点的指针 }*Glist; //广义表类型
5. E=(a,E)
这是一个递归列表,其元素中有自己。
广义表也可以用图形表示,例如前述的广义表D和E可表示为:
广义表D
D
广义表E
E
C
A
B
a
e
a b c d
2 广义表的基本运算
广义表的基本运算 ⑴ 取表头 HEAD(LS); ⑵ 取表尾 TAIL(LS)。
3 广义表的存储结构
广义表中的数据元素可以是单元素,或是广义表, •很难用顺序存储结构表示,常采用链式存储结构。 1.表头表尾链存储结构 有两类结点:表结点和单元素结点。
P 1 3 1 1
A=y((c,3),(D,2)) C=x((1,10),(2,6))

1 2
A
z y 1 1 1 3
C
x 0 0 15 ^
B
1 2
1 2

广义表在数据结构中的位置

广义表在数据结构中的位置

2 线性表在概念上 可 以归到广义表 中 Байду номын сангаас
线 性 表 是最 常 用且 最 简单 的一 种 数据 结 构 , 简
收 稿 日期 :0 60 - . 20 -52 6
4 队列在概念 上可 以归到广义表 中
由 队列 的抽 象 数据 类 型 定 义可 知 , 队列 是一 种
作者简介 : 张复兴 ( 9 1) 男 , 15 - , 河南省孟州 市人 。副教授 , 主要研究方 向为离散数学 。
w a e a el an d C n e u n l he r b l y o mmig—u n p tme w ud b o s d u . a h n u l s h tt yh v e r e . o s q e t h y,t i i t f u a i s n pa de i o o l eb o t p Te c ig q ai wa e y t
Ab t a t D t rc r ot t h o eh o g u d t nfr r rm n , t h 8 l t e oe cu s f s r c : a s u t ei i r n e r tc n l yf n a o o a mi a te¥ e i ,ac r o reo a t u s mp a t y o o i op g g n m
可 以看 出 , 它正好 是广 义表
L S=( l仅 , , 仅 ,2… 仅 )
中各个元素全为单个元素的情况。 因此 , 线性表是广义表 的特例 。线性表在概念 上可 以归 到广 义表 中 。
1 广 义 表 的概 念
广义表是线性表 的推广 , 广义表是数据结构中
的一 种结 构形 式 。广义 表一般 记作 L S=( , 2 … , 其 中 ,S是 广 义 表 ( l l仅 , 仅 ) L 仅,

数据结构第五章

数据结构第五章

5.3.1 特殊矩阵
是指非零元素或零元素的分布有一定规律的矩阵。
1、对称矩阵 在一个n阶方阵A中,若元素满足下述性质: aij = aji 0≦i,j≦n-1 则称A为对称矩阵。
对称矩阵中的元素关于主对角线对称,故只 要存储矩阵中上三角或下三角中的元素,这样, 能节约近一半的存储空间。

2013-7-25 第4章 18
5.3 矩阵的压缩存储

在科学与工程计算问题中,矩阵是一种常用 的数学对象,在高级语言编制程序时,常将 一个矩阵描述为一个二维数组。 当矩阵中的非零元素呈某种规律分布或者矩 阵中出现大量的零元素的情况下,会占用许 多单元去存储重复的非零元素或零元素,这 对高阶矩阵会造成极大的浪费。 为了节省存储空间,我们可以对这类矩阵进 行压缩存储:
5.2 数组的顺序表示和实现 由于计算机的内存结构是一维的, 因此用一维内存来表示多维数组,就必 须按某种次序将数组元素排成一列序列 ,然后将这个线性序列存放在存储器中 。 又由于对数组一般不做插入和删除 操作,也就是说,数组一旦建立,结构 中的元素个数和元素间的关系就不再发 生变化。因此,一般都是采用顺序存储 的方法来表示数组。
即为多个相同的非零元素只分配一个存储空间; 对零元素不分配空间。


课堂讨论: 1. 什么是压缩存储? 若多个数据元素的值都相同,则只分配一个元素值的 存储空间,且零元素不占存储空间。 2. 所有二维数组(矩阵)都能压缩吗? 未必,要看矩阵是否具备以上压缩条件。 3. 什么样的矩阵具备以上压缩条件? 一些特殊矩阵,如:对称矩阵,对角矩阵,三角矩阵, 稀疏矩阵等。 4. 什么叫稀疏矩阵? 矩阵中非零元素的个数较少(一般小于5%)
通常有两种顺序存储方式:
⑴行优先顺序——将数组元素按行排列,第i+1个行 向量紧接在第i个行向量后面。以二维数组为例,按 行优先顺序存储的线性序列为: a11,a12,…,a1n,a21,a22,…a2n,……,am1,am2,…,amn 在PASCAL、C语言中,数组就是按行优先顺序存 储的。 ⑵列优先顺序——将数组元素按列向量排列,第j+1 个列向量紧接在第j个列向量之后,A的m*n个元素按 列优先顺序存储的线性序列为: a11,a21,…,am1,a12,a22,…am2,……,an1,an2,…,anm 在FORTRAN语言中,数组就是按列优先顺序存储的。

数据结构5.3_广义表的定义和存储结构

数据结构5.3_广义表的定义和存储结构

数据结构5.3_⼴义表的定义和存储结构⼴义表定义:⼴义表(Lists,⼜称列表)是⼀种⾮线性的数据结构,是线性表的⼀种推⼴。

即⼴义表中放松对表元素的原⼦限制,容许它们具有其⾃⾝结构。

⼀个⼴义表是n(n≥0)个元素的⼀个序列,若n=0时则称为空表。

GL=(a1,a2,…,ai,…,an)其中n表⽰⼴义表的长度,即⼴义表中所含元素的个数,n≥0。

如果ai是单个数据元素,则ai是⼴义表GL的原⼦;如果ai是⼀个⼴义表,则ai是⼴义表GL的⼦表。

习惯上⽤⼤写表⽰⼴义表的名称;⽤⼩写字母表⽰原⼦。

当⼴义表⾮空时,称第⼀个元素a1为GL的表头(Head),称其余元素组成的表(a2,a3,...an)是GL的表尾(Tail)。

可以发现上述⼴义表的定义描述时,⼜⽤到了⼴义表的概念;⼴义表的存储结构:⼴义表中的数据元素可以具有不同的结构(或是原⼦,或是列表)。

因此难以⽤顺序存储结构表⽰,通常采⽤链式存储结构。

每个数据元素可⽤⼀个结点表⽰。

如何设定结点的结构?由于列表中的数据元素可能为原⼦或列表。

因此需要两种结构的结点:⼀种是表结点⽤于表⽰列表,⼀种是原⼦结点⽤于表⽰原⼦;若列表不空,则可以分解成表头和表尾;⼀个表结点可以由3个域组成:标志域(标识是表还是原⼦)、指⽰表头的指针域、指⽰表尾的指针域;对于原⼦结点只需要2个域:标志域、值域;--------⼴义表的头尾链表存储表⽰--------typedef enum {ATOM, LIST} ElemTag; //ATOM==0 原⼦; LIST==1 ⼦表typedef struct GLNode{ ElemTag tag; //公共部分,⽤于区分原⼦结点和表结点 union{ //原⼦结点和表结点的联合部分 AtomType atom; //atom是原⼦结点的值域, struct{ struct GLNode *hp *tp}ptr; //ptr是表结点的指针域,ptr.hp和ptr.tp分别指向表头和表尾 };} *GList; //⼴义表类型--------⼴义表的扩展线性链表存储表⽰--------typedef enum {ATOM, LIST}ElemTag;typedef struct GLNode{ ElemTag tag; union{ AtomType atom; struct GLNode *hp; } struct GLNode *tp;} *GList;相关链接:。

第5章广义表

第5章广义表

数据结构

else h=NULL; ch=*(*s); (*s)++; if(h!=NULL) if(ch==',') h->link =creat_GL(s); else h->link=NULL; return(h); }
该算法的时间复杂度为O(n)。
数据结构

2.输出广义表prn_GL(p) 对于广义表的表头结点p,若为表结点,输出空表或递归 输出子表的内容,否则,输出元素值;若当前的结点还有 后续结点,则递归输出后续表的内容。 下面的函数把按链接存储的广义表以字符串形式输出。 void prn_GL(NODE *p) { if(p!=NULL) { if(p->tag==1) { printf("("); if(p->dd.sublist ==NULL) printf(" "); 数据结构
5.取表尾运算tail .取表尾运算 若广义表LS=(a1 ,a2 ,…,an),则tail(LS)=(a2 ,a3 ,…, an)。 即取表尾运算得到的结果是除表头以外的所有元素,取 表尾运算得到的结果一定是一个子表。 值得注意的是广义表( )和(())是不同的,前者为空表,长 度为0,后者的长度为1,可得到表头、表尾均为空表, 即head((( )))=( ),tail((( )))=( )。 数据结构
四、几个运算的调用
下列主函数的功能是:创建带表头结点链式存储的广义表 然后复制一个新的广义表,并把广义表按字符串的方式 输出. main() { NODE *hd,*hc; char s[100],*p; p=gets(s); hd=creat_GL(&p); hc=copy_GL(hd); printf("copy after:"); prn_GL(hc); }

数据结构实验报告_9

数据结构实验报告_9

本科生实验报告(二)姓名:学院:专业:班级:实验课程名称: 数据结构实验日期: 2013年 5月 25 日指导教师及职称:实验成绩:开课时间:2012~2013 学年第二学期k++;a[j][n-i-1]=k;}for (j=n-i-2;j>=i;j--){k++;a[n-i-1][j]=k;}for (j=n-i-2;j>=i+1;j--){k++;[j][i]=k;}}}void main(){int n,i,j;int a[MaxLen][MaxLen];printf("输入n(n<10):");scanf("%d",&n);fun(a,n);printf("%d阶数字方阵如下:\n",n);for (i=0;i<n;i++){for (j=0;j<n;j++)printf("%4d",a[i][j]);printf("\n");}}运行结果:6.2:如果矩阵A中存在这样的一个元素A[i][j]满足条件:A[i][j]是第i行中值最小的元素,且又是第j列中值最大的元素,则称为该矩阵的一个马鞍点。

设计一个程序exp6-2.cpp 计算出m*n的矩阵A的所有马鞍点。

主程序如下:6.3:已知A和B为两个n*n阶的对称矩阵,输入时,对称矩阵只输入下三角形元素,存入一维数组,如图6.5所示(对称矩阵M存储在一维数组A中),设计一个程序exp6-3.cpp 实习如下功能:(1)求对称矩阵A和B的和。

(2)求对称矩阵A和B的乘积。

A:图6.5 对称矩阵的存储转换形式主程序如下:#include <stdio.h>#define N 4#define M 10int value(int a[],int i,int j){if (i>=j)return a[(i*(i-1))/2+j];elsereturn a[(j*(j-1))/2+i];}void madd(int a[],int b[],int c[][N]){int i,j;for (i=0;i<N;i++)printf("a+b:\n");disp2(c1);printf("a×b:\n");disp2(c2);printf("\n");}运行结果:6.4::假设n*n的稀疏矩阵A采用三元组表示,设计一个程序exp6-4.cpp实现如下功能:(1)生成如下两个稀疏矩阵矩阵的三元组a和b:(2)输出a转置矩阵的三元组;(3)输出a+b的三元组;(4)输出a*b的三元组。

数据结构 广义表的创建和遍历

数据结构 广义表的创建和遍历

广义表的创建和遍历实验题目:广义表的创建和遍历实验内容:利用链式结构存储广义表,并对创建的广义表进行遍历1 需求分析1)实验要求实现广义表的创建和遍历,利用链式结构存储元素。

利用字符串表示广义表的结构,作为输入。

程序读入字符串后,根据算法存储为广义表,然后对创建的广义表进行遍历,并注意输出表中元素。

2)程序执行的命令包括:输入广义表创建广义表遍历广义表输出3)测试及结果2 设计概要根据问题分析,程序中主要包括四个主要函数:主函数、初始化头结点、建立广义表和遍历广义表。

初始化头结点的方法与链表的初始化类似,就不再详细叙述;建立广义表主要是根据从字符串中读取的元素进行不同的操作以建立广义表;遍历则与建立相反,即根据广义表逐个访问表中元素,并通过元素所在节点的相关信息得出广义表的形式。

图 1 程序整体流程下面将详细叙述:创建广义表○1将表示广义表的字符串读入字符串数组table[SIZE]中。

○2建立创建函数,输入为字符串数组和广义表头结点指针,返回值为头结点指针。

○3建立存储结点地址的栈○4逐个输出字符串数组table[SIZE]元素○5当输出为左括号时,将当前结点标记赋为1,当前指针入栈;申请新结点,将子表指针指向新结点,然后将当前指针指向新结点地址;当输出为右括号时,当前指针指向出栈的指针;当输出为逗号时,申请新结点,将当前结点链接指针指向新结点,然后将新结点地址赋给当前指针;当输出为字符,即广义表元素时,将当前结点标记赋为0,并将字符输入当前结点○6循环过程○5,以字符串的结束作为循环的结束图 2 广义表创建函数流程遍历广义表建立遍历函数,输入为广义表头结点,返回值为空;建立存储结点地址的栈。

由于广义表结构较为复杂,在遍历时需要使用循环嵌套:第一层循环以存储结点地址的栈为空为结束标志,其中嵌套了遍历循环和连续退栈循环。

具体算法如下表:图示流程如下:图 3 广义表遍历函数流程3 详细设计●结点定义typedef struct table{int tag;char element;struct table *aPtr;struct table *nextPtr;}Table,* GerTable;●主函数void main(){char table[SIZE];head=InitiateTable(head);printf("Please put the geralized table in:\n");gets(table);head=Create(table,head);Display(head);}●创建广义表函数GerTable Create(char table[],GerTable head){int i=0;GerTable newPtr,cPtr;int top=-1;GerTable stack[SIZE];cPtr=head;while(table[i]!='\0'){if(table[i]=='('){newPtr=InitiateTable(newPtr);cPtr->tag=1;stack[++top]=cPtr;cPtr->aPtr=newPtr;cPtr=newPtr;if(table[i+1]==')'){newPtr->tag=0;newPtr->element=' ';}}else if(table[i]==')'){cPtr=stack[top--];}else if(table[i]==','){newPtr=InitiateTable(newPtr);cPtr->nextPtr=newPtr;cPtr=newPtr;}else{cPtr->tag=0;cPtr->element=table[i];}i++;}return head;}遍历及输出广义表函数void Display(GerTable head){int top=-1;GerTable stack[SIZE];GerTable cPtr;printf("The Gegernalized List:\n");cPtr=head;do{while(cPtr->nextPtr!=NULL||cPtr->aPtr!=NULL){if(cPtr->tag==0){printf("%c",cPtr->element);printf(",");cPtr=cPtr->nextPtr;}if(cPtr->tag==1){printf("(");stack[++top]=cPtr;cPtr=cPtr->aPtr;}}printf("%c",cPtr->element);printf(")");cPtr=stack[top--];if(cPtr->nextPtr==NULL){while(cPtr->nextPtr==NULL&&top!=-1){cPtr=stack[top--];printf(")");}}if(cPtr->nextPtr!=NULL){cPtr=cPtr->nextPtr;printf(",");}}while(top!=-1);}4 程序使用说明及测试结果1.说明进入程序后显示提示信息:Please put the generalized table in:输入广义表后可得到输出。

大学数据结构课件--第5章 数组和广义表

大学数据结构课件--第5章 数组和广义表

a 32 a 33 a 34 0 0
a 43 a 44 a 45 0
a 54 a 55 a 56 a 65 a 66
5.3.2 稀疏矩阵
稀疏矩阵的存储:如何表示非零元素的位置信息 1. 三元组表:每个元素用一个三元组(i,j,v)来表示。 i j v
0 1 6 1 1 6 2 3 8 12 9
2
3 4 5 6 7 8
2
5.2 数组的顺序表示和实现
a00 a00 a10 a01 存储单元是一维结构,而数组是个多维结构 , …… …… 则用一组连续存储单元存放数组的数据元素就有 am-1,0 a0,n-1 个次序约定问题。 a01 a10
a11
……
a11
……
二维数组可有两种存储方式: am-1,1 a1,n-1
……
K=
i*n-i(i-1)/2+j-i n(n+1)/2
当 i≤j 当i>j
0 a11 ... a1n-1 ... ... ... ... 0 0 0 an-1n-1
当i ≤ j时,a[i][j]是非零元素, a[i][j]前面有i行,共有n+(n-1)+(n-2)+…(n-(i-1))
=i(n+[n-(i-1)])/2=i*n-i(i-1)/2个元素,a[i][j]前面有j列,共j-i个非零元素,
A m× n
( a10 a11 … a1,n-1 )
=
注:
( … … …… ) ( am-1,0 am-1,2 … am-1,n-1 ) ( ( ( (
① 数组中的元素都具有统一的类型; ② 数组元素的下标一般都具有固定的上界和下界,即数组一旦 被定义,它的维数和维界就不再发生改变; ③ 数组的基本操作简单:初始化、销毁、存取元素和修改元素值

数据结构_广义表的运算

数据结构_广义表的运算

数据结构_广义表的运算数据结构——广义表的运算在计算机科学的数据结构领域中,广义表是一种较为复杂但又十分有趣和实用的数据结构。

它就像是一个“大容器”,可以容纳各种各样的数据元素,包括其他的广义表。

广义表的定义相对灵活,它可以是空表,也可以是由单个元素或者多个元素组成的表。

这些元素可以是原子,比如整数、字符等不可再分的数据;也可以是子表,也就是另一个广义表。

那么,广义表有哪些常见的运算呢?首先就是表头和表尾的获取。

表头指的是广义表中的第一个元素,如果这个元素本身是一个子表,那么这个子表整体就是表头。

而表尾则是除了表头之外的其余部分。

比如说,对于广义表`(a, (b, c), d)`,其表头是`a` ,表尾是`((b, c), d)`。

接下来是广义表的长度和深度的计算。

长度指的是广义表中元素的个数,需要注意的是,子表算一个元素。

比如`(a, (b, c), d)`的长度是3 。

而深度则是指广义表中括号嵌套的层数,空表的深度为1 。

对于`(a, (b, (c)))`,其深度为 3 。

广义表的创建也是一项重要的运算。

我们可以通过逐个输入元素的方式来创建广义表。

在创建过程中,需要明确每个元素是原子还是子表,以正确构建广义表的结构。

广义表的复制运算也必不可少。

这就像是给一个广义表做了一个“克隆”,得到一个完全相同的副本。

在复制过程中,需要注意对原子和子表的分别处理,确保复制的准确性。

插入和删除操作在广义表中同样有着重要的应用。

比如,我们可以在广义表的指定位置插入一个新的元素或者子表,也可以删除指定位置的元素或者子表。

合并广义表则是将两个或多个广义表组合成一个新的广义表。

在合并过程中,需要考虑元素的顺序和结构,以保证合并后的广义表符合预期。

遍历广义表是对广义表中所有元素进行访问的操作。

常见的遍历方式有深度优先遍历和广度优先遍历。

深度优先遍历就像是在探索一个迷宫,沿着一条路径一直走到底,然后再回溯;而广度优先遍历则是先访问同一层的元素,再依次访问下一层。

数据结构数组和广义表

数据结构数组和广义表

数据结构05数组与广义表数组与广义表可以看做是线性表地扩展,即数组与广义表地数据元素本身也是一种数据结构。

5.1 数组地基本概念5.2 数组地存储结构5.3 矩阵地压缩存储5.4 广义表地基本概念数组是由相同类型地一组数据元素组成地一个有限序列。

其数据元素通常也称为数组元素。

数组地每个数据元素都有一个序号,称为下标。

可以通过数组下标访问数据元素。

数据元素受n(n≥1)个线性关系地约束,每个数据元素在n个线性关系地序号 i1,i2,…,in称为该数据元素地下标,并称该数组为n维数组。

如下图是一个m行,n列地二维数组A矩阵任何一个元素都有两个下标,一个为行号,另一个为列号。

如aij表示第i行j列地数据元素。

数组也是一种线性数据结构,它可以看成是线性表地一种扩充。

一维数组可以看作是一个线性表,二维数组可以看作数据元素是一维数组(或线性表)地线性表,其一行或一列就是一个一维数组地数据元素。

如上例地二维数组既可表示成一个行向量地线性表: A1=(a11,a12,···,a1n)A2=(a21,a22, ···,a2n)A=(A1,A2, ···,Am) ············Am=(am1,am2, ···,amn)也可表示成一个列向量地线性表:B1=(a11,a21,···,am1)B2=(a12,a22, ···,am2)A=(B1,B2, ···,Bm) ············Bn=(a1n,a2n, ···,amn)数组地每个数据元素都与一组唯一地下标值对应。

数据结构第五章 数组和广义表

数据结构第五章 数组和广义表

5.3.1
特殊矩阵
1、对称矩阵 在一个n阶方阵A中,若元素满足下述性质: aij = aji 1≤i,j≤n 则称A为对称矩阵。 a11 1 5 1 3 7 a21 a 22 5 0 8 0 0 a31 a32 a33 1 8 9 2 6 ……………….. 3 0 2 5 1 an 1 a n 2 a n 3 …a n n 7 0 6 1 3
第5章
数组和广义表
5.1 数组的定义
5.2 数组的顺序表示和实现
5.3 矩阵的压缩存储
5.3.1 特殊矩阵
5.3.2 稀疏矩阵
5.4 广义表的定义
5.1 数组的定义
数组-----线性表的扩展 A =(a0,a1,a2,…,an-1)
a00 a10 ┇ Am×n= ai0 ┇ am-1,0 a01 … a0j … a11 … a1j … ┇ ai2 … aij … ┇ am-1,2 … am-1,j … a0,n-1 a1,n-1 ai,n-1 am-1,n-1 α0 α1 ┇ Am×n= α i ┇ α m-1
Assign( &A, e, index1, ..., indexn) 赋值操作 初始条件:A是n维数组,e为元素变量,随后是n个下标值。 操作结果:若下标不超界,则将e的值赋给所指定的A的元 素,并返回OK。 对于数组来说一旦维数确定了,每个元素的下标确定了, 那么整个数组就确定了,这样的一个数组结构除了能改变 某元素的值,其他的不能再改变。
5.2 数组的顺序表示和实现
数组类型特点: 1) 只有引用型操作,没有加工型操作; 2) 数组是多维的结构,而存储空间是一个一维的结构。 有两种顺序映象的方式。
有两种顺序映像方法: 1)以行序为主序(行优先,先行后列):先存储行号较小 的元素,行号相同者先存储列号较小的元素;

数据结构讲义第5章-数组和广义表

数据结构讲义第5章-数组和广义表
对于一个矩阵结构,显然用一个二维数组来表示是非常 恰当的.但有时会遇到这样一类矩阵:在这种矩阵中有 许多值相同的元素或者是零元素,为了节省存储空间, 可以对这类矩阵进行压缩存储. 压缩存储是:为多个值相同的元素只分配一个存储空间: 对零元素不分配存储空间. 特殊矩阵:值相同的元素或者零元素在矩阵中的分布有 一定规律,则称此类矩阵为特殊矩阵,反之,称为稀疏 矩阵.
5.4 广义表
5)若广义表不空,则可分成表头和表尾,反之,一对表头和表尾 可唯一确定广义表 对非空广义表:称第一个元素为L的表头,其余元素组成的表称 为LS的表尾; B = (a,(b,c,d)) 表头:a 表尾 ((b,c,d)) 即 HEAD(B)=a, C = (e) D = (A,B,C,f ) 表头:e 表尾 ( ) TAIL(B)=((b,c,d)),
5.4 广义表
4)下面是一些广义表的例子; A = ( ) 空表,表长为0; B = (a,(b,c,d)) B的表长为2,两个元素分别为 a 和子表(b,c,d); C = (e) C中只有一个元素e,表长为1; D = (A,B,C,f ) D 的表长为4,它的前三个元素 A B C 广义表, 4 A,B,C , 第四个是单元素; E=( a ,E ) 递归表.
以二维数组为例:二维数组中的每个元素都受两个线性关 系的约束即行关系和列关系,在每个关系中,每个元素aij 都有且仅有一个直接前趋,都有且仅有一个直接后继. 在行关系中 aij直接前趋是 aij直接后继是 在列关系中 aij直接前趋是 aij直接后继是
a00 a01 a10 a11
a0 n-1 a1 n-1
a11 a21 ┇ a12 a22 ┇ ai2 ┇ … amj … amn … aij … ain … … a1j a2j … … a1n a2n β1 β2 ┇ βi ┇ βm

数据结构广义表ppt课件

数据结构广义表ppt课件

} else printf("%c", g->val.data); /*为原子时输出元素值*/
if (g->tag==1) printf(")"); /*为表结点时输出')'*/
if (g->link!=NULL)
{ printf(","); DispGL(g->link);
/*递归输出后续表的内容*/
/*遇到')'字符,子表为空*/
/*新结点作为原子结点*/
/*串结束,子表为空*/ /*取下一个扫描字符*/ /*串未结束判断*/ /*当前字符为','*/ /*递归构造后续子表*/ /*串结束*/ /*处理表的最后一个元素*/ /*返回广义表指针*/
17
4. 输出广义表 以h作为带表头附加结点的广义表的表头指针,打印输
if (ch!='\0')
/*串未结束判断*/
{ h=(GLNode *)malloc(sizeof(GLNode));/*创建新结点*/
if (ch=='(')
/*当前字符为左括号时*/
{ h->tag=1;
/*新结点作为表头结点*/
h->val.sublist=CreatGL(s); /*递归构造子表并链到表头结点*/
{ int max=0,dep; if (g->tag==0) return 0; g=g->val.sublist; if (g==NULL) return 1; while (g!=NULL) { if (g->tag==1) { dep=GLDepth(g);
/*为原子时返回0*/ /*g指向第一个元素*/ /*为空表时返回1*/ /*遍历表中的每一个元素*/ /*元素为子表的情况*/ /*递归调用求出子表的深度*/
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
③更多的问题出现在了输出广义表的函数中,刚开始出现广义表的输出少括号或多括号的情况,这里有一部分原因是建立广义表的函数的问题,两部分同时作的修改。之后又出现输入复杂的广义表时,部分字母不能输出,多重括号的输出也只能输出两个,认真分析后,发现还是对广义表中右括号的处理不够完善,于是在输出时,进一步细化了输出结果的条件,比如对“(a,b)”和“()”这两种形式采取不同的输出条件和输出结果。在不断地查找问题和完善中,最终修改正确。
{
if(s[j]=='(')//若字符为'(',执行以下操作
{
p->tag=1;//当前结点的标记域赋值为1,表示存在子表
K.top++;//当前结点的指针进栈
K.pin[K.top]=p;
q=(GLNode *)malloc(sizeof(GLNode));//申请新结点
q->tag=0;//初始化新结点,标记域赋值为0,data域赋空字符
1、程序使用说明:
(1)本程序运行环境为Visual C++ 6.0;
(2)根据界面提示进行操作,注意输入的字符为西文字符
2、测试结果与分析:
页面提示“输入广义表:”
输入“((),a,b,((c,(d,()))),((())))”,按回车确定,页面显示如下:
“输出结果为:((),a,b,((c,(d,()))),((())))
q->data=NULL;
p->sublist=q;//当前结点的sublist域指向新申请的结点
p=q;//令新申请的结点成为当前结点
}
else
{
if(s[j]==',')//若字符为',',执行以下操作
{
q=(GLNode *)malloc(sizeof(GLNode));//申请新结点
q->tag=0;//初始化新结点,标记域赋值为0,data域赋空字符
每个结点的形式如下图所示。
tag为标记域:若tag=0,表示该结点的sublist域不为空,若tag=1,表示该结点为表结点,则sublist域中存放相应子表第一个元素对应结点的地址;
data域:存放广义表中的字母;
sublist域:存放相应子表第一个元素对应结点的地址;
next域:存放与本元素同一层的下一个元素所在结点的地址,当本元素是所在层的最后一个元素时,next域为空。
申请新结点并令其标记域为0,data域为空字符
当前结点p的sublist域指向新结点q
将新结点指针赋给当前结点p
}
◎若字符为',',执行以下操作
{
申请新结点并令其标记域为0,data域为空字符
当前结点p的next域指向新结点q
将新结点指针赋给当前结点p
}
◎若字符为')',执行以下操作
{
令当前结点p的next域为空
本次实验,我很感谢老师和同学对我的指点。通过本次实验,对广义表的存储结构有了更深的认识,对一些细节更加理解,收获了很多。
教师评语:
首先,我强调一下要注意细节,不论是对你而言简单的部分还是复杂的部分,这些都会影响你程序的编译和调试,另外,在充分考虑并设计好程序后在进行编写操作这是一个良好的习惯,这样能够提高你的编程效率,降低出错的可能性,当然,最好的话细分模块是一个比较好的习惯,当然这主要是针对大型程序而言。
3、广义表的输出
在广义表的输出过程中也需利用一个存储结点指针的栈辅助完成,初始时栈为空,广义表输出结束后栈也为空,所以在开始时将头结点入栈,之后根据当前指针所指结点的特性的不同执行不同的操作,以栈空作为广义表输出的结束条件。广义表输出的具体过程见详细设计部分。
4、本程序的基本操作和模块:
建立广义表的函数:Create(GLNode *G,SeqStack &K,char s[])
③将当前结点p的sublist域所指结点赋给p。
④当栈不空时执行以下操作
while(K.top!=-1)
{
◎若当前结点指针p不为空,执行以下操作
{
若当前结点标记域为1,执行以下操作
{
输出'(',并当前结点指针p入栈
将当前结点p的sublist域所指结点赋给p
}
若当前结点标记域为0,执行以下操作
{
若当前结点p的date域存有字母则输出该字母
{
GLNode *pin[20];//指针数组,用于存储广义表结点指针
int top;//栈顶指针
}SeqStack;
//——————————————————————————————————————————
void Create(GLNode *G,SeqStack &K,char s[])//建立广义表函数
由上测试结果分析得,该程序功能满足题目要求。
3、调试过程中遇到的问题及解决方法
①当代码编写完成后,编译过程出现了很多小错误,比如语句末尾漏掉分号,使用了某些变量却未定义,但这些问题很快发现并及时纠正;
②在建立广义表的函数中,建立结点后对其data域赋值不完整,一些特殊结点指针域的说明也不完整,导致输出结果有问题。于是回头进一步梳理思路,是细节部分更加严谨,最后修改正确;
若当前结点p的next域不为空,表示不是该层的结束,输出','
将当前结点p的next域所指结点赋给p
}
}
◎若当前结点指针为空,执行以下操作
{
输出')'
出栈,将栈顶元素赋给当前结点p,
若当前结点p的next域不为空,表示不是该层的结束,输出','
将当前结点p的next域所指结点赋给p
}
}
}
四 使用说明、测试分析及结果
char data;//data用于存储广义表中的字母
struct LNode *sublist,*next;//sublist为指向该结点下一层的指针,next为指向该结点同一层的指针
}GLNode;
//——————————————————————————————————————————
typedef struct//顺序栈的类型描述
K.top--;
}
else//若字符为字母,执行以下操作
{
p->data=s[j];//令当前结点的data域为该字母
p->sublist=NULL;//当前结点的sublist域为空
}
}
}
}
}
//——————————————————————————————————————————
void Display(GLNode *G,SeqStack &K)//输出广义表的函数
输出结果为:((),a,b,((c,(d,()))),((())))
是否继续?(是,输入1;否,输入0):1
输入广义表:
广义表未建立
是否继续?(是,输入1;否,输入0):0
Press any key to continue
二 概要设计
1、广义表是一种递归的数据结构,因此很难为每个广义表分配固定大小的存储空间,所以其存储结构采用动态链式结构。
实验成绩:99
指导教师签名:
批阅日期:2013.11.4
代码:
# include<stdio.h>
# include<stdlib.h>
//——————————————————————————————————————————
typedef struct LNode//广义表结点的类型描述
{
int tag;//tag为结点中的标记域
一、需求分析
1、输入的形式和输入值的范围:根据提示,输入广义表,按回车结束。
2、输出的形式:输出结果为上一步所输入的广义表。
3、程序所能达到的功能:输入广义表后,该程序可以建立广义表的链式存储结构,之后按照一定的顺序访问结点并输出相应的值,从而完成广义表的输出。
4、测试数据:
输入广义表:((),a,b,((c,(d,()))),((())))
{
GLNode *p,*q;//p指针指向当前结点,q指针指向新申请的结点
int j;//j用于标记输入的字符在数组中的位置
printf("输入广义表:");//提示输入广义表的
gets(s);
p=G;//令p指向头结点
p->next=NULL;//头结点的next域为空
for(j=0;s[j]!='\0';j++)//进入循环,建立广义表
q->data=NULL;
p->next=q;//当前结点的next域指向新申请的结点
p=q;//令新申请的结点成为当前结点
39;)')//若字符为')',执行以下操作
{
p->next=NULL;//令当前结点的next域为空
p=K.pin[K.top];//出栈,令当前结点为栈顶元素
输出广义表的函数:Display(GLNode *G,SeqStack &K)
主函数:main( )
函数的调用关系如下图所示:
三 详细设计
(一)元素类型、结点类型
1、广义表结点的类型描述
typedef struct LNode
{
int tag;//tag为结点中的标记域
char data;//data用于存储广义表中的字母
4、运行界面
五、实验总结
因为本次实验花费了很多时间思考算法,所以在编写程序上花费的时间不算太多,我在10月26日晚上写完代码,并于当天修改正确。
相关文档
最新文档