C++实现类的链表队列
//头文件：Queue.h
//-------------------------------------------------
#pragmaonce
//-------------------------------------------------
#include
usingnamespace std;
//-------------------------------------------------
typedefint dataType;
//------------------------
struct Node
{
dataType data;
Node * next;
};
//-------------------------------------------------
class Queue
{
public:
Queue(void);
~Queue(void);
void push(dataType );//入队
void pop();//出队
dataType front(); //获取头元素
bool IsEmpty(); // 是否为空
private:
Node * head ;//头指针
Node * tail;//尾指针
};
//-------------------------------------------------
// end for header file
// .cpp 文件, 文件名Queue.cpp
//-------------------------------------------------
#include"Queue.h"
//-------------------------------------------------
Queue::Queue(void)//构造函数
{
head = NULL;
tail = NULL; // the queue is empty when head ==NULL, tail == NULL }
Queue::~Queue(void)//析构函数
{
Node * ptr = NULL;
while (head != NULL )
{
ptr = head;
head = head->next;
delete ptr ;
}
}
//-------------------------------------------------void Queue::push(dataType value )//出队
{
Node * ptr = new Node ;
ptr->data = value;
ptr->next = NULL;
if (tail != NULL ){
tail->next = ptr;
}else {
head = ptr ;
}
tail = ptr ;
}
//-------------------------------------------------void Queue::pop()//入队
{
Node *ptr = head ;
head = head->next;
delete ptr ;
ptr = NULL;
if (head == NULL )
tail = NULL ;
}
//-------------------------------------------------dataType Queue::front() // 获取头元素
{
if (this->IsEmpty() == true ){
cout <<"the Queue is empty!!" ;
return 0;
}
return head->data;
}
bool Queue::IsEmpty()//是否为空
{
return head==NULL && tail == NULL;
}
//-------------------------------------------------// end of file
//编写主函数测试
//文件名：main.cpp
//-------------------------------------------------// 2014--03--23
// C++ 实现链表队列
//-------------------------------------------------#include"Queue.h"
//-------------------------------------------------int main()
{
Queue qu;
qu.push(324);
qu.push(3224);
qu.push(32324);
qu.push(3214);
qu.push(322354);
cout << qu.front() << endl;
qu.pop();cout << qu.front() << endl;
qu.pop();cout << qu.front() << endl;
qu.pop();cout << qu.front() << endl;
qu.pop();cout << qu.front() << endl;
qu.pop();
cout << qu.IsEmpty() << endl;
return 0;
}
//-------------------------------------------------
完整版数据结构习题集第3章栈和队列
第3章栈和队列 一、选择题 1.栈结构通常采用的两种存储结构是（A ）。 A、顺序存储结构和链表存储结构 B、散列和索引方式 C、链表存储结构和数组 D、线性链表结构和非线性存储结构 2.设栈ST 用顺序存储结构表示，则栈ST 为空的条件是（ B ） A、ST.top-ST.base<>0 B、ST.top-ST.base==0 C、ST.top-ST.base<>n D、ST.top-ST.base==n 3.向一个栈顶指针为HS 的链栈中插入一个s 结点时，则执行（ C ） A、HS->next=s; B、s->next=HS->next；HS->next=s; C、s->next=HS；HS=s; D、s->next=HS；HS=HS->next; 4.从一个栈顶指针为HS 的链栈中删除一个结点，用x 保存被删除结点的值，则执行（ C） A 、x=HS；HS=HS->next; B 、HS=HS->next；x=HS->data; C 、x=HS->data；HS=HS->next; D 、s->next=Hs；Hs=HS->next; 5.表达式a*(b+c)-d 的后缀表达式为（ B ） A、abcdd+- B、abc+*d- C、abc*+d- D、-+*abcd 6.中缀表达式A-（B+C/D）*E 的后缀形式是（ D ） A、AB-C+D/E* B、ABC+D/E* C、ABCD/E*+- D、ABCD/+E*- 7.一个队列的入列序列是1，2，3，4，则队列的输出序列是（ B ） A、4，3，2，1 B、1，2，3，4 C、1，4，3，2 D、3，2，4，1 8.循环队列SQ 采用数组空间SQ.base[0,n-1]存放其元素值，已知其头尾指针分别是front 和rear，则判定此循环队列为空的条件是（） A、Q.rear-Q.front==n B、Q.rear-Q.front-1==n C、Q.front==Q.rear D、Q.front==Q.rear+1 9.循环队列SQ 采用数组空间SQ.base[0,n-1]存放其元素值，已知其头尾指针分别是front 和rear，则判定此循环队列为满的条件是（） A、Q.front==Q.rear B、Q.front!=Q.rear C、Q.front==(Q.rear+1)%n D、Q.front!=(Q.rear+1)%n 10.若在一个大小为6 的数组上实现循环队列，且当前rear 和front 的值分别为0 和3，当从 队列中删除一个元素，再加入两个元素后，rear 和front 的值分别为（） A、1，5 B、2, 4 C、4，2 D、5，1 11.用单链表表示的链式队列的队头在链表的（）位置 A、链头 B、链尾 C、链中 12.判定一个链队列Q（最多元素为n 个）为空的条件是（） A、Q.front==Q.rear B、Q.front!=Q.rear C、Q.front==(Q.rear+1)%n D、Q.front!=(Q.rear+1)%n 13.在链队列Q 中，插入s 所指结点需顺序执行的指令是（） A 、Q.front->next=s；f=s; B 、Q.rear->next=s；Q.rear=s;
栈和队列的基本操作的实现
封面： 安徽大学 网络工程 栈和队列的基本操作的实现 ______2010\4\12
【实验目的】 1.理解并掌握栈和队列的逻辑结构和存储结构； 2.理解栈和队列的相关基本运算； 3.编程对相关算法进行验证。 【实验内容】 （一）分别在顺序和链式存储结构上实现栈的以下操作（含初始化，入栈，出栈，取栈顶元素等）： 1.构造一个栈S，将构造好的栈输出； 2.在第1步所构造的栈S中将元素e 入栈，并将更新后的栈S输出； 3.在第2步更新后所得到的栈S中将栈顶元素出栈，用变量e返回该元素，并将更新后的栈S输出。（二）分别在链队列和循环队列上实现以下操作（初始化，入队，出队，取队头元素等）： 1.构造一个队列Q，将构造好的队列输出； 2.在第1步所构造的队列Q中将元素e入队，并将更新后的队列Q输出； 3.在第2步更新后所得到的队列Q中将队头元素出队，用变量e返回该元素，并将更新后的队列Q输出。
【要求】 1.栈和队列中的元素要从终端输入； 2.具体的输入和输出格式不限； 3.算法要具有较好的健壮性，对运行过程中的错误 操作要做适当处理。 三、实验步骤 1．本实验用到的数据结构 (1)逻辑结构：线性结构 (2)存储结构：程序一、四（顺序存储结构）； 程序二、三（链式存储结构）； 2．各程序的功能和算法设计思想 程序一：顺序栈 # include
C语言链表功能实现
#include
Search(L); break; } case 5:{ Delete(&L); break; } case 6:{ bubblesort(&L); break; } case 7:{ selectsort(&L); break; } default :{ printf("\nOption is useless.Please input again."); break; } } if(flag){ printf("\nPlease pick an option: "); scanf("%d",&k); } } return 0; } void Input(SeqList *L){ int i,n; printf("Please input the sum of elements:\n"); scanf("%d",&n); while(n>MaxSize){ printf("Sum is bigger than MaxSize,please input again\n"); scanf("%d",&n); } printf("Input the elements of list:\n"); for(i=0;i
数据结构与算法C语言版期末复习题
《数据结构与算法》期末复习题 一、选择题。 1．在数据结构中，从逻辑上可以把数据结构分为 C 。 A．动态结构和静态结构B．紧凑结构和非紧凑结构 C．线性结构和非线性结构D．内部结构和外部结构 2．数据结构在计算机内存中的表示是指 A 。 A．数据的存储结构B．数据结构C．数据的逻辑结构D．数据元素之间的关系 3．在数据结构中，与所使用的计算机无关的是数据的 A 结构。 A．逻辑B．存储C．逻辑和存储D．物理 4．在存储数据时，通常不仅要存储各数据元素的值，而且还要存储 C 。 A．数据的处理方法B．数据元素的类型 C．数据元素之间的关系D．数据的存储方法 5．在决定选取何种存储结构时，一般不考虑 A 。 A．各结点的值如何B．结点个数的多少 C．对数据有哪些运算D．所用的编程语言实现这种结构是否方便。 6．以下说法正确的是 D 。 A．数据项是数据的基本单位 B．数据元素是数据的最小单位 C．数据结构是带结构的数据项的集合 D．一些表面上很不相同的数据可以有相同的逻辑结构 7．算法分析的目的是 C ，算法分析的两个主要方面是 A 。 （1）A．找出数据结构的合理性B．研究算法中的输入和输出的关系C．分析算法的效率以求改进C．分析算法的易读性和文档性 （2）A．空间复杂度和时间复杂度B．正确性和简明性 C．可读性和文档性D．数据复杂性和程序复杂性 8．下面程序段的时间复杂度是O(n2) 。 s =0; for( I =0; i 数据结构与算法分析实验二·实验报告 姓名：XXXXXXXXXX 学号：XXXXXXXXXX 班级：CCCCCCCCCC XXXXXXXXXXX 数据结构实验报告·实验二CCCCCCCCCCCCCC 实验二（1）用链表实现栈 一、实验描述 用链表实现一个栈。 二、实验设计 1．进栈（PUSH）算法 ①若TOP≥n时，则给出溢出信息，作出错处理（进栈前首先检查栈是否已满，满则溢出；不满则作②）； ②置TOP=TOP+1（栈指针加1，指向进栈地址）； ③S(TOP)=X，结束（X为新进栈的元素）； 2．退栈（POP）算法 ①若TOP≤0，则给出下溢信息，作出错处理(退栈前先检查是否已为空栈，空则下溢；不空则作②)； ②X=S(TOP)，（退栈后的元素赋给X）： ③TOP=TOP-1，结束（栈指针减1，指向栈顶）。 三、实验实现代码 #include SeqStack *s; s=(SeqStack *)malloc(sizeof(SeqStack)); if(!s){ printf("空间不足\n"); return NULL; } else{ s->top=-1; return s; } } //判栈空 int Empty_SeqStack(SeqStack *s){ if(s->top== -1) return 1; else return 0; } //入栈 int Push_SeqStack(SeqStack *s,DataType x) { if(s->top==MAXSIZE-1) return 0;//栈满不能入栈 else { s->top++; s->data[s->top]=x; return 1; } } XXXXXXXXXXX 数据结构实验报告·实验二CCCCCCCCCCCCCC 创建双向循环链表的源代码： #include L->Length ++; } } //结点的输出 void Display( DuLinkList L) { DuLinkList p; printf("双向循环链表中的结点的数据为:"); for(p=L->next ;p->next !=L;) { printf("%d",p->data); printf(" 、"); p=p->next ; } printf("%d\n",p->data ); } int main() { DuLinkList L; int n,i; InitList(&L) ; printf("你想创建几个循环节点就输入几就行啦，请输入:"); scanf("%d",&n); Create(L,n); Display(L); } 双向循环链表插入源代码： #include 《数据结构(C语言版)》复习重点 重点在二、三、六、七、九、十章，考试内容两大类：概念，算法 第1章、绪论 1. 数据：是对客观事物的符号表示，在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。 2. 数据元素：是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。 3. 数据结构：是相互之间存在一种或多种特定关系的数据元素的集合。 其4类基本结构：集合、线性结构、树形结构、图状结构或网状结构 4. 逻辑结构：是数据元素之间的逻辑关系的描述。 5. 物理结构（存储结构）：是数据结构在计算机中的表示（又称映像）。 其4种存储结构：顺序存数结构、链式存数结构、索引存数结构、散列存数结构6. 算法：是对特定问题求解步骤的一种描述，它是指令的有限序列，其中每一条指令表示一个或多个操作。 其5个重要特性：有穷性、确定性、可行性、输入、输出 7. 时间复杂度：算法中基本操作重复执行的次数是问题规模n的某个函数f(n),算法的时间度量记作，T(n)=O(f(n))；他表示随问题规模n的增大，算法执行时间的增长率和f(n)的增长率相同，称做算法的渐进时间复杂度，简称时间复杂度。例如： (a) {++x;s=0;} (b) for(i=1;i<=n;++i){++x;s += x;} (c) for(j=1;j<=n;++j) for(k=1;k<=n;++k){++x;s += x;} 含基本操作“x增1”的语句的频度分别为1、n和n2，则这3个程序段的时间复杂度分别为O(1)、O(n)和O(n2)，分别称为常量阶、线性阶和平方阶。还可呈现对数阶O(log n)、指数阶O(2的n次方)等。 8. 空间复杂度：算法所需存储空间的度量记作，S(n)=O(f(n))。 第2章、线性表 1. 线性表：是最常用最简单的一种数据结构，一个线性表是n个数据元素的有限序列。 2. 线性表的顺序存储结构：是用一组地址连续的存储单元依次存储线性表的数据元素。其特点为逻辑关系上相邻的两个元素在物理位置上也相邻，可以随机存取表中任一元素。 存储位置计算：假设线性表的每个元素需占用L个存储单元，并以所占的第一个单元的存储地址作为数据元素的存储位置，线性表的第i个数据元素ai的存储位置为LOC(ai)=LOC(a1)+(i-1)*L 式中LOC(a1)是线性表第一个元素a1的存储位置，通常称做线性表的起始位置或基地址。 3. 线性表的链式存储结构：是用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的，也可以是不连续的)。 第三章栈和队列试题 一、单项选择题 1.栈的插入和删除操作在（）进行。 A. 栈顶 B. 栈底 C. 任意位置 D. 指定位置 2.当利用大小为n的数组顺序存储一个栈时，假定用top==n表示栈空，则向这个栈插入一个元素时， 首先应执行（）语句修改top指针。 A. top++; B. top--; C. top = 0; D. top; 3.若让元素1,2,3依次进栈，则出栈次序不可能出现（）种情况。 A. 3, 2, 1 B. 2, 1, 3 C. 3, 1, 2 D. 1, 3, 2 4.在一个顺序存储的循环队列中，队头指针指向队头元素的（）位置。 A. 前一个 B. 后一个 C. 当前 D. 后面 5.当利用大小为n的数组顺序存储一个队列时，该队列的最大长度为（）。 A. n-2 B. n-1 C. n D. n+1 6.从一个顺序存储的循环队列中删除一个元素时，需要（）。 A. 队头指针加一 B. 队头指针减一 C. 取出队头指针所指的元素 D. 取出队尾指针所指的元素 7.假定一个顺序存储的循环队列的队头和队尾指针分别为front和rear，则判断队空的条件为（）。 A. front+1 == rear B. rear+1 == front C. front == 0 D. front == rear 8.假定一个链式队列的队头和队尾指针分别为front和rear，则判断队空的条件为（）。 A. front == rear B. front != NULL C. rear != NULL D. front == NULL 9.设链式栈中结点的结构为（data, link），且top是指向栈顶的指针。若想在链式栈的栈顶插入一 个由指针s所指的结点，则应执行操作（）。 A. top->link = s; B.s->link = top->link; top->link = s; C. s->link = top; top = s; D. s->link = top; top = top->link; 10.设链式栈中结点的结构为（data, link），且top是指向栈顶的指针。若想摘除链式栈的栈顶结点， 并将被摘除结点的值保存到x中，则应执行操作（）。 A. x = top->data; top = top->link; B. top = top->link; x = top->data; C. x = top; top = top->link; D. x = top->data; 11.设循环队列的结构是 #define MaxSize 100 typedef int ElemType; 数据结构（C语言版）期末复习汇总 第一章绪论 数据结构：是一门研究非数值计算程序设计中的操作对象，以及这些对象之间的关系和操作的学科。 数据结构是一门综合性的专业课程，是一门介于数学、计算机硬件、计算机软件之间的一门核心课程。是设计和实现编译系统、操作系统、数据库系统及其他系统程序和大型应用程序的基础。 数据：是客观事物的符号表示，是所有能输入到计算机中并被计算机程序处理的符号的总称。 如数学计算中用到的整数和实数，文本编辑中用到的字符串，多媒体程序处理的图形、图像、声音及动画等通过特殊编码定义后的数据。 数据的逻辑结构划分：线、树、图 算法的定义及特性 算法：是为了解决某类问题而规定的一个有限长的操作序列。 五个特性：有穷性、确定性、可行性、输入、输出 评价算法优劣的基本标准（4个）： 正确性、可读性、健壮性、高效性及低存储量 第二章线性表 线性表的定义和特点： 线性表：由n(n≥0)个数据特性相同的元素构成的有限序列。线性表中元素个数n(n≥0)定义为线性表的长度，n=0时称为空表。 非空线性表或线性结构，其特点： （1）存在唯一的一个被称作“第一个”的数据元素； （2）存在唯一的一个被称作“最有一个”的数据元素； （3）除第一个之外，结构中的每个数据元素均只有一个前驱； （4）除最后一个之外，结构中的每个数据元素均只有一个后继。 顺序表的插入：n个元素在i位插入，应移动（n-i+1）位元素。 顺序表存储结构的优缺点： 优点： 逻辑相邻，物理相邻；可随机存取任一元素；存储空间使用紧凑； 缺点： 插入、删除操作需要移动大量的元素；预先分配空间需按最大空间分配，利用不充分； 表容量难以扩充； 线性表的应用： 一般线性表的合并：★★★ 算法2.1：LA=(7,5,3,11) LB=(2,6,3) 合并后LA=(7,5,3,11,2,6) 算法思想：扩大线性表LA，将存在于线性表LB中而不存在于线性表LA中的数据元素插入到线性表LA中去。只要从线性表LB中依次取得每个数据元素，并依值在线性表LA中 实验二栈与队列操作 实验目的： (1)理解栈与队列的结构特征和运算特征，以便在实际问题背景下灵活运用。 (2)了解复杂问题的递归算法设计。 本次实验中，下列实验项目选做一。 1、顺序栈的基本操作 [问题描述] 设计算法，实现顺序栈的各种基本操作 [基本要求] （1）初始化栈s。 （2）从键盘输入10个字符以$结束，建立顺序栈。 （3）从键盘输入1个元素，执行入栈操作。 （4）将栈顶元素出栈。 （5）判断栈是否为空。 （6）输出从栈顶到栈底元素。 要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。 2、链栈的基本操作 [问题描述] 设计算法，实现链栈的各种基本操作 [基本要求] （1）初始化栈s。 （2）从键盘输入10个字符以$结束，建立带头结点的链栈。 （3）从键盘输入1个元素，执行入栈操作。 （4）完成出栈操作。 （5）判断栈是否为空。 （6）输出从栈顶到栈底元素。 （7）输出链栈的长度。 要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。 3、循环队列的基本操作 [问题描述] 设计算法，实现循环顺序队列的建立、入队、出队等操作。 [基本要求] （1）从键盘输入10个字符以$结束，建立循环队列，并显示结果。 （2）从键盘输入1个元素，执行入队操作，并显示结果。 （3）将队头元素出队，并显示结果。 （4）要求程序通过一个主菜单进行控制，在主菜单界面通过选择菜单项的序号来调用各功能函数。 4、只用尾指针表示的循环链表队列的综合操作 [问题描述] 假设以带头结点的的循环链表表示队列，并且只设一个指针指向队尾元素的结点（注意不设头指针），试编写队列初始化、入队、出队函数。 [基本要求及提示] （1）首先定义链表结点类型。 （2）编写带头结点的循环链表的初始化函数，只用尾指针表示。 （3）编写入队函数、出队函数。 （4）在主函数中编写菜单（1.初始化；2.入队；3.出队；4.退出），调用上述功能函数。 5、用标志域表示队空队满状态的循环队列的综合操作 [问题描述] 要求循环队列不损失一个空间全部都得到利用，设置一个标志域tag，以0和1来区分当队头与队尾指针相同时队列状态的空和满，试编写与此结构相对应的入队和出队操作。 [基本要求及提示] （1）教材中为区分当队头与队尾指针相同时队列状态的空和满，以牺牲一个空间的代价来实现的，空：Q->front==Q->rear,满：（Q->rear+1）%MAXSIZE==Q->front。 （2）本题不损失一个空间全部都得到利用，为此如下定义循环队列类型： Typedef struct { QueueElementType element[MAXSIZE]; int front; int rear; int tag; }SeqQueue; 此时，循环队列空和满的条件分别为： Q->front==Q->rear&&tag==0 和 Q->front==Q->rear&&tag==1 （3）编写入队函数、出队函数。 （4）在主函数中编写菜单（1.入队；2.出队；3.退出），调用上述功能函数。 6、利用辅助数组进行栈的逆置 [问题描述] 利用辅助栈将栈中的元素逆置。 [基本要求及提示] 在主函数中编写菜单（1.入栈；2.出栈；3.逆置；4.退出）调试运行程序。 7、利用辅助栈进行队列的逆置 [问题描述] 利用辅助栈进行队列元素逆置。 [基本要求及提示] 在主函数中编写菜单（1.入队；2.出队；3.逆置；4.退出）调试运行程序。 8、Hanoi塔问题 用双向循环链表求解约瑟夫环 学校：东北大学 专业：计算机科学与技术 1.问题描述 Josephus排列问题定义如下：假设n个竞赛者排成一个环形。给定一个正整数m≤n，从第1人开始，沿环计数，第m人出列。这个过程一直进行到所有人都出列为止。最后出列者为优胜者。全部出列次序定义了1，2，…n的一个排列。称为（n，m）Josephus排列。例如，（7，3）Josephus排列为3,6,2,7,5,1,4。【实验要求】 设计求解Josephus排列问题程序。 （1）采用顺序表、单链表或双向循环链表等数据结构。 （2）采用双向循环链表实现Josephus排列问题，且奇数次顺时针轮转，偶数次逆时针轮转。 （3）推荐采用静态链表实现Josephus排列问题。 2.需求分析 本程序要求根据输入的人数n和给定的正整数m，求得约瑟夫排列，且奇数次顺时针轮转，偶数次逆时针轮转。故可利用双向循环链表建立存储结构，利用双向循环链表的遍历与删除操作实现功能要求。 3.概要设计 1.抽象数据类型定义： typedef struct DuLNode { int data; struct DuLNode *prior; struct DuLNode *next; }DuLNode,*DuLinkList; //定义双向循环链表 2.基本操作 int InitList_Dul(DuLinkList &L) //建立一个只含头结点的空双向循环链表 int CreateList_DuL(DuLinkList &L,int n) //建立一个带头结点的含n个元素的 双向循环链表L int ListDelete_DuL(DuLinkList &L,DuLinkList x) //删除指针x指向的结点 3.设计思路 首先建立一个双向循环链表作为存储结构，每个结点的数据域存储每个人的编号，然后根据给定的m值对整个链表进行遍历，找到所要找的结点后，输出该结点的数据域的值，并在双向循环链表中删除该结点，重复这样的操作，一直到所有的人都出列，依次输出的数列即为所求的Josephus排列。 4.详细设计 typedef struct DuLNode { int data; struct DuLNode *prior; .h #ifndef LIST_H_INCLUDED #define LIST_H_INCLUDED /***** 本头文件均为带头结点的单链表，功能函数包括 对单链表的单个结点的修改，删除等操作， 包含对整个单链表整个操作 单链表来实现栈，队列等数据结构 *****/ typedef int ElemType; typedef int Status; typedef struct LNode { ElemType data; struct LNode * next; }LNode, *LinkList; typedef struct LStack { LinkList top; }LStack, *PLStack;//单链表实现栈 typedef struct LQueue { LinkList Front; LinkList rear; }LQueue, *PLQueue;//单链表实现队列 //单链表操作 Status InitList_L(LinkList &L);//构造一个空的单链表 Status DestroyList_L(LinkList &L);//销毁单链表L Status ClearList_L(LinkList &L);//将单链表置为空表 int ListLength_L(LinkList L);//求单链表的长度 LNode * Search_L(LinkList L, ElemType e);//查找链表L第一个数据域为e的元素，若不存在则返回NULL LNode * NextElem_L(LinkList p);//返回p结点的直接后结点的指针，若P结点是尾元素结点，则返回NULL LNode * MakeNode_L(ElemType e);//构造e结点，返回指向该结点的指针 Status InsertAfter_L(LNode *p, LNode *q);//在p结点之后插入q结点 Status DeleteAfter_L(LNode *p, ElemType &e);//删除结点P直接结点的后继结点，用e返回结点值，若p为空或指向尾结点则操作失败 void ListTraverse_L(LinkList L);//遍历单链表 #include int i=-1; List *p,*data1,*q,*Last; data1=(List *)malloc(sizeof(List)); p=(List *)malloc(sizeof(List)); q=(List *)malloc(sizeof(List)); data1=head->next;//记住第一个数据地址 p=head->next; while(p->next!=NULL) { q=p; //q是前一个节点 p=p->next; //p是后一个节点 p->pre=q; //后一个节点的【前继指针】指向前一个节点的地址} Last=p; //p 就是【最后一个数据】的地址 data1->pre=Last; //【第一个元素】的【前继指针】指向【最后一个元素】的地址Last->next=data1; //【最后一个元素】的【后继指针】指向【第一个元素】的地址//双向链表构成 p=Last; printf("\n\n"); while(p->data!=1) { printf("%d ",p->data); p=p->pre; } printf("%d \n",p->data); } 详解堆栈的几种实现方法——C语言版 基本的抽象数据类型（ADT）是编写C程序必要的过程，这类ADT有链表、堆栈、队列和树等，本文主要讲解下堆栈的几种实现方法以及他们的优缺点。 堆栈（stack）的显著特点是后进先出（Last-In First-Out, LIFO），其实现的方法有三种可选方案：静态数组、动态分配的数组、动态分配的链式结构。 静态数组：特点是要求结构的长度固定，而且长度在编译时候就得确定。其优点是结构简单，实现起来方便而不容易出错。而缺点就是不够灵活以及固定长度不容易控制，适用于知道明确长度的场合。 动态数组：特点是长度可以在运行时候才确定以及可以更改原来数组的长度。优点是灵活，缺点是由此会增加程序的复杂性。 链式结构：特点是无长度上线，需要的时候再申请分配内存空间，可最大程度上实现灵活性。缺点是链式结构的链接字段需要消耗一定的内存，在链式结构中访问一个特定元素的效率不如数组。 首先先确定一个堆栈接口的头文件，里面包含了各个方案下的函数原型，放在一起是为了实现程序的模块化以及便于修改。然后再接着分别介绍各个方案的具体实施方法。 堆栈接口stack.h文件代码： [cpp]view plaincopy 1./* 2.** 堆栈模块的接口 stack.h 3.*/ 4.#include 习题三栈和队列 一单项选择题 1. 在作进栈运算时,应先判别栈是否(① ),在作退栈运算时应先判别栈是否(② )。当栈中元素为n个,作进栈运算时发生上溢,则说明该栈的最大容量为(③ )。 ①, ②: A. 空 B. 满 C. 上溢 D. 下溢 ③: A. n-1 B. n C. n+1 D. n/2 2．若已知一个栈的进栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，...，pn，若p1＝3，则p2为( )。 A 可能是2 B 一定是2 C 可能是1 D 一定是1 3. 有六个元素6，5，4，3，2，1 的顺序进栈，问下列哪一个不是合法的出栈序列？（） A. 5 4 3 6 1 2 B. 4 5 3 1 2 6 C. 3 4 6 5 2 1 D. 2 3 4 1 5 6 4.设有一顺序栈S，元素s1,s2,s3,s4,s5,s6依次进栈，如果6个元素出栈的顺序是s2,s3,s4, s6, s5,s1,则栈的容量至少应该是（） A.2 B. 3 C. 5 D.6 5. 若栈采用顺序存储方式存储，现两栈共享空间V[1..m]，top[i]代表第i个栈( i =1,2)栈顶，栈1的底在v[1]，栈2的底在V[m]，则栈满的条件是（）。 A. |top[2]-top[1]|=0 B. top[1]+1=top[2] C. top[1]+top[2]=m D. top[1]=top[2] 6. 执行完下列语句段后，i值为：（） int f(int x) { return ((x>0) ? x* f(x-1):2);} int i ; i =f(f(1)); A．2 B. 4 C. 8 D. 无限递归 7. 表达式3* 2^(4+2*2-6*3)-5求值过程中当扫描到6时，对象栈和算符栈为（），其中^为乘幂。 A. 3,2,4,1,1；(*^(+*- B. 3,2,8；(*^- C. 3,2,4,2,2；(*^(- D. 3,2,8；(*^(- 8. 用链接方式存储的队列，在进行删除运算时（）。 A. 仅修改头指针 B. 仅修改尾指针 C. 头、尾指针都要修改 D. 头、尾指针可能都要修改 9. 递归过程或函数调用时，处理参数及返回地址，要用一种称为（）的数据结构。 A．队列 B．多维数组 C．栈 D. 线性表 10．设C语言数组Data[m+1]作为循环队列SQ的存储空间， front为队头指针，rear为队尾指针，则执行出队操作的语句为（） A.front=front+1 B. front=（front+1）% m C.rear=(rear+1)%(m+1) D. front=(front+1)%(m+1) 11.循环队列的队满条件为 ( ) A. (sq.rear+1) % maxsize ==(sq.front+1) % maxsize; B. (sq.front+1) % maxsize ==sq.rear C. (sq.rear+1) % maxsize ==sq.front D.sq.rear ==sq.front //C语言课程设计职工信息管理系统—单链表实现 #include "stdio.h" #include "stdlib.h" #include "string.h" int saveflag=0; /*是否需要存盘的标志变量*/ struct employee { char name[15]; char num[10];/* 工号 */ char sex[4]; char bm[15]; char zc[20]; int gz; }; typedef struct node { struct employee data; struct node *next; }Node,*Link; //Link l (注意是：字母l不是数字1) void add(Link l); void disp(Link l); //查看职工所有信息 void del(Link l); //删除功能 Node* Locate(Link l,char findmess[],char nameornum[]); void Qur(Link l); //查询功能 void Tongji(Link l); //统计 void Sort(Link l); //排序 void Modify(Link l); //修改功能 void save(Link l); //将单链表l中的数据写入文件 void printe(Node *p); //本函数用于打印链表中某个节点的数据内容 */ //以下4个函数用于输出中文标题 void printstart(); void Wrong(); void Nofind(); void printc(); list是双向循环链表，，每一个元素都知道前面一个元素和后面一个元素。在STL 中，list和vector 一样，是两个常被使用的容器。和vector不一样的是，list不支持 对元素的任意存取。list中提供的成员函数与vector类似，不过list提供对表首元素的操作 push_front、pop_front，这是vector不具备的。禾口vector另一点不同的是，list的迭代器不会存在失效的情况，他不像vector会保留备份空间，在超过容量额度时重新全部分配内存，导致迭代器失效；list没有备份空间的概念，出入一个元素就申请一个元素的空间，所以它的迭代器不会失效。还是举《C++之vector》中的 例子： int data[6]={3,5,7,9,2,4}; list< int> lidata(data, data+6); lidata.push_back(6); list初始化时，申请的空间大小为6，存放下了data中的6个元素，当向lidata插入第7个元素“6”，list申请新的节点单元，插入到list链表中，数据存放结构如图1所示： 插入节点"6拆之后的list 图1 list的存储结构 list每次增加一个元素，不存在重新申请内存的情况，它的成本是恒定的。而vector每当增加关键元素的时候，都需要重新申请新的更大的内存空间，会调用元素的自身的复制构造函数，存在构造成本。在销毁旧内存的时候，会调用析构函数, 存在析构成本。所以在存储复杂类型和大量元素的情况下，list比vector更有优势！ List是一个双向链表,双链表既可以向前又向后链接他的元素。 数据结构(C语言版)例题（第三章：栈和队列） (2008-05-09 12:33:13) 转载▼ ◆3.15③假设以顺序存储结构实现一个双向栈，即在一维数组的存储空间中存在着两个栈，它们的栈底分别设在数组的的两个端点。 试编写实现这个双向栈tws的三个操作:初始化inistack(tws)、入栈 push(tws,i,x)和出栈pop(tws,i,x)的算法, 其中i为0或1，用以分 别指示设在数组两端的两个栈，并讨论按过程（正/误状态变量可设 为变参）或函数设计这些操作算法各有什么优缺点。 实现下列3个函数： Status InitStack(TwoWayStack &tws, int size); Status Push(TwoWayStack &tws, int i, SElemType x); Status Pop(TwoWayStack &tws, int i, SElemType &x); 双向栈类型定义如下： typedef struct { SElemType *elem; int top[2]; int size; // 分配给elem的总容量 }TwoWayStack; // 双端栈 Status InitStack(TwoWayStack &tws, int size){ tws.elem=(SElemType*)malloc(sizeof(SElemType)*size); tws.size=size; tws.top[0]=0; //hao tws.top[1]=size-1; //以数组下标作为指针； return OK; } Status Push(TwoWayStack &tws, int i, SElemType x) {int w=tws.top[0]; if(w==tws.top[1]) return ERROR; else if(i==0) { tws.elem[tws.top[0]]=x; tws.top[0]=tws.top[0]+1; } else if(i==1) { tws.elem[tws.top[1]]=x; tws.top[1]=tws.top[1]-1; } return OK;用链表实现栈和队列
双向循环链表的建立插入与删除
《数据结构(C语言版)》复习重点要点
数据结构第三章栈和队列3习题
数据结构(C语言版) 期末复习汇总
实验二 栈与队列操作实验题目
用双向循环链表求解约瑟夫环
带有头结点的链表基本操作与其能实现的数据结构,栈和队列
单链表转换成双向循环链表
详解堆栈的几种实现方法——C语言版
第三章栈和队列习题_数据结构电子教案
C语言课程设计_职工信息管理系统_单链表实现程序源代码
双向循环链表list
数据结构(C语言版)例题(第三章：栈和队列)
- 《数据结构》习题集：第3章 栈和队列
- 数据结构考研试题精选及答案第三章 栈和队列答案
- 第三章栈和队列习题_数据结构
- 利用一个链表类实现一个队列类和栈类
- 栈和队列的基本操作的实现
- 第三章栈和队列习题_数据结构
- 栈和队列习题_数据结构
- (完整版)《数据结构》习题集：第3章栈和队列
- 数据结构练习题之栈和队列
- 实验二 栈与队列操作实验题目
- 《数据结构》习题集：第3章 栈和队列
- 栈和队列基本操作实验报告
- c语言栈队列链表算法代码实现
- 链表、堆栈、队列的区别
- 完整版数据结构习题集第3章栈和队列
- 第三章栈和队列习题_数据结构电子教案
- 栈和队列基本操作实验报告
- 栈与队列的基本操作
- 用链表实现栈和队列
- 数据结构第三章栈和队列3习题