数据结构：顺序栈和链栈

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

/*
 * 程序名：seqstack1.c，此程序演示顺序栈的实现，数据元素是整数。
 * 
*/
#include <stdio.h>
#include <string.h>

#define MAXSIZE 10       // 顺序栈的最大长度。

typedef int ElemType;    // 自定义顺序栈的数据元素为整数。

typedef struct
{
  ElemType data[MAXSIZE];   // 用数组存储顺序栈中的元素。
  int top;                  // 栈顶指针，从0到MAXSIZE-1，-1表示空栈。
                            // 也可以从1到MAXSIZE，0表示空栈。
}SeqStack,*PSeqStack;

// 顺序栈SS的初始化操作。
void InitStack(PSeqStack SS);                     

// 销毁顺序栈SS。
void DestroyStack(PSeqStack SS);

// 元素入栈，返回值：0-失败；1-成功。
int Push(PSeqStack SS, ElemType *ee);

// 元素出栈，返回值：0-失败；1-成功。
int Pop(PSeqStack SS, ElemType *ee);

// 求顺序栈的长度，返回值：栈SS中元素的个数。
int Length(PSeqStack SS);                   

// 清空顺序栈。
void Clear(PSeqStack SS);                    

// 判断顺序栈是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqStack SS);                    

// 判断顺序栈是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqStack SS);

// 打印顺序栈中全部的元素。
void PrintStack(PSeqStack SS);                    

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(PSeqStack SS, ElemType *ee);

int main()
{
  SeqStack SS;     // 创建顺序栈。

  InitStack(&SS);  // 初始化顺序栈。

  printf("栈的长度是%d\n",Length(&SS));

  ElemType ee;     // 创建一个数据元素。

  printf("元素（1、2、3、4、5、6、7、8、9、10）入栈。\n");
  ee=1;  Push(&SS, &ee);
  ee=2;  Push(&SS, &ee);
  ee=3;  Push(&SS, &ee);
  ee=4;  Push(&SS, &ee);
  ee=5;  Push(&SS, &ee);
  ee=6;  Push(&SS, &ee);
  ee=7;  Push(&SS, &ee);
  ee=8;  Push(&SS, &ee);
  ee=9;  Push(&SS, &ee);
  ee=10; Push(&SS, &ee);

  printf("栈的长度是%d\n",Length(&SS));

  // 只查看栈顶元素的值，元素不出栈。
  if (GetTop(&SS,&ee)==1)  printf("栈顶的元素值为%d\n",ee);

  PrintStack(&SS);

  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(&SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);

  return 0;
}

// 初始化顺序栈
void InitStack(PSeqStack SS)
{
  Clear(SS); // 清空顺序栈。
}

// 清空顺序栈。
void Clear(PSeqStack SS)
{
  if (SS == NULL) return; // 检查空指针。

  SS->top=-1;  // 栈顶指针置为-1。
  memset(SS->data,0,sizeof(ElemType)*MAXSIZE);  // 数组元素清零。
}

// 求顺序栈的长度，返回值：栈SS中元素的个数。
int Length(PSeqStack SS)
{
  if (SS == NULL) return 0; // 检查空指针。

  return SS->top+1;
}

// 销毁顺序栈SS。
void DestroyStack(PSeqStack SS)
{
  // 静态顺序栈无需释放内存，不需要销毁操作。

  Clear(SS); // 清空顺序栈。

  return;
}

// 判断顺序栈是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(PSeqStack SS)
{
  if (SS == NULL) return 0;  // 检查空指针。

  if (SS->top == -1) return 1;

  return 0;
}

// 判断顺序栈是否已满，返回值：1-已满，0-未满或失败。
int IsFull(PSeqStack SS)
{
  if (SS == NULL) return 0;  // 检查空指针。

  if (SS->top >= MAXSIZE-1) return 1;

  return 0;
}

