数据结构——栈

数据结构2.功能受限的表结构

一、功能受限的表结构

    对表结构的部分功能加以限制，形成特殊的表结构

    栈:

        只有一个进出口的表结构,先进后出,FILO(first in late out)

        顺序栈：

            数据域：

                存储元素的内存首地址

                栈的容量

                栈顶位置

                空增栈(栈顶下标从0开始)  /  满增栈(栈顶下标从-1开始)

            运算：

                运算、销毁、入栈、出栈、栈顶、栈满、栈空       

        #include <stdil.h>

        #include <stdlib.h>

        #include <stdbool.h>
        #define TYPE int

        typedef struct ArrayStack

        {

            TYPE* ptr;  //  存储元素内存首地址

            size_t cal; //  栈的容量

            size_t top; //  栈顶下标 从0开始 空增栈



        }ArrayStack;

       

        //创建

        ArrayStack* create_array_stack(sizeof(size_t cal));

        {

            //  为栈结构分配内存

            ArrayStack* stack = malloc(sizeof(ArrayStack));

            //  分配存储元素的内容

            stack->ptr = malloc(sizeof(TYPE)*cal);

            //  记录栈容量

            stack->cal = cal;

            //  记录栈顶位置，接下来要入栈的位置

            stack->top = 0;

            return stack;



        }

        //销毁

        void destory_array_stack(ArrayStack* stack);

        {

            free(stack->ptr);

            free(stack);




        }

        //栈空

        bool empty_array_stack(ArrayStack* stack);

        {

            return 0 == stack->top;



        }

        //栈满

        bool full_array_stack(ArrayStack* stack);

        {

            return stack->top >= stack->cal;



        }

        //入栈

        bool push_array_stack(ArrayStack* stack,TYPE val);

        {

            if(full_array_stack(stack)) return false;

            stack->ptr[stack->top++] = val;

            return true;



        }

        //出栈

        bool pop_arary_stack(ArrayStack* stack);

        {

            if(empty_array_stack(stack)) return false;

            stack->top--;

            return true;



        }

        //栈顶

        bool top_array_stack(ArrayStack* stack,TYPE* val);

        {

            if(empty_array_stack(stack)) return false;

            *val = stack->ptr[stack->top-1];

            return true;



        }



        int main()

        {

            TYPE top_num = -100;

            ArrayStack* stack = create_array_stack(10);

            for(int i = 0; i<10;i++)

            {

                push_array_stack(stack,i+1);

                top_array_stack(stack,&top_num);

                printf("top:%d\n",top_num);

            }



            while(!empty_array_stack(stack))

            {      

                top_array_stack(stack,&top_num);

                printf("top:%d\n",top_num);

                pop_array_stack(stack);

            }



        }

    栈的应用：

        1.函数的调用、栈内存特点

        2.生产者和消费者模型(仓库->栈)

        3.表达式解析

    栈的常考笔试面试题：

        1.某个序列是一个栈的入栈顺序,判断哪个是正确的出栈顺序

        12345  入栈

        12345  yes

        32145  yes

        31254  no

        有可能边入边出

        2.问题:两个顺序栈,如何能够让空间利用率最高？

        让两个栈相对着入栈

        3.实现一个函数,序列a为入栈顺序,判断序列b是否是序列a的出栈顺序     

  bool is_pop_stack(int a[],int b[],int len)

       {

      //创建一个栈

      ArrayStack* stack = create_array_stack(len);

      //按照a的顺序依此入一个

      for(int i=0,j=0;i<len;i++)

      {

          //按a的顺序一个个入栈

          push_array_stack(stack,a[i]);

          //按b的顺序尝试出栈

          int val = 0;

          while(top_array_stack(stack,&val) && val == b[j])

          {

              pop_array_stack(stack);

             j++;

          }

      }

          //判断栈是否为空

          bool flag =  empty_array_stack(stack);

          destory_array_stack(stack);

          return flag;

       }

    链式栈:

        栈结构数据项:

            栈顶结点

            结点数量

        运算：

            创建、销毁、入栈、出栈、栈满、栈顶

   

 #include <stdio.h>

     #include <stdlib.h>

     #include <stdbool>

     #define TYPE int

     typedef struct Node

     {

        TYPE data;

        struct Node* next;

     }Node;

    //创建结点

    Node* create_node(TYPE data)

    {

        Node* node = malloc(sizeof(Node));

        node->data = data;

        node->next = NULL;

        return node;

    }



    //设计链式栈结构

    typedef struct ListStack

    {

        Node* top;    // 栈顶结点

        size_t cnt;   // 结点数量



    }ListStack;

    //创建栈结构

    ListStack* create_list_stack(void)

    {

        ListStack* stack = malloc(sizeof(ListStack));

        stack->top = NULL;

        stack->cnt = 0;

        return stack;

    }

    //入栈

    void push_list_stack(ListStack* stack,TYPE val)

    {

            Node* node = create_node(val);

            node->next = stack->top;

            stack->top = node;

            stack->cnt++;

    }

    //栈顶

    TYPE top_list_stack(ListStack* stack)

    {

        return stack->top->data;



    }

    //栈空

    bool empty_list_stack(ListStack* stack)

    {

        if(stack->cnt == 0)

        return true;

        else

        return false;



    }

    //出栈

    bool pop_list_stack(ListStack* stack)

    {

        if(empty_list_stack(stack))

        return false;

        else

        {

            Node* temp = stack->top;

            stack->top = temp->next;

            free(temp);

            stack->cnt--;

            return true;

        }

    }

    //数量    保持数据结构的封装性不被打破

    size_t size_list_stack(ListStack* stack)

    {

        return stack->cnt;

    }

    //销毁栈

    void destory_list_stack(ListStack* stack)

    {

        //把所有结点释放

        while(pop_list_stack(stack));

        //释放栈结构

        free(stack);

    }



     int main()

     {

        ListStack* stack = create_list_stack();

        for(int i = 0 ;i<10;i++)

        {

            push_list_stack(stack,i+1);

            printf("top:%d\n size:%d\n",top_list_stack(stack),size_list_stack(stack));

        }

        while(empty_list_stack(stack))

        {

            printf("top:%d size:%d\n",top_list_stack(stack),size_list_stack(stack));

            pop_list_stack(stack);

        }

        destory_list_stack(stack);

     }