栈--顺序栈与链栈

最新推荐文章于 2023-11-11 00:10:14 发布
最新推荐文章于 2023-11-11 00:10:14 发布
阅读量413 收藏 3
点赞数
分类专栏： 数据结构 文章标签： 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songsongL/article/details/94553726
版权

文章目录

栈

  • 逻辑结构：线性表
  • 存储结构：顺序存储\链式存储
  • 基本运算：
    1. 初始化
    2. 判断栈空
    3. 判断栈满
    4. 入栈
    5. 出栈
    6. 取栈顶元素

注意：栈也是线性表，其特殊性在于有特殊的运算规则。即：栈结构只能在一端进行操作，该操作端称为栈顶，另一端称为栈底。按照“后进先出”（Last In First Out,LIFO）原则处理数据节点。

1. 顺序栈

  • 顺序栈的定义
typedef struct stack
{
    int *base;        	 	// 基地址
    int *top;          		// 栈顶指针
    int stackSize;          // 栈容量
}*Stack;
  • 顺序栈的初始化
Stack Init_Stack(Stack S)				// 栈的初始化
{
    S=(Stack)malloc(sizeof(Stack));
    if(!S)
        exit(0);
        
    S->base = (int*)malloc(STACK_INIT_SIZE*sizeof(DATATYPE));

    if(!S->base)
        exit(0);

    S->top = S->base;
    S->stackSize = STACK_INIT_SIZE;
    return S;
}
  • 判断栈空

栈底等于栈顶即为空。

int IsEmpty(Stack S)
{
    if (S->top == S->base){
        return 1;
    } 
	else{
        return 0;
    }
}
  • 判断栈满

栈顶减栈底等于栈容量即为栈满。

int IsFull(Stack S)
{
    if (S->top - S->base == S->stackSize) {
        return 1;
    } 
	else{
        return 0;

    }
}

回到目录

  • 顺序栈的入栈
void Push(Stack S, DATATYPE e)				// 数据压进栈
{
    assert(S);

    if (IsFull(S))

    {

        S->base = (int*)malloc((STACK_INIT_SIZE+STACK_INCREMENT)*sizeof(DATATYPE));

        if (!S->base)

            exit(0);       					 // 存储分配失败

        S->top = S->base + S->stackSize;

        S->stackSize += STACK_INCREMENT;

    }

    *S->top++ = e;

}
  • 顺序栈的出栈
DATATYPE Pop(Stack S)
{
    assert(S);
    if (S->top == S->base)
        return 0;     
    else
    {
        return *--S->top;     // *--S->top就是*(--S->top)
    }
}
  • 取栈顶元素
// 访问栈顶 
DATATYPE GetTop(Stack S)
{
    assert(S);
    if (S->top == S->base)
        return 0;         
    else
    {
        return *(S->top-1);    
    }
}

注意：取栈顶元素与出栈的区别：
出栈：数据从栈中移出，
取栈顶：只是访问了一下栈顶，数据还在栈中。

  • 顺序栈的销毁
void DestroyStack(Stack S) {
    free(S->base);
	free(S);
}

回到目录

  • 总的代码
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>             // 断言函数
#define STACK_INIT_SIZE 100     // 栈容量
#define STACK_INCREMENT 10      // 栈增量

typedef int DATATYPE;

typedef struct stack
{
    int *base;        	 // 基地址
    int *top;         	 // 栈顶指针
    int stackSize;       // 栈容量
}*Stack;


// 栈的初始化
Stack Init_Stack(Stack S)
{
    S=(Stack)malloc(sizeof(Stack));
    if(!S)
        exit(0);
        
    S->base = (int*)malloc(STACK_INIT_SIZE*sizeof(DATATYPE));

    if(!S->base)
        exit(0);

    S->top = S->base;
    S->stackSize = STACK_INIT_SIZE;
    return S;
}

// 判栈空
int IsEmpty(Stack S)
{
    if (S->top == S->base){
        return 1;
    } 
	else{
        return 0;
    }
}

// 判栈满
int IsFull(Stack S)
{
    if (S->top - S->base == S->stackSize) {
        return 1;
    } 
	else{
        return 0;

    }
}