// 元素入栈，返回值：0-失败；1-成功。
int Push(PSeqStack SS, ElemType *ee)
{
  if ( (SS == NULL) || (ee == NULL) ) return 0;  // 检查空指针。

  if (IsFull(SS) == 1)
  {
    printf("顺序栈已满，不能插入。\n"); return 0;
  }

  SS->top++;  // 栈指针先加1。

  memcpy(&SS->data[SS->top],ee,sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(SS->data+SS->top,ee,sizeof(ElemType));    // 采用指针运算也可以。

  return 1;
}

// 打印顺序栈中全部的元素。
void PrintStack(PSeqStack SS)
{
  if (SS == NULL) return;  // 检查空指针。

  if (SS->top == -1) { printf("栈为空。\n"); return; }

  int kk;
  for (kk = 0; kk <= SS->top; kk++)
  {
    printf("SS[%d],value=%d\n",kk,SS->data[kk]);     // 用数组的下标访问。
    // printf("SS[%d],value=%d\n",kk,*(SS->data+kk));   // 采用指针运算也可以。
  }
}

// 元素出栈，返回值：0-失败；1-成功。
int Pop(PSeqStack SS, ElemType *ee)
{
  if ( (SS == NULL) || (ee == NULL) ) return 0;  // 检查空指针。

  if (SS->top == -1) { printf("栈为空。\n"); return 0; }

  memcpy(ee,&SS->data[SS->top],sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(ee,SS->data+SS->top,sizeof(ElemType));    // 采用指针运算也可以。

  SS->top--;  // 栈指针减1。

  return 1;
}

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(PSeqStack SS, ElemType *ee)
{
  if ( (SS == NULL) || (ee == NULL) ) return 0;  // 检查空指针。

  if (IsEmpty(SS) == 1) { printf("栈为空。\n"); return 0; }

  memcpy(ee,&SS->data[SS->top],sizeof(ElemType));  // 用数组的下标访问。
  // memcpy(ee,SS->data+SS->top,sizeof(ElemType));    // 采用指针运算也可以。

  return 1;
}

 

/*
 * 程序名：linkstack1.c，此程序演示链栈的实现，数据元素是整数。
 * 
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef int ElemType;    // 自定义链栈的数据元素为整数。

typedef struct SNode
{
  ElemType data;       // 链栈中的元素。
  struct SNode *next;  // 指向下一个结点的指针。
}SNode,*LinkStack;

// 链栈SS的初始化操作，分配头结点，返回头结点的地址。
SNode *InitStack();

// 销毁链栈SS。
void DestroyStack(LinkStack SS);

// 元素入栈，返回值：0-失败；1-成功。
int Push(LinkStack SS, ElemType *ee);

// 元素出栈，返回值：0-失败；1-成功。
int Pop(LinkStack SS, ElemType *ee);

// 求链栈的长度，返回值：栈SS中元素的个数。
int  Length(LinkStack SS);                   

// 清空链栈。
void Clear(LinkStack SS);                    

// 判断链栈是否为空，返回值：1-空，0-非空或失败。
int  IsEmpty(LinkStack SS);                    

// 打印链栈中全部的元素。
void PrintStack(LinkStack SS);                    

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(LinkStack SS, ElemType *ee);

int main()
{
  LinkStack SS;     // 创建链栈。

  SS=InitStack();  // 初始化链栈。

  printf("栈的长度是%d\n",Length(SS));

  ElemType ee;     // 创建一个数据元素。

  printf("元素（1、2、3、4、5、6、7、8、9、10）入栈。\n");
  ee=1;  Push(SS, &ee);
  ee=2;  Push(SS, &ee);
  ee=3;  Push(SS, &ee);
  ee=4;  Push(SS, &ee);
  ee=5;  Push(SS, &ee);
  ee=6;  Push(SS, &ee);
  ee=7;  Push(SS, &ee);
  ee=8;  Push(SS, &ee);
  ee=9;  Push(SS, &ee);
  ee=10; Push(SS, &ee);

  printf("栈的长度是%d\n",Length(SS));

  if (GetTop(SS,&ee)==1)  printf("栈顶的元素值为%d\n",ee);

  PrintStack(SS);

  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);
  if (Pop(SS,&ee)==1)  printf("出栈的元素值为%d\n",ee);

  // 销毁链栈SS。
  DestroyStack(SS); SS=0;  // 销毁链栈后把SS置为空，防止野指针。

  return 0;
}

// 链栈SS的初始化操作，分配头结点，返回头结点的地址。
SNode *InitStack()
{
  SNode *head = (SNode *)malloc(sizeof(SNode));  // 分配头结点。

  if (head == NULL) return NULL;  // 内存不足，返回失败。

  head->next=NULL;  // 头结点的下一结点暂时不存在，置空。

  return head;
}


// 清空链栈。
void Clear(LinkStack SS)
{
  // 清空链栈SS是指释放链栈全部的结点，但不包括头结点。
  if (SS == NULL) return;  // 检查空指针。

  SNode *tmp1;
  SNode *tmp2=SS->next;  // 保留头结点，从头结点的下一个结点开始释放。

  while(tmp2!=NULL)
  {
    tmp1=tmp2->next;
    free(tmp2);
    tmp2=tmp1;
  }

  SS->next=NULL; // 这行代码一定不能少，否则会留下野指针。

  return;
}

// 求链栈的长度，返回值：栈SS中元素的个数。
int  Length(LinkStack SS)
{
  if (SS == NULL) return 0; // 检查空指针。

  SNode *pp=SS->next;  // 头结点不算，从第1个结点开始。

  int length=0;

  while (pp != NULL) { pp=pp->next; length++; }

  return length;
}

// 销毁链栈SS。
void DestroyStack(LinkStack SS)
{
  // 销毁链栈SS是指释放链栈全部的结点，包括头结点。
  SNode *tmp;

  while(SS!=NULL)
  {
    tmp=SS->next;  // tmp保存下一结点的地址。
    free(SS);      // 释放当前结点。
    SS=tmp;        // SS指针移动到下一结点。
  }

  // SS=NULL;   // SS在本函数中相当于局部变量，就算置空了也不会影响调用者传递的SS，所以SS=NULL没有意义。

  return;
}

// 判断链栈是否为空，返回值：1-空，0-非空或失败。
int IsEmpty(LinkStack SS)
{
  if (SS == NULL) return 0;   // 检查空指针。

  if (SS->next == NULL) return 1;

  return 0;
}

// 打印链栈中全部的元素。
void PrintStack(LinkStack SS)
{
  if (SS == NULL) return; // 检查空指针。

  if (SS->next == NULL) { printf("栈为空。\n"); return; }

  int kk=0;
  SNode *pp=SS->next;  // 从第1个结点开始。

  while (pp != NULL)
  {
    printf("SS[%d],value=%d\n",kk++,pp->data);     
    pp=pp->next;
  }
}

// 元素出栈，返回值：0-失败；1-成功。
int Pop(LinkStack SS, ElemType *ee)
{
  if ( (SS == NULL) || (ee == NULL) ) return 0;  // 检查空指针。

  if (SS->next == NULL) { printf("栈为空。\n"); return 0; }

  SNode *tmp=SS->next;

  memcpy(ee,&tmp->data,sizeof(ElemType));  

  SS->next=tmp->next;

  free(tmp);

  return 1;
}

// 获取栈顶元素，返回值：0-失败；1-成功。
// 只查看栈顶元素的值，元素不出栈。
int GetTop(LinkStack SS, ElemType *ee)
{
  if ( (SS == NULL) || (ee == NULL) ) return 0;  // 检查空指针。

  if (SS->next == NULL) { printf("栈为空。\n"); return 0; }

  memcpy(ee,&SS->next->data,sizeof(ElemType));  

  return 1;
}

// 元素入栈，返回值：0-失败；1-成功。
int Push(LinkStack SS, ElemType *ee)
{
  if ( (SS == NULL) || (ee == NULL) ) return 0;  // 检查空指针。

  SNode *tmp = (SNode *)malloc(sizeof(SNode));  // 分配一个结点。
  if (tmp == NULL) return 0;  // 内存不足，返回失败。

  // 考虑数据元素为结构体的情况，这里采用了memcpy的方法而不是直接赋值。
  memcpy(&tmp->data,ee,sizeof(ElemType));

  // 处理next指针。
  tmp->next=SS->next;
  SS->next=tmp;
  
  return 1;
}

橙子@C
关注
专栏目录
数据结构：顺序栈与链栈
qq_40657299的博客
11-13 649
栈(stack): 概念：栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 栈是允许在同一端进行插入和删除操作的
数据结构基础：顺序栈和链栈的表示以及实现
weirdo_cy的博客
03-25 1227
栈 定义和特点 限定仅在表尾进行插入或删除操作的线性表 包含两类栈，存储结构不同：顺序栈、链栈 栈的操作特性：后进先出 a1，为栈底元素；an,为栈顶元素。不含元素的空表为空栈 是操作受限制的线性表， 基本操作：入栈、出栈、读取栈顶元素值、建栈、判栈满或空等等 一、顺序栈的表示和实现 1.定义 利用一组地址连续的存储单元依次存放自栈底到栈顶的元素，同时附带指针指示栈顶元素在顺序栈中的位...
数据结构：顺序栈和链式栈的实现
a2998658795的博客
08-17 784
数据结构：顺序栈和链式栈的实现
C语言实现数据结构——顺序栈与链栈
chfens的博客
04-02 2188
C语言实现顺序栈与链栈的基本功能。
数据结构 一、栈的实现
code
08-21 617
www.sourcedev.cc点击打开链接
堆栈ADT实现及应用，数据结构测试
huangdxian的博客
06-03 735
数据结构复习，题目描述： 假设栈ADT的数据元素为整数，栈ADT的实现采用顺序存储结构。现要用栈来辅助完成任意非负十进制整数到Base(Base不大于35)进制的转换。部分代码已经给出，请补充完善栈溢出处理函数和主函数。 注意：只提交需要补充的函数，其他代码不允许自己重写和修改。 **栈溢出处理函数overflowProcess：**当栈满时，将栈的空间在原来基础上扩大1倍。 主函数： 输入一个非负十进制整数n及要转换的进制Base，输出其转换后的进制形式，以及长度。输出格式如下： ($...$)10=(
数据结构课程：顺序栈和链栈的实现
10-16
### 数据结构课程：顺序栈和链栈的实现 #### 栈的基本概念 栈是一种特殊的线性表，其特殊之处在于所有元素的插入和删除都只能在一端进行，这一端被称为栈顶(top)，与之相对的一端称为栈底(bottom)。栈通常支持以下...
数据结构-栈的应用：顺序栈与链栈的应用
最新发布
03-22
在这个主题中，我们将专注于栈（Stack）这一特殊的数据结构，及其在实际应用中的两种主要实现方式：顺序栈（Sequential Stack）和链栈（Linked Stack）。栈通常被称为“后进先出”（LIFO，Last In First Out）的数据...
数据结构C++ 顺序栈、链栈、循环队列、链队列的主要操作（Word文档含代码和注释）
11-04
### 数据结构C++：顺序栈、链栈、循环队列、链队列的主要操作 #### 一、概述 本文档提供了使用C++编程语言实现的数据结构中的栈与队列的操作详解，具体包括顺序栈、链栈、循环队列、链队列四种结构的基本操作，并...
数据结构：顺序栈与链栈及循环队列基础操作实验详解
本实验旨在深入理解栈（Stack）和队列（Queue）这两种基本的数据结构，以及它们在计算机科学中的重要性。实验主要包括以下几个部分： 1. 栈的理论与实现： - 栈是一种后进先出（LIFO，Last In First Out）的数据...
栈——链栈
MADE_哒哒
02-23 383
所谓的链栈指的是采用链表为存储结构而实现的栈。 根据单链表的操作特征，选择其头部为栈的顶部，此时出栈，入栈都可以在O(1)完成。 带头结点的链表，结点的插入和删除都在其头结点之后进行。 不带头结点的链表，结点的插入和删除都在其第一个结点出进行。 而且栈是操作受限制的单链表，它对单链表的功能进行了阉割。如果对单链表理解透彻，则链栈不在话下。 如果对单链表有疑问请看另一篇博客。 https...
【数据结构】顺序栈和链栈--Stack
Z1tai的博客
11-11 2165
栈是一种线性数据结构，它的元素按照特定的顺序进行插入和删除操作。栈的插入操作称为入栈（push），删除操作称为出栈（pop）。栈可以看作是一种具有限制访问的线性表，只能在表的一端进行插入和删除操作，称为栈顶（top）, 而另一端则称为栈底（bottom）。栈是计算机科学中非常重要的数据结构，它具有简单且高效的特点。我们深入了解了栈的概念、用途、基本操作和实现细节。通过掌握栈的原理和应用，我们可以更好地理解和使用它，从而在解决实际问题时发挥其优势。
栈文档之顺序栈
二木成林
04-22 4417
采用顺序存储的栈称为顺序栈，它采用一组地址连续的存储单元存放自栈底到栈顶的数据元素，同时设定一个指针（top）指向当前栈顶元素的位置。通常采用数组来实现。
#pragma once
weixin_30827565的博客
12-29 800
【1】#pragma once这个宏有什么作用？ 为了避免同一个头文件被包含（include）多次，C/C++中有两种宏实现方式：一种是#ifndef方式；另一种是#pragma once方式。在能够支持这两种方式的编译器上，二者并没有太大的区别。但两者仍然有一些细微的区别。 【2】两者的使用方式有何区别？ 示例代码如下： 1 //方式一： 2 #ifndef __SOM...
顺序栈（最简便打印栈中元素）
qq_17807067的博客
04-01 4836
最好记，最好理解的打印栈模板，个人感觉已经是最好了，如有更好请评论~
根据入栈顺序输出所有可能的出栈顺序 （Java）
qq_42194192的博客
09-15 6003
比如入栈顺序是1,2,3，那么出栈顺序分别可以是1,2,3；1,3,2；…. import java.util.Stack; public class ss { static char[] in={'a','b','c'}; public static void main(String[] args){ fun(0,new Stack&lt;Character&gt;(),"");...
C语言实现顺序栈的创建和操作(进栈，出栈，打印等等）
热门推荐
weixin_43954729的博客
03-23 1万+
C语言实现顺序栈的创建和操作(进栈，出栈，打印等等） 往期文章地址： C语言实现顺序表的创建及基本操作 C语言实现单链表的创建及基本操作 本来我在上次的文章结尾说下一篇我想写循环链表的，今天翻开课本仔细看了看，还是想先写一下有关栈方面的知识。一方面是栈和队列正在学习，另一方面是循环链表的知识和相关的例题比较多，不好写。于是我打算从顺序栈开始着手，本以为代码过程会比较顺利，没想到还是遇到了好多问...
数据结构 顺序栈
qq_52748953的博客
09-27 261
#include <stdio.h> #include <stdlib.h> #include <string.h> #define MAXSIZE 10 typedef int ElemType; typedef struct{ ElemType data[MAXSIZE]; int top;//栈顶指针，-1表示空栈，maxsize-1表示满栈 }SeqStack,*PSeqStack; // 顺序栈SS的初始化操作。 void Init
C语言实现：顺序栈与链栈操作详解
"数据结构课程涵盖了顺序栈和链栈的实现，主要使用C语言进行编程。顺序栈是基于一组连续存储单元实现的栈，而链栈则是通过链式存储结构来实现。这两种栈都支持常见栈操作，如初始化、入栈、出栈、取顶、查询栈长和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值