栈的链式实现（C语言描述）

来源：互联网发布：农行总行待遇知乎编辑：程序博客网时间：2024/05/23 01:50

原文地址：http://blog.csdn.net/lpp0900320123/article/details/20615529 http://blog.csdn.net/ns_code/article/details/11358347

栈本质上是一个线性表，只不过对线性表的操作进行了限制，只可以在表的一端进行操作（插入、删除元素）。栈是一种是一种实现数据“先进后出”的存储结构，分为静态栈和动态栈，静态栈就是以数组的方式存储数据，动态栈是以链表的方式存储数据；对栈的操作算法，常用的就是压栈和出；下面将以链式的方式创建栈，并对用c语言实现栈的压栈和出栈的算法：

1.栈的创建

在创建一个数据结构之前，必须知道这种数据结构由哪些参数组成，栈的本质既然是个链表，它必然由很多节点组成；为了实现“先进后出”这种数据结构，我们需要引进两个参数，一个是栈顶指针（pTop），始终指向栈顶元素。一个参数是栈底指针（pBottom），始终指向栈底元素。我们知道为了方便描述链表的各种操作，引进了头节点的概念，即为每个链表前面加一个头节点，但并存放有效数据；同样，为了实现栈的操作，我们同样需要一个不存放任何有效数据的节点，并且栈底指针始终指向该节点；

[cpp] view plaincopy
typedef int elementype;  
//定义一个节点  
typedef struct Node  
{  
    elementype data;  
    struct Node *pNext;  
}NODE,*PNODE;//  
//构造一个栈  
typedef struct stack  
{  
    PNODE pTop; //栈顶指针  
    PNODE pBottom;//栈底指针  
}STACK,*PSTACK;  

其中，使用了typedef关键词，typedef只是给一个数据类型提供一个别名；因此这里的NODE=struct Node ，PNODE=struct Node *；同样，STACK=struct stack ，PSTACK=struct Node *;

此时，数据类型构造出来了，接下来要创建一个空栈，这样我们才能进行栈的操作，创建栈，无非就是分配内存，内存分配有三种方式，静态存储区，栈，堆；

[cpp] view plaincopy
//创建一个空栈，里面没有任何有效数据；  
void Create_Stack(PSTACK S)  
{  
    S->pBottom=(struct Node *)malloc(sizeof(struct Node));  
    if(NULL==S->pBottom)  
    {  
        printf("Memory allocation failure");  
        exit(-1);  
    }  
    S->pTop=S->pBottom;  
    S->pTop->data=0;  
    S->pTop->pNext=NULL;  //防止出现野指针  
}  

图1 空栈示意图

2.压栈算法

图2 压栈算法示意图

压栈的伪算法：
（1）.创建一个节点p，并修改节点的指针域使其指向栈顶数据元素；p->pNext=pTop；
（2）修改栈顶指针，使其指向栈顶元素，pTop=p；

程序代码：

[cpp] view plaincopy
//进栈  
void Push_Stack(PSTACK S,int val)  
{  
    PNODE p=(struct Node *)malloc(sizeof(struct Node));  
    if(NULL==p)  
    {  
        printf("Memory allocation failure");  
        exit(-1);  
    }  
    p->data=val;  
    p->pNext=S->pTop;  //让p的指针域指向上一个节点  
    S->pTop=p;        //让pTop指针指向栈顶元素  
}  

3.出栈算法

图3.出栈算法示意图

出栈伪算法：
（1）.先用P指针保存要删除数据的地址，用于便于释放此节点的内存，即p=pTop；
（2）.修改栈顶指针的指向，使其指向栈顶元素；pTop=pTop->pNext;

附录：程序代码

[cpp] view plaincopy
#include<stdio.h>  
#include<stdlib.h>
#include<stdbool.h>
  
  
typedef struct Node  
{  
int data;  
struct Node *pNext;  
}NODE,*PNODE;  
  
  
typedef struct Stack  
{  
PNODE pTop;  
PNODE pBottom;  
}STACK,*PSTACK;  
  
  
PSTACK create_stack();  
void push_stack(PSTACK,int);  
void traverse_stack(PSTACK);  
bool pop_stack(PSTACK,int *);  
bool is_empty(PSTACK);  
void clear_stack(PSTACK);  
  
  
int main()  
{  
int data_pop;  
//创建一个空的栈，pS指针指向该栈  
PSTACK pS = create_stack();  
  
  
//向该栈中压入数据，遍历该栈并输出栈中的数据  
push_stack(pS,2);  
push_stack(pS,6);  
push_stack(pS,28);  
traverse_stack(pS);  
  
  
//从该栈中推出数据，遍历该栈并输出栈中的数据  
if(pop_stack(pS,&data_pop))  
  printf("pop succeed,the data poped out is:%d\n",data_pop);  
else   
      printf("pop failed\n");  
traverse_stack(pS);  
//清空栈，遍历该栈并输出栈中的数据  
clear_stack(pS);  
printf("data cleared!\n");  
traverse_stack(pS);  
  
  
return 0;  
}  
  
  
  
  
//创建一个空栈,并返回指向该栈的指针  
  
  
PSTACK create_stack()  
{  
PSTACK pS = (PSTACK)malloc(sizeof(STACK));  
pS->pTop = (PNODE)malloc(sizeof(NODE));  
if(NULL==pS || NULL==pS->pTop)  
{  
  printf("malloc failed");  
  exit(-1);  
}  
else  
{  
  pS->pBottom = pS->pTop;  
  pS->pBottom->pNext = NULL;  
}  
return pS;  
}  
  
  
//判断该栈是否为空  
  
  
bool is_empty(PSTACK pS)  
{  
if(pS->pTop == pS->pBottom)  
  return true;  
    else  
  return false;  
}  
  
  
//向pS指针指向的栈中压入数据val  
void push_stack(PSTACK pS,int val)  
{  
PNODE pNew = (PNODE)malloc(sizeof(NODE));  
if(NULL==pNew)  
{  
  printf("malloc failed");  
  exit(-1);  
}  
else  
{  
  pNew->data = val;  
  pNew->pNext = pS->pTop;  
  pS->pTop = pNew;  
}  
return ;  
}  
  
  
//从栈中推出数据，并将推出的数据保存在pData指针所指向的位置  
bool pop_stack(PSTACK pS,int *pData)  
{  
if(is_empty(pS))  
  return false;  
else  
{  
  PNODE p = pS->pTop;  
  *pData = p->data;  
  pS->pTop = p->pNext;  
  free(p);  
  p = NULL;  
  return true;  
}  
}  
  
  
//遍历栈，并自栈顶向栈底输出栈中的数据  
void traverse_stack(PSTACK pS)  
{  
PNODE pCurrent = pS->pTop;   
printf("Now datas int the stack are:\n");  
while(pCurrent != pS->pBottom)  
        {  
  printf("%d ",pCurrent->data);  
  pCurrent = pCurrent->pNext;  
}  
printf("\n");  
return ;  
}  
  
  
//清空栈，即将其还原为空栈  
void clear_stack(PSTACK pS)  
{  
  if(is_empty(pS))  
    return ;  
  PNODE p = NULL;  
  while(pS->pTop != pS->pBottom)  
  {  
     p = pS->pTop;
     pS->pTop = p->pNext;
     free(p);  
       p = NULL;
  }  
}  

0 0