// 操作数压栈
void Push(Stack S, DATATYPE e)
{
    assert(S);

    if (IsFull(S))
    {

        S->base = (int*)malloc((STACK_INIT_SIZE+STACK_INCREMENT)*sizeof(DATATYPE));

        if (!S->base)

            exit(0);        // 存储分配失败

        S->top = S->base + S->stackSize;

        S->stackSize += STACK_INCREMENT;

    }

    *S->top++ = e;
}

// 操作数弹栈
DATATYPE Pop(Stack S)
{
    assert(S);
    if (S->top == S->base)
        return 0;              // 空栈弹出0保证部分负数的正确运算
    else
    {
        return *--S->top;     // *--S->top就是*(--S->top)
    }
} 

// 访问栈顶 
DATATYPE GetTop(Stack S)
{
    assert(S);
    if (S->top == S->base)
        return 0;         
    else
    {
        return *(S->top-1);    
    }
} 

// 栈的销毁
void DestroyStack(Stack S) {
    free(S->base);
	free(S);
}

int main()
{
  	Stack OPND=NULL;
    OPND = Init_Stack(OPND);        // 创建操作数栈
	int i;
	for (i=0; i<5; i++)
    {
    	Push(OPND,i); 
    }
   
    for (i=0; i<5; i++)
    {
    	printf("此时的栈顶为：%d\n",GetTop(OPND));
    	printf("将%d出栈\n",Pop(OPND)); 
    }
    DestroyStack(OPND);
    return 0;

}
  • 运行结果

在这里插入图片描述
回到目录

2.链栈

  • 链栈的定义
typedef struct node			//定义节点
{
    DATATYPE data;
    struct node * next;
} StackNode;

typedef struct				//定义一个链栈
{
    StackNode * top;  		//总指向栈顶 
    int count;				//计数器 记录链栈的元素个数
}Stack,*LinkStack;
  • 链栈的初始化
void init(LinkStack s)
{
    s->top=NULL;		//该指针箭头指向为空
    s->count=0;			//初始化时长度为零
}
  • 判断栈空
int IsEmpty(LinkStack s)
{
    return (s->top==NULL? TRUE:FALSE);
}

回到目录

  • 链栈的入栈
void push(LinkStack s,DATATYPE a)
{
    StackNode * p=(StackNode *)malloc(sizeof(StackNode));
    if(NULL==p)				//申请不成功
        exit(1);
    else
    {
        p->data=a;			
        p->next=s->top;		//将新节点的指针域指向原栈顶节点
        s->top=p;			//栈顶指针指向新节点
        s->count++;
    }
}
  • 链栈的出栈
DATATYPE pop(LinkStack s)
{
    DATATYPE a; 
    if( IsEmpty(s))
        return FALSE;
    else
    {
        a =s->top->data;			//将即将弹出的数据存在a中。不存也不影响出栈操作 
        s->top=s->top->next;
        s->count--;
        free(s->top);		
		return a;
    }
}
  • 取栈顶元素
DATATYPE GetTop(LinkStack S)
{
    if(IsEmpty(S))
        return FALSE;
    else
    {
        return S->top->data;
    }
}

回到目录

  • 总的代码
# include<stdio.h>
# include<stdlib.h>
# define FALSE 0
# define TRUE 1

typedef int DATATYPE;

typedef struct node			//定义节点
{
    DATATYPE data;
    struct node * next;
} StackNode;

typedef struct				//定义一个链栈
{
    StackNode * top;  		//总指向栈顶 
    int count;				//计数器 记录链栈的元素个数
}Stack,*LinkStack;

void init(LinkStack s);					//初始化
int IsEmpty(LinkStack s);				//判断是否为空（链栈一般不会为满）
void push(LinkStack s,DATATYPE a);		//入栈
DATATYPE pop(LinkStack s);				//出栈
DATATYPE GetTop(LinkStack S);			//取栈顶元素
int length(LinkStack s);				//取链栈长度

void init(LinkStack s)
{
    s->top=NULL;		//该指针箭头指向为空
    s->count=0;			//初始化时长度为零
}

int IsEmpty(LinkStack s)
{
    return (s->top==NULL? TRUE:FALSE);
}

