数据结构学习笔记 第三章 限定性线性表——栈和队列

最新推荐文章于 2022-07-16 12:02:06 发布
最新推荐文章于 2022-07-16 12:02:06 发布
阅读量944 收藏 3
点赞数
分类专栏： 数据结构笔记 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/itLance/article/details/105552342
版权

文章目录

第三章 限定性线性表——栈和队列

  • 栈和队列是两种重要的数据类型
  • 特殊性：一类操作受限制的线性表，限制插入删除操作的位置
  • 栈：只能在指定的一段插入和删除元素，后进先出
  • 队列：在一端插入元素，另一端删除元素，先进后出，和排队一样

3.1栈

3.1.1栈的定义

  • 栈作为一种限定性线性表，插入删除均在表的一端进行；
  • 栈顶（Top）栈底（Bottom）；
  • 空栈：没有元素；
  • 插入：进栈，入栈；
  • 删除：出栈，退栈。
  • 栈的特点：后进先出（LIFO：Last in First Out)

在这里插入图片描述

  • ADT定义
ADT Stack {
	数据元素：可以是任意类型数据，但必须为同一个数字对象。
    结构关系：栈中的数据元素之间是线性关系。
    基本操作：
    1.InitStack(s)
    操作前提：s为未初始化的栈。
    操作结果：将s初始化为空栈。
    
    2.ClearStack(s)
    操作前提：栈s已存在。
    操作结果：将s置为空栈。
    
    3.IsEmpty(s)
    操作前提：栈s已存在。
    操作结果：判断s是否为空栈。返回TURE,FALSE。
    
    4.IsFull(s)
    操作前提：栈s已存在。
    操作结果：判断栈满。返回TURE,FALSE。
    
    5.Pish(s,x)
    操作前提：栈s已存在。
    操作结果：在栈顶插入元素x。若未满，则插入；若满了，报错。
    
    6.Pop(s,x)
    操作前提：栈s已存在。
    操作结果：删除s顶端的元素，将其放回到x。若为空则操作失败。
    
    7.GetTop(s,x)
    操作前提：栈s已存在。
    操作结果：读栈，将最顶端的元素赋值给x但不删除。
}

3.1.2栈的表示和实现

栈在计算机中有两种基本的储存结构：顺序储存结构和链式储存结构

  • 顺序存储结构的栈为顺序栈
//定义一个栈，将栈和top封装在一个结构里面
#define Stack_Size 50
typdef struct
{
    StackElementType elem[Stack_Size];
    int top;
}SeqStack;

//初始化栈
void InitStack(SeqStack *s)
{
    s->top = -1;
}

//进栈（需考虑未满）
int Push(SeqStack *S, StackElementType x)
{
    if(S->top == Stack_Size - 1)
        return (FALSE); //栈满
    
    S->top++;
    S->elem[S->top] = x;
    return (TRUE)
}

//出栈（需考虑空）
int Pop(SeqStack *S, StackElementType *x)//x带出元素
{
    if(S->top == -1)
        return FALSE;//栈空
    
    *x = S->elem[S->top];
    S->top --;
    return TRUE;
}

//读栈
int GetTop(SeqStack *S, StackElementType *x)
{
    if(S->top == -1)
        return FLASE;//空栈
    else
    {
        *x = S->elem[S->top];
        return TRUE;
    }
    
}
  • 多栈共享技术

两头往中间走。

#define M 100
typedef struct
{
    StackElementType Stack[M];
    int top[2]
}DqStack;

//初始化
void InitStack(DqStack *s)
{
    S->top[0] = -1;
    S->top[1] = M;
}

//双端进栈
int Push (DqStack *S, StackElementType x, int i)
{
    if(S->top[0]+1 == S->top[1])
        return FALSE;//栈满
    switch(i)
    {
        case 0:
            S->top[0]++;
            S->Stack[S->top[0]] = x;
            break;
        case 1:
            S->top[1]--;
            S->Stack[S->top[1]] = x;
            break;
        default:
            return FALSE;
    }
    return TRUE;
}

