数据结构 第三章 栈和队列

最新推荐文章于 2022-02-18 09:12:53 发布
最新推荐文章于 2022-02-18 09:12:53 发布
阅读量472 收藏
点赞数
分类专栏： 数据结构复习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41934068/article/details/86009220
版权

目录

3.1 堆栈的基本概念

3.2 堆栈的顺序存储结构

一、构造原理

二、代码实现

三. 多栈共享连续空间问题

3.3 堆栈的链式存储结构

一.构造原理

二、代码实现

3.4 队列的基本概念

3.5队列的顺序存储结构

一.构造原理

二、代码实现

三.循环队列

3.5 队列的链式存储结构

一.构造原理

二、代码实现

3.1 堆栈的基本概念

一、堆栈的定义

     堆栈是一种只允许在表的一端进行插入操作和删除操作的线性表。允许操作的一端称为栈顶，栈顶元素的位置由一个称为栈顶指针的变量给出。当表中没有元素时，称之为空栈。

二、堆栈的基本操作

1. 插入（进栈、入栈）2. 删除（出栈、退栈） 3. 测试堆栈是否为空    4. 测试堆栈是否已满   5. 检索当前栈顶元素

3.2 堆栈的顺序存储结构

一、构造原理

描述堆栈的顺序存储结构最简单的方法是利用一维数组 STACK[ 0..M–1 ] 来表示,同时定义一个整型变量( 不妨取名为top) 给出栈顶元素的位置。

上溢——当堆栈已满时做插入操作。(top=M–1);下溢——当堆栈为空时做删除操作。(top=–1)

二、代码实现

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#define MaxSize 100
using namespace std;
//定义栈
typedef struct stack
{
    int data[MaxSize];//数组实现栈内元素定位
    int top;//作为数组下标
}*Stack,SNode;

//创建一个空栈
Stack creatStack()
{
    Stack s = (Stack)malloc(sizeof(Stack));
    s->top = 0;
    return s;
}

//入栈
bool Push(Stack &s, int x)
{
    if(s->top == MaxSize)
        return false;
    s->data[s->top++] = x;
    return true;
}
//出栈
bool isEmpty(Stack s)
{
    return (s->top == 0);
}
int Pop(Stack &s)
{
    return s->data[--s->top];
}
int main()
{
    int n;
    int x;
    cin>>n;
    Stack s = creatStack();
    while(n--)
    {
        int x;
        cin>>x;
        Push(s,x);
    }
    while(!isEmpty(s))
    {
        cout<<Pop(s)<<" ";
    }
    cout<<endl;
    return 0;
}

三. 多栈共享连续空间问题

#include <stdio.h>
#include <stdlib.h>

#define ERROR 1e8
typedef int ElementType;
typedef enum { push, pop, end } Operation;
typedef enum { false, true } bool;
typedef int Position;
struct SNode {
    ElementType *Data;
    Position Top1, Top2;
    int MaxSize;
};
typedef struct SNode *Stack;

Stack CreateStack( int MaxSize )//要写
{
      Stack s = (Stack)malloc(sizeof(struct SNode));
      s->Top1 = -1;
      s->Top2 = MaxSize;
      s->Data = (int *)malloc(sizeof(int)*(MaxSize+5));
      s->MaxSize = MaxSize;
      return s;
}
bool Push( Stack S, ElementType X, int Tag )//要写
{
    if(S->Top1+1 == S->Top2)
    {
        printf("Stack Full\n");
        return false;
    }
    if(Tag == 1)
    {
        S->Top1++;
        S->Data[S->Top1] = X;
    }
    else
    {
        S->Top2--;
        S->Data[S->Top2] = X;
    }
    return true;
}
ElementType Pop( Stack S, int Tag )//要写
{
    if((Tag == 1 && S->Top1 == - 1) ||(Tag == 2 && S->Top2 == S->MaxSize))
    {
        printf("Stack %d Empty\n",Tag);
        return ERROR;
    }
    if(Tag == 1)
    {
        S->Top1--;
        return S->Data[S->Top1+1];
    }
    else
    {
        S->Top2++;
        return S->Data[S->Top2-1];
    }
}
Operation GetOp();  /* details omitted */
void PrintStack( Stack S, int Tag ); /* details omitted */

