学习记录——day16 操作受限的线性表 链式栈

操作受限的线性表        

1、在之前的内容，无论是顺序表还是链表，都是详细处理的线性表，既可以在端点处进行操作也        可以在中间位置操作

2、现实生活中，有很多并不需要在中间进行操作的序列，只在端点处进行操作，这样的线性表，
      我们称为操作受限的线性表

 3、根据不同的受限情况，线性表分为:栈、队列

4、栈:插入和删除操作都只允许在同一端进行

      队列:插入和删除操作都只允许在异端进行

栈

1、栈的相关概念

        1）栈:操作受限的线性表，插入和删除只能在同一端进行，不能在中间进行相关操作

        2）允许操作的一端，称为栈顶，不允许操作的一端称为栈底

        3）特点；先进后出、后进先出

         4、栈的分类：栈的分类:根据存储方式的不同，分为顺序栈和链式栈

                顺序栈:顺序存储的栈称为顺序栈

                链式栈:链式存储的栈称为链式栈

2、顺序栈

        1）结构体类型

#define MAX 8

typedef int datatype;

typedef struct
{
    datatype *data; //存储站的容器指向堆区空间
    int top; //记录堆区空间栈顶元素的下标
}Stack, *StackPtr;

        2）创建栈

//创建栈
StackPtr stack_create()
{
    StackPtr S = (StackPtr)malloc(sizeof(Stack)*MAX);
    if (NULL == S)
    {
        printf("创建失败\n");
        return NULL;
    }
    
    S->data = (datatype*)malloc(sizeof(datatype)*MAX);
    if (NULL == S->data)
    {
        printf("创建成功\n");
        return NULL;
    }
    
    memset(S->data,0,sizeof(datatype)*MAX);//bzero(S->data,sizeofa(datatype)*MAX)
    S->top = -1;
}

        3）判空

//判空
int stack_empty(StackPtr S)
{
    return S->top == -1;
}

        4）判满

//判满
int stack_full(StackPtr S)
{
    return S->top == MAX-1;
}

        5）入栈

//入栈
int stack_push(StackPtr S,datatype e)
{
    if (NULL == S || stack_full(S))
    {
        printf("入栈失败\n");
        return -1;
    }

    S->top++;
    S->data[S->top] = e;

    printf("入找成功\n");    
    return 0;
}

        6）出栈

//出栈
int stack_pop(StackPtr S)
{
    if (NULL == S || stack_empty(S))
    {
        return -1;
    }

    printf(" %d 出找成功\n",S->data[S->top]);
    S->top--;
    
}

        7）遍历

//遍历
void stack_show(StackPtr S)
{
    if (NULL == S || stack_empty(S))
    {
        return;
    }
    
    printf("栈顶到栈底:\n");
    for (int i = S->top; i >= 0 ; i--)
    {
        printf("%d",S->data[i]);
    }
    putchar(10);
}

        8）获取栈顶元素

//获取栈顶元素
datatype* stack_get_top(StackPtr S)
{
    if (NULL == S || stack_empty(S))
    {
        return NULL;
    }

    return S->data[S->top];
}

        9）求栈的大小

//求栈的大小
int stack_size(StackPtr S)
{
    if (NULL == S)
    {
        return -1;
    }

    return S->top+1;
}

        10）销毁栈

//销毁栈
void stack_destroy(StackPtr S)
{
    if ( S != NULL)
    {
        free(S->data);

        free(S);
        S = NULL;
    }
    
    printf("销毁成功\n");
}

        11）完整代码

00.h

#ifndef DAY16_2_h
#define DAY16_2_h
#include<myhead.h>

#define MAX 8

typedef int datatype;

typedef struct
{
    datatype *data; //存储站的容器指向堆区空间
    int top; //记录堆区空间栈顶元素的下标
}Stack, *StackPtr;

//创建栈
StackPtr stack_create();

