03_线性表应用一：栈

一、什么是栈

一种“先进后出”的数据结构；栈类似一个箱子， 先放进去后拿出来

栈的分类：

1.静态栈 ： 以数组为内核的

2.动态栈 ： 以链表为内核

栈的算法：

出栈、压栈

二、栈的顺序存储

三、栈的链式存储

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
//结点数据类型 
typedef struct Node
{
    int data;
    struct Node* pNext;
}NODE,* PNODE;
//栈数据类型   栈是一个砍掉一部分功能的链表 
typedef struct Stack
{
    PNODE pTop;
    PNODE pBottom;
}STACK,* PSTACK;

void init(PSTACK);
void push(PSTACK pS,int val);
void traverse(PSTACK);
void pop(PSTACK);
bool empty(PSTACK pS);

int main(void)
{
    STACK stack;
    init(&stack);
    push(&stack,1);
    push(&stack,2);
    push(&stack,3);
    push(&stack,4);
    push(&stack,5);
    push(&stack,6);
    traverse(&stack);
    pop(&stack);
}

void init(PSTACK pS)
{
    pS->pTop = (PNODE)malloc(sizeof(NODE));
    if(NULL == pS->pTop)
    {
        printf("动态内存分配失败！");
        exit(-1); 
    }
    pS->pBottom = pS->pTop;
    pS->pTop->pNext = NULL;
}

void push(PSTACK pS,int val)
{
    PNODE pTmp = (PNODE)malloc(sizeof(NODE));
    pTmp->data = val;
    
    pTmp->pNext  = pS->pTop;//把top给新结点 
    pS->pTop = pTmp;//新结点给top指向 
    return;
}

void traverse(PSTACK pS)
{
    PNODE pTmp = pS->pTop; // 定义一个临时结点，永远指向顶点 
    while(pTmp != pS->pBottom) // 终止条件： pTmp != pBottom 
    {
        printf("pTmp->data : %d.
",pTmp->data);
        pTmp = pTmp->pNext; // 往下走 
    }
}
bool empty(PSTACK pS)
{
    if(pS->pTop == pS->pBottom || pS->pTop->pNext == NULL)
    {
        return true;
    }
    return false;
}
void pop(PSTACK pS)
{
    if(empty(pS))
    {
        printf("空栈"); 
        exit(-1);
    }
    while(pS->pTop != pS->pBottom)
    {
        PNODE pTmp = pS->pTop;
        printf("free pTmp->data: %d .
" ,pTmp->data);
        pS->pTop = pTmp->pNext;
        free(pTmp);
        pTmp = NULL;
    }
    return;
}

//清空
void clear(PSTACK pS)
{
    if(empty(pS))
    {
        printf("空栈"); 
        exit(-1);
    }
    PNODE p = pS->pTop;
    PNODE q;
    while(p != pS->pBottom)
    {
        q = p->pNext;
        free(p);
        p = q;
    }
    pS->pTop = pS->pBottom;
}

四、栈的应用一：圆括号匹配

五、栈的应用二：字符串回文判断

六、栈和递归

6.1　　阶乘

6.2　　Fib数列

七、哈诺塔实现

#include <stdio.h>
#include <stdlib.h>

void hanoi(int i,char a,char b,char c); 
int main(void)
{
    char a = 'A';
    char b = 'B';
    char c = 'C'; 
    int i=0;
    printf("请输入盘子的个数：");
    scanf("%d",&i);
    hanoi(i,a,b,c); 
    return 0;
}

void hanoi(int i,char A,char B,char C)
{
    if(i == 1)//如果是1个盘子
    {
        printf("将编号为%d的盘子直接从%c,移到%c
",i,A,C);//    直接将A上的盘子移到C
    }
    else//否则
    {
        
        hanoi(i - 1,A,C,B);//将A上的n-1个盘子借助C移到B
        printf("将编号为%d的盘子直接从%c,移到%c
",i,A,C);//将A上的盘子移到C
        hanoi(i - 1,B,A,C);//最后将B上的n-1个盘子借助A移到C
    }
     
}