int main()
{
    int N, Tag, X;
    Stack S;
    int done = 0;

    scanf("%d", &N);
    S = CreateStack(N);
    while ( !done ) {
        switch( GetOp() ) {
        case push: 
            scanf("%d %d", &Tag, &X);
            if (!Push(S, X, Tag)) printf("Stack %d is Full!\n", Tag);
            break;
        case pop:
            scanf("%d", &Tag);
            X = Pop(S, Tag);
            if ( X==ERROR ) printf("Stack %d is Empty!\n", Tag);
            break;
        case end:
            PrintStack(S, 1);
            PrintStack(S, 2);
            done = 1;
            break;
        }
    }
    return 0;
}

3.3 堆栈的链式存储结构

一.构造原理

      链接堆栈就是用一个线性链表来实现一个堆栈结构, 同时设置一个指针变量( 这里不妨仍用top表示)指出当前栈顶元素所在链结点的位置。栈为空时，有top=NULL。

二、代码实现

#include<stdio.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
typedef struct SNode
{
	int data;
    struct SNode *next;
}*Stack,SNode;
Stack createStack()
{
    Stack s = (Stack)malloc(sizeof(Stack));
    s->next = NULL;
    return s;
}
//入栈
bool isEmpty(Stack s)
{
    if(s->next)
        return false;
    return true;
}
void push(Stack &s,int e)
{
	SNode *p = new SNode;
	p->data = e;
	p->next = s->next;
	s->next = p;
}
//出栈
int pop(Stack &s)
{
	SNode *p = s->next;
	s->next = p->next;
	return p->data;
}

int main()
{
	int n;
	cin>>n;
	Stack s = createStack();
	while(n--)
    {
        int x;
        cin>>x;
        push(s,x);
    }
    while(!isEmpty(s))
    {
        cout<<pop(s)<<" ";
    }
    cout<<endl;
}

3.4 队列的基本概念

一. 队列的定义

队列简称队 。是一种只允许在表的一端进行插入操作，而在表的另一端进行删除操作的线性表。允许插入的一端称为队尾，队尾元素的位置由rear指出； 允许删除的一端称为队头, 队头元素的位置由front指出。

二. 队列的基本操作1. 队列的插入（进队、入队） √ 2. 队列的删除（出队、退队） √ 3. 测试队列是否为空   √ 4. 检索当前队头元素 5. 创建一个空队

3.5队列的顺序存储结构

一.构造原理

在实际程序设计过程中，通常借助一个一维数组QUEUE[0..M–1]来描述队列的顺序存储结构，同时，设置两个变量 front与rear分别指出当前队头元素与队尾元素的位置。

约定

rear 指出实际队尾元素所在的位置,

front 指出实际队头元素所在位置的前一个位置。

二、代码实现

#include <stdio.h>
#include <malloc.h>

typedef struct sq
{
	int maxsize;
	int front, rear;
	int *quence;
}Qs;

void init_quence(Qs *s, int ms) /*初始化队列*/
{
	s->maxsize = ms;
	s->quence = (int *)malloc(ms*sizeof(int));
	s->front = s->rear = 0;
}

void in_quence(Qs *s, int val) /*入队函数*/
{
	if((s->rear+1)%s->maxsize == s->front)
	{
		printf("Quence is full.\n");
		return;
	}
	s->rear = (s->rear+1)%s->maxsize;
	s->quence[s->rear] = val;
}

int out_quence(Qs *s) /*出队函数*/
{
	if(s->rear != s->front)
	{
		s->front = (s->front+1)%s->maxsize;
		return s->quence[s->front];
	}
}

void print_quence(Qs *s) /*打印队列中元素*/
{
	int i;
	i = s->front;

	if(s->rear == s->front)
		return;
	do
	{
		printf("%d ", s->quence[(i+1)%s->maxsize]);
		i = (i+1)%s->maxsize;
	}while(i != s->rear);
}

void clear_quence(Qs *s) /*清除队列*/
{
	free(s->quence);
	s->quence = 0;
	s->maxsize = 0;
	s->front = s->rear = 0;
}

int count_quence(Qs *s) /*统计队列个数*/
{
	int i, count = 0;

	i = s->front;
	if(s->rear == s->front)
		return 0;
	do
	{
		count ++;
		i = (i+1)%s->maxsize;
	}while(i != s->rear);
	return count;
}