//出栈
int Pop(DqStack *S, StackElementType *x,int i)
{
    switch(i)
    {
        case 0:
            if(S->top[0] == -1)
                return FLASE;
            *x = S->Elem[S->top[0]];
            S->top[0]--;
            break;
        case 1:
            if(S->top[1] == M)
                return FLASE;
            *x = S->Elem[S->top[1]];
            S->top[1]++;
            break;
        default:
            return FALSE;
    }
    return TRUE;
}
  • 链式储存的栈为链栈
typedef struct node
{
    StackElementType data;
    struct node *next;
}LinkStackNode;
typedef LinkStackNode *LiskStack;

void Init(LiskStack top)
{
    top = malloc(sizeof(LinkStackNode));
}

int Push(LiskStack top, StackElementType x)
{
    LiskStackNode *temp;
    temp = malloc(sizeof (LinkStackNode));
    temp->data = x;
    temp->next = top->next;
    top->next = temp;
    return ture;
}

int Pop(LinkStack top,StackElementType *x)//先判断空栈
{
    LinkStackNode *temp;
    temp = top->next;
    if (temp == NULL)
        retrun false;
    *x = temp->data;
    top->next = temp->next;
    free(temp);
    return true;
}

对于链栈，我们可以将栈顶指针编入一个指针数组，这样就可以形成多链栈。

3.1.3栈的应用举例

  • 汉诺塔问题

3.2队列

3.2.1队列的定义

  • 一种限定性的线性表，一端插入元素，另一端删除元素，先进先出。
  • 队尾：允许插入的一端。
  • 对头：允许删除的一端。

3.2.2队列的表示和实现

  • 链队列

在这里插入图片描述

//定义
typedef struct Node
{
    QueueElementType data;
    struct Node *next;
}LinkQueueNode;

typedef struct
{
    LinkQueueNode *frount;
    LinkQueueNode *rear;
}LinkQueue;

//初始化
int InitQueue(LinkQueue *Q)
{
    Q->front = (LinkQueueNode *)malloc(sizeof (LinkQueueNode));
    if(Q->front != 0)
    {
        Q->rear = Q->front;
        Q->front->next = NULL;
        return true;
    }
    else 
        return false;
}

//入队
int EnterQueue(LinkQueue *Q, QueueElemType x)
{
    LinkQueueNode *NewNode;
    Newnode = (LinkQueueNode *)malloc(sizeof(LinkQueueNode));
    if (NewNode != NULL)
    {
        NewNode->data = x;
        NewNode->next = NULL;
        Q->rear->next = NewNode;
        Q->rear = NewNode;
        return true;
    }
    else
        retrun false;
}

//出队
int DeleteQueue(LinkQueueNode *Q, QueueElemType *x)
{
    LinkQueueNode *p;//用于free的
    
    if(Q->front == Q->rear)
        return false;
    p = Q->front->next;
    Q->front->next = p->next;
    if(Q->rear == p)//如果队中只有一个p，pfree之后，rear就指向乱七八糟了，所以要改一下rear。
        Q->rear = Q->front;
    *x = p->data;
    free(p);
    
    return true;
}
  • 循环队列
#define MAXSIZE 50
typedef struct
{
    QueueElementType element[MAXSIZE];
    int front;
    int rear;
}SeqQueue;

//初始化
void InitQueue(SeqQueue *Q)
{
    Q->front = Q->rear = 0;
}

//入队
int EnterQueue(SeqQueue *Q, QueueElementType x)
{
    if((Q->rear + 1)%MAXSIZE == Q->front)//尾指针追上头指针
        return false;
    Q->element[Q->rear] = x;
    Q->rear = (Q->rear+1)%MAXSIZE;
    return true;
}

