用数组实现栈结构

程序的基本结构

包含的文件有:

common.h —— 一般的头文件,包含了常用的头文件,状态

c3-1.h —— 包含了基本操作的原型,类型定义

bo3-1.c —— 基本操作的实现

main3-1.c —— 测试各种操作

common.h中的内容

 1 /* common.h (file name) */
 2 #include<string.h>
 3 #include<ctype.h>
 4 #include<malloc.h>
 5 #include<limits.h>
 6 #include<stdio.h>
 7 #include<stdlib.h>
 8 #include<math.h>
 9 /* function result status code */
10 #define TRUE 1
11 #define FALSE 0
12 #define OK 1
13 #define ERROR 0
14 #define INFEASIBLE -1
15
16 typedef int Status; /* function result status code, such as OK */
17 typedef int Boolean;  /* Boolean type, the value is TRUE or FALSE */

c3-1.h中的内容

 1 /* c3-1.h 栈顺序存储结构 */
 2
 3 #define STACK_INIT_SIZE 10    /* 存储空间初始分配量 */
 4 #define STACK_INCREMENT 2     /* 存储空间分配增量   */
 5
 6 typedef int SElemType;        /* 定义栈元素的类型   */
 7
 8 struct _SqStack {
 9   SElemType *base;            /* 在栈构造之前和销毁之后, base的值为NULL */
10   SElemType *top;             /* 栈顶指针 */
11   int stacksize;              /* 当前已分配的存储空间, 以元素为单位 */
12 }; /* 顺序栈 */
13
14 typedef struct _SqStack SqStack;
15
16 /* 下面是和栈相关的9个操作 */
17
18 /*
19  * 构造一个空栈, 栈顶和栈底的指针相同,
20  * 初始的长度为STACK_INIT_SIZE, 目前是10个栈元素
21  */
22 void InitStack(SqStack *S);
23
24 /*
25  * 销毁一个已经存在的栈
26  */
27 void DestroyStack(SqStack *S);
28
29 /*
30  * 把栈S置为空, 主要是将栈顶指针设为栈底指针
31  */
32 void ClearStack(SqStack *S);
33
34 /*
35  * 判断栈是不是为空的
36  */
37 Status StackEmpty(SqStack *S);
38
39 /*
40  * 返回S中元素的个数, 也就是栈的长度
41  */
42 int StackLength(SqStack *S);
43
44 /*
45  * 返回栈顶的元素到e中, 但是不删除
46  */
47 Status GetTop(SqStack *S, SElemType *e);
48
49 /*
50  * 向栈中插入元素
51  */
52 void Push(SqStack *S, SElemType e);
53
54 /*
55  * 往栈顶插入一个元素
56  */
57 void Push(SqStack *S, SElemType e);
58
59 /*
60  * 遍历栈的元素
61  */
62 void StackTraverse(SqStack *S, void(*visit)(SElemType));

bo3-1.c中的内容

 1 #include "common.h"
 2 #include "c3-1.h"
 3 /* bo3-1.c 顺序栈(存储结构在c3-1.h中定义)的基本操作(9个) */
 4
 5 void InitStack(SqStack *S) {
 6   /* 构造一个空栈 */
 7   if(!(S->base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType))))
 8     exit(OVERFLOW); /* 存储分配失败 */
 9   S->top = S->base;