int main()
{
	Qs s;
	int i;
	int dat[7] = {1, 2, 3, 4, 5, 6, 7};

	init_quence(&s, 7);
	for(i = 0; i < 7; i++)
	{
		in_quence(&s, dat[i]);
		printf("Quence number is: %d. ", count_quence(&s));
		print_quence(&s);
		printf("\n");
	}
	printf("Out quence number is: %d.\n", out_quence(&s));
	print_quence(&s);
	clear_quence(&s);
	return 0;
}

三.循环队列

把队列(数组)设想成头尾相连的循环表，使得数组前部由于删除操作而导致的无用空间尽可能得到重复利用，这样的队列称为循环队列。

 

3.5 队列的链式存储结构

一.构造原理

队列的链式存储结构是用一个线性链表表示一个队列，指针front与rear分别指向实际队头元素与实际队尾元素所在的链结点。

二、代码实现

#include <stdio.h>
#include <stdlib.h>
typedef int LQEletype;
typedef struct QueueNode{
    LQEletype data;
    struct QueueNode *next;
}QueueNode;
typedef QueueNode *QueueP;//定义指向队列节点的指针（相当于头指针）
typedef struct LinkQueue{
    QueueP front,rear;//定义队头指针（相当于头指针）、队尾指针
}LinkQueue;
void init(LinkQueue *q){
    QueueP p=(QueueP)malloc(sizeof(QueueNode));
    p->next=NULL;
    q->front=p;//初始化一个空的链式队列。
    q->rear=p;
}
void insertEle(LinkQueue *q,LQEletype e){
    QueueP p=(QueueP)malloc(sizeof(QueueNode));
    p->data=e;
    p->next=NULL;//因为插入时在队列后边插入，next为空
    q->rear->next=p;//让队尾指向插入的节点
    q->rear=p;//重新指定队尾
}
void deleteEle(LinkQueue *q,LQEletype *e){
    if(q->front==q->rear){
        printf("该队列为空");
        return ;
    }else{
        QueueP p=q->front->next;//拿到队列的第一个数据
        *e=p->data;
        q->front->next=p->next;//
        if(q->rear==p){//如果拿到的这个数据节点恰巧是队尾，就重新指定队尾
            q->rear=q->front;
        }
        free(p);
    }
}
void getEle(LinkQueue q,LQEletype *e){
    if(q.front==q.rear){
        printf("该队列为空");
        return ;
    }else{
        *e=q.front->next->data;
    }
}
int main()
{
    LinkQueue q;
    init(&q);
    LQEletype e,i=888;
    getEle(q,&e);
    printf("初始化后尝试获取队列里的值：\n%d\n",e);
    insertEle(&q,i);
    getEle(q,&e);
    printf("插入后获取队列里的值：\n%d\n",e);
    deleteEle(&q,&i);
    getEle(q,&e);
    return 0;
}

 