//出队
int DeleteQueue(SeqQueue *Q, QueueElementType *x)
{
    if(Q->front == Q->rear)
        return false;
    *x = Q->element[Q->front];
    Q->front = (Q->front+1)%MAXSIZE;
    return true;
}

3.2.3队列的应用举例

1.打印杨辉三角
#include <stdio.h>

#define  TRUE 1
#define  FALSE 0

#define MAXSIZE 50  /*队列的最大长度*/

typedef struct
{
	int element[MAXSIZE];  /* 队列的元素空间*/
	int front;  /*头指针指示器*/
	int rear;  /*尾指针指示器*/
} SeqQueue;


/*初始化操作*/
void InitQueue(SeqQueue *Q)
{  
	/* 将*Q初始化为一个空的循环队列 */
	Q->front=Q->rear=0;
}

/*入队操作*/
int EnterQueue(SeqQueue *Q, int x)
{  
	/*将元素x入队*/
	if((Q->rear+1)%MAXSIZE==Q->front)  /*队列已经满了*/
		return(FALSE);
	Q->element[Q->rear]=x;
	Q->rear=(Q->rear+1)%MAXSIZE;  /* 重新设置队尾指针 */
	return(TRUE);  /*操作成功*/
}

/*出队操作*/
int DeleteQueue(SeqQueue *Q, int *x)
{ 
	/*删除队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	Q->front=(Q->front+1)%MAXSIZE;  /*重新设置队头指针*/
	return(TRUE);  /*操作成功*/
}

int GetHead(SeqQueue *Q, int *x)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	return(TRUE);  /*操作成功*/
}

void YangHuiTriangle( )
{ 
	int n;
	int i;
	int temp;
	int x;
	int N;
	SeqQueue Q;
	InitQueue(&Q);
	EnterQueue(&Q,1);  /* 第一行元素入队*/
	printf("please input N:");
	scanf("%d",&N);
	for(n=2;n<=N;n++)   /* 产生第n行元素并入队，同时打印第n-1行的元素*/
	{
		EnterQueue(&Q,1);   /* 第n行的第一个元素入队*/
		for(i=1;i<=n-2;i++)  /* 利用队中第n-1行元素产生第n行的中间n-2个元素并入队*/
		{
			DeleteQueue(&Q,&temp);
			printf("%6d",temp);     /* 打印第n-1行的元素*/
			GetHead(&Q,&x);
			temp=temp+x;      /*利用队中第n-1行元素产生第n行元素*/
			EnterQueue(&Q,temp);  
		}
		DeleteQueue (&Q,&x);  
		printf("%6d",x);    /* 打印第n-1行的最后一个元素*/
		EnterQueue(&Q,1);   /* 第n行的最后一个元素入队*/
		printf("\n");
	}
}

void main()
{
	YangHuiTriangle( );
}
2.键盘输入缓冲区算法
seqqueue.h
#define  TRUE 1
#define  FALSE 0
#define  QueueElementType char

#define MAXSIZE 50  /*队列的最大长度*/

typedef struct
{
	QueueElementType  element[MAXSIZE];  /* 队列的元素空间*/
	int front;  /*头指针指示器*/
	int rear;  /*尾指针指示器*/
}SeqQueue;


/*初始化操作*/
void InitQueue(SeqQueue *Q)
{  
	/* 将*Q初始化为一个空的循环队列 */
	Q->front=Q->rear=0;
}

/*入队操作*/
int EnterQueue(SeqQueue *Q, QueueElementType x)
{  
	/*将元素x入队*/
	if((Q->rear+1)%MAXSIZE==Q->front)  /*队列已经满了*/
		return(FALSE);
	Q->element[Q->rear]=x;
	Q->rear=(Q->rear+1)%MAXSIZE;  /* 重新设置队尾指针 */
	return(TRUE);  /*操作成功*/
}