void push(LinkStack s,DATATYPE a)
{
    StackNode * p=(StackNode *)malloc(sizeof(StackNode));
    if(NULL==p)				//申请不成功
        exit(1);
    else
    {
        p->data=a;			
        p->next=s->top;		//将新节点的指针域指向原栈顶节点
        s->top=p;			//栈顶指针指向新节点
        s->count++;
    }
}

DATATYPE pop(LinkStack s)
{
    DATATYPE a; 
    if( IsEmpty(s))
        return FALSE;
    else
    {
        a =s->top->data;			//将即将弹出的数据存在a中。不存也不影响出栈操作 
        s->top=s->top->next;
        s->count--;
        free(s->top);		
		return a;
    }
}

DATATYPE GetTop(LinkStack S)
{
    if(IsEmpty(S))
        return FALSE;
    else
    {
        return S->top->data;
    }
}

int length(LinkStack s)
{
    return s->count;
}

int main(void)
{
    Stack S;
    init(&S);        // 创建操作数栈
 	int i;
	for (i=0; i<5; i++)
    {
    	push(&S,i); 
    }
    
    printf("链栈长度为：%d\n",length(&S));
    	
    while(!IsEmpty(&S))
    {    
		printf("此时的栈顶为：%d\n",GetTop(&S));  
        printf("将%d出栈\n",pop(&S)); 
    }
    return 0;
}
  • 运行结果

在这里插入图片描述

注意：顺序栈的栈顶指向的是即将入栈的位置，没有指着任何数据，所以栈顶减栈底可以判断是否为空或满。而链栈的指针指向的是栈顶的数据，所以s->top==NULL就可以判断是否为空。别搞混了。

回到目录