lero1005
关注
专栏目录
数据结构 - 第三章 栈和队列
達某真是滑天下之大稽
04-30 339
定义 栈是限定仅在表尾进行插入和删除操作的线性表。 队列是只允许在一端进行插入操作、而在另一端进行删除操作的线性表。 栈和队列的本质都是线性表，但是是操作受限的线性表。因此它们根据存储方式不同，具有对应线性表的特点。 栈 栈的特殊之处就在于限制了这个线性表的插入和删除位置，它始终只在栈顶进行。这也就使得栈底是固定的，最先进栈的只能在栈底。因此，栈是后进先出的结构。栈空：top=...
《数据结构》第3章 栈和队列
kingloveccc的博客
08-06 542
《数据结构》第3章 栈和队列第3章 栈和队列 第3章 栈和队列
数据结构第三章
yuuka77的专栏
10-25 350
3.1     栈 3.1.1    栈的逻辑结构 1.栈（stack）是限定仅在表尾进行插入和删除操作的线性表，允许插入和删除的而一端称为栈顶，另一端称为栈底。不含任何元素的栈称为空栈。   2.栈的特性：后进先出（在任何时候出栈的元素都只能是栈顶元素，即最后入栈者最先出栈）。   3. 栈的抽象数据类型定义 ADT Stack Data   栈中元素具有相同类型及后进先出
【数据结构】第三章 栈和队列
weixin_30508309的博客
12-09 96
1 栈的概念 栈：限定仅在表尾进行插入和删除操作的线性表，后进先出的线性表，简称LIFO结构 栈顶：表尾，允许插入和删除的一端 栈底：表头，不允许插入和删除的一端 空栈：不含任何数据元素的栈 2 栈的顺序存储结构 (1) 结构代码 typedef int SElemType typedef struct { SElemType data[MA...
JAVA数据结构和算法：第三章（栈和队列）
春水上行的博客
08-25 1025
栈栈是限制仅在一个位置上进行插入和删除的线性表。允许插入和删除的一端为末端，称为栈顶。另一端称为栈底。不含任何数据元素的栈称为空栈。栈又成为后进先出(LIFO)表，后进入的元素最先出来。 首先，栈是一个线性表，元素之间具有线性关系，即前驱后继关系，其次，它是一种特殊的线性表，只能在表尾进行插入和删除操作。栈的插入操作，叫作进栈（push），删除操作，叫作出栈(pop). 由于栈是一个线性表，所以我们
数据结构第三章栈和队列.pdf
11-12
"数据结构第三章栈和队列" 本章节主要介绍了栈和队列这两种基本数据结构的概念、实现和应用。 一、栈的基本概念 栈是一种后进先出（Last In First Out，LIFO）的数据结构，仅允许在栈顶插入或删除元素。栈的基本...
数据结构第三章栈和队列3习题.pdf
07-29
数据结构第三章栈和队列习题 在本节中，我们将讨论栈和队列这两种基本数据结构，通过习题来深入了解它们的实现和应用。 1. 栈的实现 栈是一种后进先出（LIFO）的数据结构，栈顶元素是最新添加的元素。栈的实现...
数据结构第三章栈和队列3.1-3.2
11-23
3.1_1栈的基本概念.mp4将介绍栈的基本概念，3.1_2栈的顺序存储实现.mp4和3.1_3栈的链式存储实现.mp4则会分别讲解栈的两种常见实现方式——顺序存储和链式存储，它们各有优劣，适用于不同的情况。 接下来，我们转向...
数据结构第三章栈和队列3.3-3.4
最新发布
11-23
在本章中，我们将深入探讨两种基本的数据结构：栈和队列，它们在3.3至3.4部分扮演着关键角色。 首先，栈是一种后进先出（LIFO，Last In First Out）的数据结构，就像现实生活中的堆叠物品一样，最后放进去的物品...
数据结构第3章栈和队列自测卷答案.pdf
05-11
数据结构第3章栈和队列自测卷答案.pdf 本资源摘要信息主要关注数据结构的第三章，即栈和队列的相关知识点。通过对自测卷答案的分析，我们可以总结出以下几个重要的知识点： 1. 栈和队列的定义：栈是一种特殊的...
数据结构第三章栈与队列
06-11
内容经典高度概括，知识点全面集中。考试冲刺时用效果挺好的。
数据结构第三章栈和队列
06-25
栈和队列的定义特点练习题及答案 对栈和队列更熟悉的掌握，更深刻的去理解 数据结构其中的妙处。
数据结构#include
01-05
#include #include #define ok 1 #define error 0 #define overflow -1 #define LIST_INIT_SIZE typedef int ElemType; typedef int Status; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; #include #include #define ok 1 #define error 0 #define overflow -1 #define LIST_INIT_SIZE typedef int ElemType; typedef int Status; typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList;
数据结构第三章：栈和队列
欢迎来到关关雎鸠儿的博客
08-13 447
一、栈的定义和运算 1．栈的定义 栈是一种特殊的线性表，插入或删除栈元素的运算只能在表的一端进行，称运算的一端为栈顶，另一端称为栈底。 特点：后进先出 栈又称为“后进先出”的线性表，简称LIFO表。 二、栈的应用举例 1.数制转换 void conversion( ) { initstack(S); scanf (“%”,N); ...
数据结构-第三章 栈和队列
SpriCoder的博客
02-18 627
第三章：栈和队列
数据结构第三章 栈和队列
sunjiansunshine的博客
11-24 183
栈：后进先出 顺序栈，两栈共享空间。 队列，先进先出 队满：（rear+1）mod queuesize=front 顺序表实现队列 #include using namespace std; const int queuesize=14; template class cirqueue { public: cirqueue() { front=rear=queuesize-1; } ~...
掌握数据结构第三章：栈与队列详解
本资源主要介绍了数据结构中的第三章内容——栈。栈是一种特殊的线性数据结构，其特点是只能在表的一端进行插入（进栈）和删除（出栈）操作，具有明确的栈顶和栈底，栈顶作为唯一可进行操作的端点。栈的基本概念包括...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值