10   S->stacksize = STACK_INIT_SIZE;
11 }
12
13
14 void DestroyStack(SqStack *S) {
15   /* 销毁栈S, S不再存在 */
16   free(S->base);
17   /* 除了释放资源还必须将元素置空或者置 */
18   S->base = NULL;
19   S->top = NULL;
20   S->stacksize = 0;
21 }
22
23 void ClearStack(SqStack *S) {
24   /* 把S置为空栈, 并没有释放掉栈的空间, 而是移动栈顶指针为栈底 */
25   S->top = S->base;
26 }
27
28 Status StackEmpty(SqStack *S) {
29   /* 判断栈是不是为空 */
30   if(S->top == S->base)
31     return TRUE;
32   else
33     return FALSE;
34 }
35
36 int StackLength(SqStack *S) {
37   /* 返回栈S中元素的个数, 也就是栈的长度 */
38   return S->top - S->base;
39 }
40
41 Status GetTop(SqStack *S, SElemType *e) {
42   /* 若栈不为空, 则用e返回S的栈顶元素, 并返回OK; 否则返回ERROR */
43   if(S->top > S->base) {
44     *e = *(S->top - 1);
45     return OK;
46   } else {
47     return ERROR;
48   }
49 }
50
51 void Push(SqStack *S, SElemType e) {
52   /* 插入元素e为新的栈顶元素 */
53   if(S->top - S->base >= S->stacksize) {
54     /* 这种情况下栈已经满了 */
55     S->base = (SElemType *)realloc(S->base, (S->stacksize+STACK_INCREMENT) *
56                                    sizeof(SElemType));
57     if(!S->base)
58       exit(OVERFLOW); /* 存储分配失败 */
59     S->top = S->base + S->stacksize;
60     S->stacksize += STACK_INCREMENT;
61   }
62   *(S->top)++ = e;
63 }
64
65 Status Pop(SqStack *S, SElemType *e) {
66   /* 若栈不为空, 则删除栈顶元素, 用e返回其值, 并返回OK */
67   /* 否则返回ERROR */
68   if(S->top == S->base)
69     return ERROR;
70   *e = *--S->top;
71   return OK;
72 }
73
74 void StackTraverse(SqStack *S, void(*visit)(SElemType)) {
75   /* 从栈底到栈顶依次对栈中每个元素调用函数visit() */
76   /* 这里要用一个变量保存栈底元素的指针 */
77   SElemType *p = S->base;
78   while(S->top > S->base)
79     visit(*S->base++);
80
81   S->base = p;
82 }

main3-1.c中的内容

 1 #include "common.h"
 2 #include "c3-1.h"
 3
 4 void print(SElemType c) {
 5   printf("%d ", c);
 6 }
 7
 8 int main(void) {
 9   int j;
10   SqStack s;
11   SElemType e;
12   InitStack(&s);   /* 初始化一个栈 */
13
14   for(j=1; j<=12; j++)
15     Push(&s, j);
16
17   printf("栈中的元素依次为: ");
18   StackTraverse(&s, print);
19   printf("\n");
20
21
22   Pop(&s, &e);
23   printf("弹出的栈顶元素e=%d\n", e);
24
25   printf("栈是否为空: %d(1:空, 0:否)\n", StackEmpty(&s));
26
27   GetTop(&s, &e);  /* 获得栈顶元素, 但是并不弹出栈 */
28   printf("栈顶元素 e=%d 栈的长度为%d\n", e, StackLength(&s));
29
30   ClearStack(&s);
31   printf("清空栈后, 栈是否为空: %d(1:空 0:否)\n", StackEmpty(&s));
32
33   DestroyStack(&s);
34   printf("销毁栈后, s.top=%u, s.base=%u, s.stacksize=%d\n",s.top, s.base, s.stacksize);
35
36   exit(0);
37 }

运行方法和结果显示

时间: 2024-10-27 11:31:33

用数组实现栈结构的相关文章

用数组模拟栈的结构

