数据结构（三）堆栈

- 日理万妓 2022-04-22 07:52 203阅读 0赞

## 堆栈 ##

### 1. 什么是堆栈 ###

堆栈（Stack）：具有一定操作约束的线性表

*  只在一端（栈顶，Top）做插入、删除
 *  插入数据：入栈（Push）
 *  删除数据：出栈（Pop）
 *  后入先出：Last In First Out（LIFO）

### 2. 堆栈的抽象数据类型描述 ###

*  类型名称：堆栈（Stack）
 *  数据对象集：一个有 0 个或多个元素的有穷线性表
 *  操作集：长度为 MaxSize 的堆栈 S ∈ Stack，堆栈元素 item ∈ ElementType
    
    堆栈的基本操作主要有：
    
     *  `Stack CreateStack(int MaxSize)`：生成空堆栈，其最大长度为 MaxSize
     *  `int IsFull(Stack S,int MaxSize)`：判断堆栈 S 是否已满
     *  `void Push(Stack S,ElementType item)`：将元素 item 压入堆栈
     *  `int IsEmpty(Stack S)`：判断堆栈 S 是否为空
     *  `ElementType Pop(Stack S)`：删除并返回栈顶元素

#### 1. 栈的顺序存储实现 ####

栈的顺序存储结构通常由一个一维数组和一个记录栈顶元素位置的变量组成

#include<stdio.h>
    #include<malloc.h> 
    #define MaxSize 100   // 堆栈元素的最大个数 
    typedef int ElementType; // ElementType 暂时定义为 int 类型 
    typedef struct SNode *Stack;
    struct SNode{
        
    	ElementType Data[MaxSize];   // 存储堆栈元素
    	int Top;  // 记录栈顶元素下标 
    }; 
    Stack S;
    
    Stack CreateStack();  // 初始化堆栈 
    int IsFull(Stack S); // 判断堆栈是否已满 
    int IsEmpty(Stack S);   // 判断堆栈是否为空 
    void Push(Stack S,ElementType item);   // 入栈 
    ElementType Pop(Stack S);   // 出栈 
    
    // 初始化堆栈 
    Stack CreateStack(){
        
    	S = (Stack)malloc(sizeof(struct SNode));
    	S->Top = -1;
    	return S;
    } 
    
    // 是否已满 
    int IsFull(Stack S){
        
    	return (S->Top == MaxSize-1);
    }
    
    // 是否为空 
    int IsEmpty(Stack S){
        
    	return (S->Top == -1); 
    } 
    
    // 入栈 
    void Push(Stack S,ElementType item){
        
    	if(IsFull(S)){
           // Top 从 0 开始 
    		printf("堆栈满");
    		return;
    	}else{
        
    		S->Top++;   // 栈顶元素加一 
    		S->Data[S->Top] = item;   // 放进最上 
    		return;
    	}
    }
    
    // 出栈
    ElementType Pop(Stack S){
        
    	if(IsEmpty(S)){
        
    		printf("堆栈空");
    		return;
    	}else{
        
    		ElementType val = S->Data[S->Top];  //取出最上 
    		S->Top--;  // 栈顶元素减一 
    		return val;
    	}
    }
    int main(){
        
    	S = CreateStack();
    	printf("5入栈\n");
    	Push(S,5);
    	printf("7入栈\n");
    	Push(S,7);
    	printf("66入栈\n");
    	Push(S,66);
    	printf("%d出栈\n",Pop(S));
    	printf("%d出栈\n",Pop(S));
    	return 0;
    }

#### 2. 栈的链表存储实现 ####

栈的链式存储结构实际上就是一个单链表，叫做链栈。插入和删除操作只能在链栈的栈顶进行

#include<stdio.h>
    #include<malloc.h>
    typedef int ElementType;
    typedef struct SNode *Stack;
    struct SNode{
        
    	ElementType Data;
    	Stack Next;
    };
    
    
    Stack CreateStack();  // 初始化链栈 
    int IsEmpty(Stack S);  // 判断链栈是否为空 
    void Push(Stack S,ElementType item);  // 入栈 
    ElementType Pop(Stack S);  // 出栈
     
    
    // 初始化 
    Stack CreateStack(){
        
    	Stack S;
    	S = (Stack)malloc(sizeof(struct SNode));
    	S->Next = NULL;
    	return S;
    }
    
    // 判断是否为空 
    int IsEmpty(Stack S){
        
    	return (S->Next == NULL);
    }
    
    // 入栈
    void Push(Stack S,ElementType item){
        
    	Stack tmp;
    	tmp = (Stack)malloc(sizeof(struct SNode));
    	tmp->Data = item;
    	// 链栈栈顶元素是链表头结点，新入栈的链表在栈顶元素后面 
    	tmp->Next = S->Next;   
    	S->Next = tmp;
    } 
    
    // 出栈
    ElementType Pop(Stack S){
        
    	Stack First;
    	ElementType TopVal;
    	if(IsEmpty(S)){
        
    		printf("堆栈空");
    		return;
    	}else{
        
    		First = S->Next;   // 出栈第一个元素在栈顶元素后面 
    		S->Next = First->Next;  //把第一个元素从链栈删除 
    		TopVal = First->Data;   // 取出被删除结点的值 
    		free(First);  // 释放空间 
    		return TopVal;
    	}
    } 
    
    int main(){
        
    	Stack S;
    	S = CreateStack();
    	printf("5入栈\n");
    	Push(S,5);
    	printf("7入栈\n");
    	Push(S,7);
    	printf("66入栈\n");
    	Push(S,66);
    	printf("%d出栈\n",Pop(S));
    	printf("%d出栈\n",Pop(S));
    	return 0;
    }