标签：必须   double   push   出栈   head   front   入栈   int   存在   

堆和栈

Stack(栈)

栈的结构：

下面是数据结构的集中类型：

struct stu   //链表
{
    int data;  //抽象出的一种数据

    struct stu *pnext;   //链表的指针
};

struct    //顺序表
{
    int data[100];

    int size;    //顺序表大小标志
};

struct  //顺序结构的栈
{
    int data[100];

    int top;    //栈顶标志
};

顺序结构的栈：

#include <stdio.h>

#define MAXSIZE 100

typedef struct  //顺序结构的栈
{
    int data[MAXSIZE];
    int top;    //栈顶标志

}SeqStack;

void StackInit(SeqStack *S);  //初始化
int StackPush(SeqStack *S, int data);//入栈
int StackPop(SeqStack *S,int *data);//出栈

int main()
{
    int data;
    SeqStack myStack;   //定义一个变量

    StackInit(&myStack); //初始化栈

    for (int i = 0; i < 10; i++)
    {
        StackPush(&myStack, i+1);
        printf("%d\t", myStack.data[i]);
    }

    for (int i = 0; i < 10; i++)
    {
        StackPop(&myStack, &data);
        printf("%d\t", data);
    }
    return 0;
}

//初始化
void StackInit(SeqStack *S)
{
    S->top = 0;
}

//入栈
int StackPush(SeqStack *S, int data)
{
    if (S->top >= MAXSIZE)  //判断栈是否满
    {
        printf("栈满！\n");
        return 0;
    }
    else
    {
        S->data[S->top] = data;  //往栈顶加入数据
        S->top++;
        return 1;
    }
}

//出栈  不是要删除  而是得到
int StackPop(SeqStack *S,int *data)
{
    if (S->top <= 0)
    {
        printf("栈空\n");
        return 0;
    }
    else
    {
        S->top--;
        *data = S->data[S->top];
        return 1;
    }
}

//栈顶的元素 出栈判空 入栈判满 *data = S->data[S->top-1];
// 1 2 3 4 5 6 7 8 9 10

链式结构的栈：

//链式栈
#include <stdio.h>

typedef struct node
{
    int data;   
    struct node *pnext;
}LsNode;


void StackInit(LsNode **head);//初始化
void StackPush(LsNode *head, int data);  //入栈
int StackPop(LsNode *head, int *data);  //出栈


int main()
{
    int data;
    LsNode *head;  //在主函数中定义变量的时候，系统根据变量的数据类型开辟大小。int a 4  double b 8
                   //定义指针变量的时候必须用malloc去只指定内存的大小。
    StackInit(&head);

    for (int i = 0; i < 10; i++)
    {
        StackPush(head, i + 1);
    }

    for (int i = 0; i < 10; i++)
    {
        StackPop(head, &data);
        printf("%d\t", data);
    }
    return 0;
}

//初始化
void StackInit(LsNode **head)
{
    *head = (LsNode *)malloc(sizeof(LsNode));
    (*head)->pnext = NULL;  //int =NULL;
}

//入栈
void StackPush(LsNode *head,int data)
{
    LsNode *p;  //从新定义一个节点
    p = (LsNode *)malloc(sizeof(LsNode));  //为新的节点开辟空间
    //malloc 开辟一块内存 并且返回一个空指针类型,空指针类型可以强制转换为任意其他指针类型。
    p->data = data;                         //对新节点的内容填充
    p->pnext = head->pnext;                     //新节点的pnext指向NULL
    head->pnext = p;                        //新节点的地址赋给head->pnext.
}

//出栈
int StackPop(LsNode *head,int *data)
{
    LsNode *p = head->pnext;  //p指向哪里？ 指向第一个元素
    if (NULL == p)
    {
        printf("栈空\n");
        return 0;
    }
    else
    {
        head->pnext = p->pnext;     //让head->pnext指向下一个元素
        *data = p->data;            //得到需要的第一个元素保存在data变量中
        free(p);                    //释放p指向的内存。
        return 1;
    }
}

注意：

循环队列 队列满 头尾重合 队列的大小 size 或者num 或者count计数

Typdef struct
｛
Int data[100];
Int front;
Int end;
Int count;
｝

堆和栈

标签：必须   double   push   出栈   head   front   入栈   int   存在   

原文地址：https://www.cnblogs.com/qzdd/p/12354347.html