/*出队操作*/
int DeleteQueue(SeqQueue *Q, QueueElementType *x)
{ 
	/*删除队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	Q->front=(Q->front+1)%MAXSIZE;  /*重新设置队头指针*/
	return(TRUE);  /*操作成功*/
}

int GetHead(SeqQueue *Q, QueueElementType *x)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(FALSE);
	*x=Q->element[Q->front];
	return(TRUE);  /*操作成功*/
}

int IsEmpty(SeqQueue *Q)
{ 
	/*提取队列的队头元素，用x返回其值*/
	if(Q->front==Q->rear)  /*队列为空*/
		return(TRUE);
	else
		return(FALSE);  /*操作成功*/
}
main.c
#include "stdio.h"
#include "conio.h"

#include "seqqueue.h"

main()
{
	char ch1,ch2;
	SeqQueue  Q;
	int f;
	InitQueue (&Q);/*初始化队列*/

	while(TRUE)
	{
		while(TRUE)
		{
			printf("A");  /*进程1*/

			if(kbhit())  /*前键盘敲击*/
			{
				ch1=getch();  /*读取键入字符*/
				if(ch1==';'||ch1=='.')  /*第一个进程中断*/
					break;
				f= EnterQueue(&Q,ch1);  /*入队*/
				if(f==FALSE)
				{
					printf("full");  /*满队*/
					break;
				}
			}

		}
		while (!IsEmpty(&Q))  /*第二个进程*/
		{
			DeleteQueue(&Q,&ch2);
			putchar(ch2);  /*显示输入缓冲区内容*/
		}
		getch();
		if(ch1=='.') break;  /*结束整个程序*/
	}
}

3.3总结与提高

  • 基本概念：
    ① 栈和队列是特殊的线性表，是操作受限制的线性表
    ② 操作的位置限制在表的端点
    • 栈：限定元素的操作只在表的一端
    • 队列：限定元素的操作在表的两段进行

  • 顺序和链式存储方式：
    ① 栈：
    • 顺序栈：受到事先开辟的栈区容量的限制；
    • 链栈：栈顶指针指向栈顶位置
    ② 队列：
    • 循环队列：为了区分队列空和满的方法（损失一个空间的方法）；受到事先开辟的栈区容量的限制；
    • 链队列：除了头指针，还有一个尾指针，并且封装在一个结构体里

  • 栈与队列的应用：
    ① 栈：
    • 保存暂时无法解决的问题，而将注意力转向最新出现的问题，当最新问题得到解决后，再次回到次新问题上
    • 利用最新问题的解，求得次新问题的解（递归）
    ② 队列：控制解决问题的顺序，凡是对元素的保存次序与使用顺序相同的，都可使用队列