package datastruct; import java.util.Arrays; /** * 用数组模拟栈的结构:后进先出(LIFO) 线性表结构 * @author stone * 2014-07-29 06:34:49 */ public class SimulateStack<E> { public static void main(String[] args) { SimulateStack<String> ss = new SimulateStack<Str

C语言实现使用静态数组来构造栈结构

在数据结构中,栈是一种很重要的存在.这是一种先进后出的结构,就像一个"死胡同"一样.今天我们先用最简单的方式静态数组来模拟栈.代码上传至 https://github.com/chenyufeng1991/Stack_StaticArray . (1)声明栈的大小,数组,和一个栈顶指针.栈顶指针可以取出栈顶的数据. #define STACK_SIZE 50 static int stack[STACK_SIZE]; static int top_element = -1; (2)压入

日常学习随笔-数组、单链表、双链表三种形式实现栈结构的基本操作

一.栈结构 栈(stack)是限制插入和删除只能在一个位置上的表,该位置是 表的末端,叫做栈的顶(Top).对栈的基本操作有push(进栈),pop(出栈),peak(栈顶元素),size(栈容量)等. 栈的核心思想:"先进后出". 二.案例一:数组实现"栈" 1 package com.xfwl.algorithmAnalysis.stack; 2 3 import java.util.Arrays; 4 5 /** 6 * 自定义栈结构(基于数组的形式) 7 *

php数组实现栈数据结构

tips:今天预习四脚猫的php数据结构,看到这个例子,研究了一下,算是对栈结构有个初步了解. 栈,体现的是后进先出,即LIFO.队列,体现的是先进先出,即FIFO. 栈 array_pop() //尾出 array_push() //尾进 或 array_shift()//头进 array_unshift()//头出 用例:验证一个数学算式是否正确,比如{2*3[x*y+5+m*(i-j)/3]+k*(4+(t+9))}. 分析:对于一个算式的正确与否,就是体现在,各种括号的匹配上,括号完全匹

闭关修炼中 *** Java常用算法之 -- 栈结构

什么是栈结构: 栈结构从数据的运算来分类,栈结构具有特殊的运算规则. 从数据的逻辑结构来看,栈结构其实就是一种线性结构. but!!! 从数据的存储结构来划分,栈结构分为两类: 顺序表结构:即用一组地址连续的内存单元依次保存栈中的数据.在程序中,可以定义一个 指定大小的结构数组来作为栈,序号为0的元素就是栈底,在定义一个top保 存栈顶的序号. 链式栈结构:即使用链式形式保存栈中各元素的值.链表首部(head引用所指向元素)为栈顶, 链表尾部(指向地址为null)为栈底. 栈结构遵循:后进先出(

javascript中的栈结构

1.栈的定义 栈是一种和列表类似的数据结构,可以用它来解决很多的编程问题,栈是一种高效的数据结构,因为数据只能在栈的顶端添加或者删除,所以这样的操作很快而且容易实现. 栈是一种特殊的列表,站内的元素只能拖过列表的一端进行访问,这一端陈伟栈顶.一叠盘子是最常见的栈结构,只能从顶部取盘子,洗好的盘子也只能放在顶端.栈被称为后入先出的数据结构. 由于栈具有后入先出的特点,所以任何不在栈顶的元素都无法访问.为了得到栈底的元素,必须拿掉上面的元素. 对栈的操作有将一个元素压入栈和将一个元素弹出栈.压入栈使

帧栈结构的弊端

过程采用帧栈结构保存局部信息和状态信息,可以实现上下文的转换,局部变量保存等好处,随之带来的是数组越界引用和缓冲区溢出会造成严重的后果.后果可参考 http://www.cnblogs.com/fanzhidongyzby/archive/2013/08/10/3250405.html 解决办法1.栈随机化 http://blog.csdn.net/swordmanwk/article/details/42044775 2.金丝雀检测(栈破坏检测) http://www.ithao123.cn/

栈结构的经典算法题

栈结构 颠倒一个栈的元素顺序 问题:假设有一个栈{1,2,3,4,5,6},6是栈顶,1是栈底,现在要把这个栈中的元素颠倒一下. 思路:最简单的办法当然是把栈中的元素依次pop到一个数组中,然后把这个数组再push回栈里面即可,但这样需要O(n)的辅助空间. 下面介绍一种仅使用O(1)辅助空间的算法,我们知道,可以使用递归来模拟栈的操作.我们借助函数递归pop元素,这样在递归的函数栈上依次有 {6,5,4,3,2,1},1是栈顶,6是栈底,然后在递归返回的时候,如何把当前元素塞到原栈的底部呢?这

Java 模拟栈结构

栈和队列: 通常是作为程序猿的工具,用于辅助构思算法.生命周期较短,执行时才被创建 訪问受限.在特定时刻,仅仅有一个数据可被读取或删除 是一种抽象的结构.内部的实现机制.对用户不可见.比方用数组.链表来实现栈 栈: 同一时候,仅仅同意一个数据被訪问,后进先出 对于入栈和出栈的时间复杂度都为O(1),即不依赖栈内数据项的个数,操作比較快 例,使用数组作为栈的存储结构 public class StackS<T> { private int max; private T[] ary; privat