//判空
int stack_empty(StackPtr S);

//判满
int stack_full(StackPtr S);

//入栈
int stack_push(StackPtr S,datatype e);

//出栈
int stack_pop(StackPtr S);

//遍历
void stack_show(StackPtr S);

//获取栈顶元素
datatype* stack_get_top(StackPtr S);

//求栈的大小
int stack_size(StackPtr S);

//销毁栈
void stack_destroy(StackPtr S);

#endif // !DAY16_2_h

00.c

#include "00.h"

//创建栈
StackPtr stack_create()
{
    StackPtr S = (StackPtr)malloc(sizeof(Stack));
    if (NULL == S)
    {
        printf("创建失败\n");
        return NULL;
    }
    
    S->data = (datatype*)malloc(sizeof(datatype)*MAX);
    if (NULL == S->data)
    {
        printf("创建成功\n");
        return NULL;
    }
    
    memset(S->data,0,sizeof(datatype)*MAX);//bzero(S->data,sizeofa(datatype)*MAX)
    S->top = -1;
}

//判空
int stack_empty(StackPtr S)
{
    return S->top == -1;
}

//判满
int stack_full(StackPtr S)
{
    return S->top == MAX-1;
}

//入栈
int stack_push(StackPtr S,datatype e)
{
    if (NULL == S || stack_full(S))
    {
        printf("入栈失败\n");
        return -1;
    }

    S->top++;
    S->data[S->top] = e;

    printf("入找成功\n");    
    return 0;
}

//出栈
int stack_pop(StackPtr S)
{
    if (NULL == S || stack_empty(S))
    {
        return -1;
    }

    printf(" %d 出找成功\n",S->data[S->top]);
    S->top--;
    
}

//遍历
void stack_show(StackPtr S)
{
    if (NULL == S || stack_empty(S))
    {
        return;
    }
    
    printf("栈顶到栈底:\n");
    for (int i = S->top; i >= 0 ; i--)
    {
        printf("%d",S->data[i]);
    }
    putchar(10);
}

//获取栈顶元素
datatype* stack_get_top(StackPtr S)
{
    if (NULL == S || stack_empty(S))
    {
        return NULL;
    }

    return S->data[S->top];
}

//求栈的大小
int stack_size(StackPtr S)
{
    if (NULL == S)
    {
        return -1;
    }

    return S->top+1;
}

//销毁栈
void stack_destroy(StackPtr S)
{
    if ( S != NULL)
    {
        free(S->data);

        free(S);
        S = NULL;
    }
    
    printf("销毁成功\n");
}

00main.c

#include "00.h"

int main(int argc, char const *argv[])
{
    StackPtr S = stack_create();
    if (NULL == S)
    {
        return-1;
    }
    
    stack_push(S,1);
    stack_push(S,0);
    stack_push(S,2);
    stack_push(S,4);
    stack_show(S);

    stack_pop(S);
    stack_show(S);

    stack_get_top(S);

    stack_size(S);

    stack_destroy(S);
    return 0;
}

        12)10进制 转 2进制 

#include "00.h"

int main(int argc, char const *argv[])
{
    StackPtr S = stack_create();
    if (NULL == S)
    {
        return-1;
    }
    printf("(0-255)\n");
    printf("输入一个10进制正整数:\n");
    int num = 0;
    scanf("%d",&num);

    while (num)
    {
        int temp = num%2;
        num = num/2;

        stack_push(S,temp);
        // stack_show(S);
    }

    stack_show(S);
    printf("即输入数的二进制数\n");
    

    return 0;
}

        

链式栈

1、链式存储的栈，称为链式栈

2、对于单链表而言，我们可以使用，使用头插头删完成一个栈，或者尾插尾删完成链式栈

3、头插头删:链表的头部就是栈顶，链表的尾部就是栈底(常用)

4、尾插尾删:链表的尾部就是栈顶，链表的头部就是栈底