itLance
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构：线性表、链表、队列、栈、串
11-24
3. **队列**：队列是一种先进先出（FIFO）的数据结构，分为顺序队列和链式队列。seqQueue.cpp和linkQueue.cpp分别展示了这两种实现。顺序队列基于数组，当队尾达到数组长度时，需要进行队列扩容；链式队列则通过链表...
数据结构与算法实验，线性表，栈和队列，二叉树，图结构
01-18
在这个实验中，我们将深入探讨四个核心概念：线性表、栈和队列、二叉树以及图结构。这些概念构成了许多高级算法的基础，广泛应用于软件开发、数据库设计、网络通信等多个领域。 1. 线性表：线性表是最基本的数据...
限定性线性表—队列（顺序存储及链式存储）
郭永明的技术专栏
05-09 3784
目录1. 队列概述1.1 队列定义1.2 队列演示2. 队列顺序存储2.1 顺序存储定义2.2 循环队列2.3 顺序存储队列常规操作2.3.1 初始化与清空2.3.2 空队列与满队列判断2.3.3 入队与出队2.3.4 其他操作3. 队列链式存储3.1 链式存储定义3.2 链式存储队列常规操作3.2.1 初始化与销毁3.2.2 空队列判断3.2.3 入队与出队3.2.4 其他操作4. 总结 1. 队列概述 1.1 队列定义 队列是只允许在一端进行插入操作，在另一端进行删除操作的线性表。 队列是一种先进先出的
限定性线性表—栈
chirrupy_hamal的博客
04-06 1119
栈（堆栈）和队列是两种重要的抽象数据类型，是一类操作受限制的特殊线性表，其特殊性在于限制插入和删除等运算的位置。 在栈中，用户只能在指定的一端插入和删除元素，因此具有后进先出或先进后出的特性；在队列中，用户只能在一端插入元素，而在另一端删除元素，因此呈现先进先出或后进后出的特性。 从数据结构角度看，它们都是线性结构。 栈作为一种限定性线性表，是将线性表的插入和删除运算限制为仅在表的一端进行，通常将...
【数据结构】限定性线性表——栈 （7000字超级详细 图文结合）C语言
登登的博客 是温馨的小屋。
05-20 917
亲爱的友友们，现在让我们一起重新来学习栈的知识吧 这7000字的对栈深入浅出的描述，希望能够帮助你我更加熟悉一些基础算法。 栈作为一种限定性线性表，是将线性表的插入和删除运算限制为仅在表的一端进行。通常将表中允许进行插入、删除操作的一端称为栈顶 (Top)，表的另一端被称为栈底 (Bottom)。当栈中没有元素时称为空栈。栈的插入操作被形象地称为进栈或入栈，删除操作称为出栈或退栈。
限定线性表---栈
yyh_linux_note的博客
12-12 156
文章目录一，栈的定义二，顺序栈三，链栈入栈出栈 一，栈的定义 二，顺序栈 三，链栈 一，栈的定义 栈是一种线性表，插入删除的操作都在一段进行，这端一般为栈顶 栈是先进后出的线性表，简称LIFO表 数据元素：任意类型但是必须属于一个数据对象 栈中数据元素为线性关系 栈分为两种存储结构：顺序存储和链式存储 二，顺序栈 顺序栈必须在栈顶附设一个位置指针top来动态指示栈顶元素在栈中的位置 通常 top...
【数据结构】限定性线性表——栈与队列 总结
Mr.zwX
07-05 341
一、顺序栈 LIFO （一）栈的声明 #define Stack_Size 100 typedef struct{ StackElementType elem[Stack_Size]; int top; }SeqStack; （二）栈的操作 1、初始化栈——构造空栈 top == -1 void InitStack(SeqStack* S){ S->top=-1; } 2、判栈空 int IsEmpty(SeqStack* S){ return (S->to
数据结构：第3章 限定性线性表—栈和队列.ppt
06-18
在本章中，我们将专注于两种特殊类型的线性数据结构——栈和队列，它们在逻辑上属于线性表，但在操作上具有特定的限制。 **栈（Stack）** 栈是一种“后进先出”（LIFO, Last In First Out）的数据结构，形象地比喻...
数据结构实验（线性表、栈、队列）
11-20
（2）建立一个循环单链表，其节点有 prior，data 和 next 三个域，其中 data 为数 据域，存放元素的有效信息，next 域为指针域，指向后继节点，prior 为指针域，它的 值为 NULL。编写一个算法将此表改为循环双链表。...
数据结构与算法PPT-数据结构绪论、线性表、栈和队列、树与二叉树、图、查找、排序
最新发布
02-14
本资料包涵盖了数据结构与算法的重要概念，包括数据结构绪论、线性表、栈和队列、树与二叉树、图、查找以及排序。 1. **数据结构绪论**： 数据结构是程序设计的基础，它涉及到如何在计算机中存储和组织数据。常见的...
数据结构——栈（1）：限定性线性表（先进后出）
zhangying_496的博客
08-05 1319
1、栈的定义 2、栈顶顺序存储结构 3、共享空间栈 4、栈的链式存储结构
限定性线性表—队列
chirrupy_hamal的博客
06-27 431
队列是另一种限定性的线性表，它只允许在表的一端插入元素，而在另一端删除元素，所以队列具有先进先出（FIFO）的特性。 在队列中，允许插入的一端叫做队尾（rear），允许删除的一端则称为队头（front）。 与线性表类似，队列也可以有两种存储表示，即顺序表示和链式表示。 队列之顺序队列 循环队列是队列的一种顺序表示和实现方法。 与顺序栈类似，在队列的顺序存储结构中，可以用一组地址连续的存储单元依次存...
限定性线性表——栈
qq_41293737的博客
04-21 613
1. 栈的定义： 栈作为一种限定性顺序表，是将线性表的插入和删除操作限制为仅在表的一端进行，通常将表中允许插入、删除操作的一端称为栈顶（Top），因此栈顶的位置是动态变化的，它由一个称为栈顶指针的位置指示器来表示。同时，表的另一端被称为栈底（Bottom）。当栈中没有元素时称为空栈。栈的插入操作被形象的称为进栈或入栈、删除操作称为出栈或退栈。 2、栈的表示和实现——顺序栈 顺序...
学习队列心得
weixin_47810364的博客
07-16 274
文章为本人学习笔记，如有错漏，还恳请批评指正！
第三章「栈与队列」 学习总结
weixin_30430169的博客
03-31 214
通过第三章【栈与队列】的学习，我掌握了对两种特殊线性表—栈与队列的 一系列操作方法。栈的特点是后进后出，队列的特点是后进先出。这两种操作受 限的线性表在帮助我们解决特定的问题时能带来相当大的便利。 本章的作业一是pta上的括号匹配编程题，题目要求我们对一串输入的字符 串进行扫描判断该串字符中的括号是否匹配。再学完栈之后，我第一个想到的便 是利用栈后出后进...
数据结构——限定性线性表——栈与队列
qq_53246692的博客
06-17 197
栈 队列
限定性线性表——栈和队列
qq_40824748的博客
10-22 2756
限制线性表插入和删除等运算的位置（只允许在端点位置操作） 栈是限定仅在表的一端进行插入和删除的线性表 队列是限定仅在表的一端进行插入、在表的另一端进行删除的线性表 栈和队列是两种常用的抽象数据类型、都属于线性结构 栈： 栈可以改变数据的处理顺序 栈是函数过程嵌套调用及递归调用管理的有效手段 定义： 只能在表的一端（栈顶）进行插入和删除运算的线性表 逻辑结构： 与线性表相同、仍为一对一关系 存储结构 ： 用顺序栈或链栈存储均可、但以顺序栈更常见 运算规则：...
栈和队列——限定性线性表（一）
qq_40657955的博客
11-22 606
限定性：限制线性表插入和删除等运算的位置。（只允许在端点位置操作） 栈：把运算位置限定在表尾端的线性表。        栈顶：允许运算端        栈尾：不允许运算端        栈顶指示器：用来指示动态变化的栈顶位置        空栈：表中无任何元素        满栈：无法申请到栈区可用空间        栈的常见运算：进栈或入栈（表尾插入），出栈或退栈（表尾删除）  ...
数据结构与算法（Java实现）之 【限定性线性表——栈和队列】
海绵猿宝的博客
01-28 1887
（1）基本概念 栈和队列，是操作受限定的线性表。共同点是操作的位置限制在表的端点。 栈具有LIFO的特性，限定元素的运算位置只在表的一端（栈顶）进行。 队列具有FIFO的特性。限定元素的运算位置分别在表的两端进行，队头进行删除操作，队尾进行插入操作。 （2）顺序和链式两种存储方式： 顺序存储结构（更常见）： 栈和队列都可以，受到事先开辟的容量限制，可能发生溢出。 循环队列是顺序存储结构。通过取模(%)将其看成首尾相接的环。区分队列空和满，两种经典解决办法：一是损失一个空间；二是设置标志位。在一..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值