songsongL
关注
专栏目录
数据结构：顺序栈与链栈
qq_40657299的博客
11-13 661
栈(stack): 概念：栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 栈是允许在同一端进行插入和删除操作的
顺序栈与链式栈
Nessie_zhao的博客
04-10 557
栈首先先对栈做简单的认识：栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。它按照先进后出的原则存储数据，先进入的数据被压入栈底，最后的数据在栈顶，需要读数据的时候从栈顶开始弹出数据（最后一个数据被第一个读出来）。栈具有记忆作用，对栈的插入与删除操作中，不需要改变栈底指针。允许进行插入和删除操作的一端称为栈顶(top)，另一端为栈底(bottom)；栈底固定，而栈顶浮动；栈中元素个
栈的顺序与链式存储结构与操作
11-04
栈的顺序与链式存储结构与操作，已ac过，放心下载
顺序栈和链栈
MONKEY_Quan的博客
12-23 820
栈：（stack）是限定仅在表尾进行插入或删除操作的线性表。（用自己形象的话说，可以把栈比作一个没有盖的桶，栈底就是桶底，而栈顶就是你给桶里放的烧饼（一层只能放一个烧饼），最上面的那个烧饼就是栈顶）。当然你想取出桶底的烧饼，就必须一一的拿出最外面的烧饼，所以栈又称为后进先出（Last In First Out，LIFO）的线性表。 一.顺序栈 顺序栈就是利用顺序存储结构实现的栈，就是利用一...
数据结构-栈的应用：顺序栈与链栈的应用
最新发布
03-22
- **操作**：与顺序栈相同，只是在链表上进行操作，如在链表尾部添加节点（压栈）、移除链表头部节点（出栈）等。 3. **栈的应用场景**： - **括号匹配**：在编译器中，栈常用于检查程序中的括号是否匹配，例如在...
Java算法实例-链栈和顺序栈操作
08-22
与顺序栈相比，链栈在内存分配上更为灵活，不需要预设大小，因此在动态变化的环境中更适用。插入和删除操作（push和pop）的时间复杂度也为O(1)，但比顺序栈多了一些额外的内存开销用于存储指针。 在这个Java算法...
数据结构 栈-链栈及基本操作
Mi-ronin的博客
03-20 6204
目录一.栈的定义二.栈的特点三.栈的理解四.链栈引入五.链栈定义六.链栈的结构体设计七.链栈的基本操作7.1链栈的初始化7.2链栈判空7.3链栈入栈7.4链栈出栈 一.栈的定义 栈是限定仅在表尾进行插入和删除操作的数据结构（受到限制的线性表）。 我们把允许插入和删除的一端称为栈顶，另一端称为栈底，不含任何元素为空栈。 二.栈的特点 后进先出 比如word，浏览器网页等一系列软件中，都有撤销的操作，就是利用栈的这种方式来实现的，可能不同软件的代码不同，但是他们的原理是一样的均为：后进先出。 三.栈的理解
顺序栈与链栈的实现
11-08
顺序栈与链栈的实现 本文将详细介绍顺序栈和链栈的实现，包括它们的数据结构、操作和应用。 一、顺序栈 顺序栈是一种基于数组的栈实现，它使用一个数组来存储栈中的元素。顺序栈的优点是访问速度快、实现简单，...
C++模版类实现顺序栈、链栈
10-28
类的成员函数与顺序栈类似，但操作方式不同： 1. **私有成员**：一个指向节点的指针`top`。 2. **push()**：创建新节点，将新元素放入，并将新节点链接到当前栈顶节点。 3. **pop()**：删除栈顶节点，需要检查栈...
顺序栈和链式栈
qq_36091214的博客
04-14 283
栈是限制在一端进行插入操作和删除操作的线性表（俗称堆栈）允许进行操作的一端称为“栈顶”另一固定端称为“栈底”当栈中没有元素时称为“空栈”。特点 ：后进先出（LIFO）。
顺序栈与链栈
小X的书屋
03-14 512
首先是顺序栈#include<stdio.h> #include<malloc.h> #define MAXSIZE 100 typedef struct{ int data[MAXSIZE];//数值 int top;//顶 }shunxu; shunxu *chuangjian()//创建顺序表 { shunxu*s; s=(shunxu*)malloc(s
【数据结构】顺序栈和链栈--Stack
Z1tai的博客
11-11 2333
栈是一种线性数据结构，它的元素按照特定的顺序进行插入和删除操作。栈的插入操作称为入栈（push），删除操作称为出栈（pop）。栈可以看作是一种具有限制访问的线性表，只能在表的一端进行插入和删除操作，称为栈顶（top）, 而另一端则称为栈底（bottom）。栈是计算机科学中非常重要的数据结构，它具有简单且高效的特点。我们深入了解了栈的概念、用途、基本操作和实现细节。通过掌握栈的原理和应用，我们可以更好地理解和使用它，从而在解决实际问题时发挥其优势。
【数据结构】C语言实现顺序栈和链式栈
Qregi的博客
01-20 678
顺序栈 SeqStack.h #pragma once #include typedef char SeqType; #define SEQMAXSIZE 1000 typedef struct SeqStack{ SeqType data[SEQMAXSIZE]; int top; int bottom; }SeqStack; //初始化栈 void Se
史上最全 顺序栈和链栈
qq_45288176的博客
06-11 2935
■ 栈(stack) 是一个特殊的线性表，是限定仅在一端(通常是表尾)进行插入和删除操作的线表。 ■ 又称为后进先出(Last In First Out)的线性表，简称LIFO结构。
顺序栈和链式栈的理解与使用
HyHarden的博客
08-15 8523
1、前言 栈在很多地方都有涉及，它也是作为一种最基本的数据结构而存在。它的特点是，越后进来的元素越先出去。即，我们对栈进行插入，删除操作，都是通过栈顶元素来操作的。栈其实在逻辑结构上就是线性表，但是它的运算却是受到限制的。在栈中，允许插入删除的一端叫做栈顶，还有另一个固定端作为栈底，如果栈中没有元素则叫做空栈。因为栈是后进先出的，并且是线性表的一种，所以栈也称为后进先出线性表。由
出栈和取栈顶元素有什么区别？
Jay__ZHOU_的博客
10-24 952
在学习栈的时候，遇到了一个题，需要出栈操作和取栈顶元素操作，一时半会没反应过来着两者有什么区别。仔细想想，如果进行出栈操作，其实就是把栈顶元素从栈中直接删除，而取栈顶元素只是返回栈顶元素，并没有删除栈顶元素。
C++实现顺序栈与链栈对比教程
本文档主要介绍了顺序栈（SeqStack）和链栈（linkStack）的实现原理、结构以及相应的操作方法。顺序栈是一种基于数组的数据结构，而链栈则使用链表来存储元素。以下是针对这两种栈的详细讲解： **顺序栈（SeqStack...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值