栈-----基础操作

栈是限定仅在表尾进行插入和删除操作的线性表。
先进后出、后进先出

栈------可以记录函数的调用关系，
      ------- 四则混合运算 3+5*6运用栈计算结果存在优先级，
      ------gcc在编译时候在文本解析中的时候会用到栈（字符串解析）

栈顶:允许操作的一端
栈底:不允许操作的一端
入栈，出栈。（增加删除）

顺序栈（数组）， 链式栈
30+2\5
1.创建  ------- CreateSeqStack
2.销毁  ------- DestroySeqStack
3.判断是否为空栈 ------ IsEmptySeqStack
4.判断是否为满栈 -------- IsFullSeqStack
5.压栈 -------- PushSeqStack
6.出栈 ---------PopSeqStack

两个栈的区别（数据结构中的与进程中的）

1. 数据结构中的栈（Stack）

   • 栈是一种基本的线性数据结构，它遵循后进先出（LIFO, Last In First Out）的原则存储和操作数据。
   • 栈的操作仅限于栈顶，包括入栈（Push）、出栈（Pop）、查看栈顶元素（Peek/Top）以及判断栈是否为空（IsEmpty）。
   • 栈的容量有限，当元素数量达到上限时，会发生栈溢出。
   • 栈可以通过数组或链表等数据结构实现。

2. 进程中的栈

   • 进程中的栈是操作系统为进程分配的一块内存区域，用于存储函数调用过程中的局部变量、参数、返回地址等信息。
   • 每个进程通常会有两个栈：用户栈和内核栈。用户栈在用户空间使用，内核栈在内核空间使用。
   • 当进程执行函数调用时，相关信息会被压入栈中；函数返回时，这些信息会被弹出栈。
   • 进程栈的大小由操作系统和编译器共同决定，且在运行过程中可能会动态调整

二、作用与特性

1. 数据结构中的栈
   • 主要用于算法实现中，如表达式求值、括号匹配、递归调用等场景。
   • 其简单性和高效性使得栈成为解决特定问题时的首选数据结构。
2. 进程中的栈
   • 主要用于支持函数的调用和返回机制，确保程序能够正确地执行和恢复上下文。
   • 进程栈的大小直接影响到程序能够使用的递归深度和局部变量的数量。
   • 在多任务操作系统中，进程栈还涉及到进程间的隔离和保护。

三、实现方式

1. 数据结构中的栈
   • 可以通过数组或链表等数据结构来实现。
   • 数组实现的栈需要预先分配固定大小的存储空间，而链表实现的栈则具有更高的灵活性。
2. 进程中的栈
   • 由操作系统在进程创建时自动分配和管理。
   • 进程栈的大小和增长策略通常由操作系统和编译器共同决定。
   • 在某些情况下，操作系统允许用户通过系统调用或配置文件来调整进程栈的大小。

四、总结

       数据结构中的栈是一种抽象的数据结构，用于解决特定问题；而进程中的栈则是操作系统为进程分配的一块内存区域，用于支持函数的调用和返回机制。两者在概念、作用、特性及实现方式上均存在显著差异。理解这些差异有助于更好地应用栈这一数据结构并深入理解操作系统的内存管理机制。

---

1）栈的创建

2）入栈 ,top++

3）出栈，top--

4)  空与满

5）栈顶的显示

  6)   销毁

显示

1.实例，实现字符匹配，（{【】}），左括号入栈后括号出站

主函数

#include <stdio.h>
#include "seqstack.h"
#include <string.h>
#include <stdlib.h>
int do_handle(char *linebuf ,SeqStack* ss,int row)
{
    DATATYPE* tmp =NULL;
    DATATYPE data;
    bzero(&data,sizeof(data));
    int col = 1;
    while(*linebuf)
    {
        char c = *linebuf;
        switch (c)
        {

        case '(':
        case '[':
        case '{':
            data.sym = c;
            data.col = col;
            data.row = row;
            PushSeqStack(ss,&data);
            break;
        case ')':
            tmp = GetTopSeqStack(ss);
            if(NULL != tmp &&'(' == tmp->sym)
            {
                PopSeqStack(ss);
            }
            else
            {
                if(NULL == tmp)
                {
                    fprintf(stderr," ')' error row:%d col:%d \n",row,col);
                }
                else
                {
                fprintf(stderr," ')' error row:%d col:%d or stack top sym:%c row:%d col:%d\n",row,col
                        ,tmp->sym,tmp->row,tmp->col);
                }
                return 1;
            }
            break;


        case ']':
            tmp = GetTopSeqStack(ss);
            if(NULL != tmp &&'[' == tmp->sym)
            {
                PopSeqStack(ss);
            }
            else
            {
                if(NULL == tmp)
                {
                    fprintf(stderr," ']' error row:%d col:%d\n",row,col);
                }
                else
                {
                fprintf(stderr," ']' error row:%d col:%d or stack top sym:%c row:%d col:%d\n",row,col
                        ,tmp->sym,tmp->row,tmp->col);
                }
                return 1;
            }
            break;


        case '}':
            tmp = GetTopSeqStack(ss);
            if(NULL != tmp &&'{' == tmp->sym)
            {
                PopSeqStack(ss);
            }
            else
            {
                if(NULL == tmp)
                {
                    fprintf(stderr," '}' error row:%d col:%d \n",row,col);
                }
                else
                {
                fprintf(stderr," '}' error row:%d col:%d or stack top %c row:%d col:%d\n",row,col
                        ,tmp->sym,tmp->row,tmp->col);
                }
                return 1;
            }
            break;
        }
        linebuf++;
        col++;
    }
    return 0;

}
int main()
{
    SeqStack* ss = CreateSeqStack(100);
    FILE *fp=fopen("/home/linux/1.c","r");
    if(NULL == fp)
    {
        return 1;
    }
    int row =1;
    int flag = 0;
    while(1)
    {
        char buf[1024]={0};
        if(NULL==fgets(buf,sizeof(buf),fp))
        {
            break;
        }
        int ret = do_handle(buf,ss,row);
        if(1 == ret)
        {
            flag =1;
            break;
        }
        row++;
    }
    fclose(fp);
    if(1 == flag)
    {
        DestroySeqStack(ss);
        exit(1);
    }
    if(IsEmptySeqStack(ss))
    {
        printf("file ok\n");
    }
    else
    {
        DATATYPE* tmp = GetTopSeqStack(ss);
        fprintf(stderr,"stack top %c row:%d col:%d\n",tmp->sym,tmp->row,tmp->col);
    }
    DestroySeqStack(ss);
    printf("Hello World!\n");
    return 0;
}

.c文件

include "seqstack.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
SeqStack *CreateSeqStack(int size)
{
    SeqStack* ss = ( SeqStack*)malloc(sizeof(SeqStack));
    if(NULL ==ss)
    {
        perror("CreateSeqStack error malloc1");
        return NULL;
    }
    ss->head = ( DATATYPE*)malloc(sizeof(DATATYPE)*size);
    if(NULL ==ss->head)
    {
        perror("CreateSeqStack error malloc2");
        return NULL;
    }
    ss->tlen = size;
    ss->top =  0;
    return ss;
}

int PushSeqStack(SeqStack *ss, DATATYPE *data)
{
    if(NULL == ss ||NULL ==data)
    {
        fprintf(stderr,"SeqStack or data  is null \n");
        return 1;
    }
    if(IsFullSeqStack(ss))
    {
        fprintf(stderr,"PushSeqStack full\n");
        return 1;
    }

    memcpy(&ss->head[ss->top],data,sizeof(DATATYPE));
    ss->top++;
    return 0;
}

int PopSeqStack(SeqStack *ss)
{
    if(NULL == ss )
    {
        fprintf(stderr,"SeqStack  is null \n");
        return 1;
    }
    if(IsEmptySeqStack(ss))
    {
        fprintf(stderr,"PopSeqStack is empty \n");
        return 1;
    }
    ss->top--;
    return 0;
}

int IsEmptySeqStack(SeqStack *ss)
{
    return 0 == ss->top;
}

int IsFullSeqStack(SeqStack *ss)
{
    return ss->top == ss->tlen;
}

DATATYPE *GetTopSeqStack(SeqStack *ss)
{
    if(IsEmptySeqStack(ss))
    {
        return NULL;
    }
    return &ss->head[ss->top-1];
}

int DestroySeqStack(SeqStack *ss)
{
    free(ss->head);
    free(ss);
    return 0;
}

int GetSizeSeqStack(SeqStack *ss)
{
    return ss->top;
}

.h文件

#ifndef SEQSTACK_H
#define SEQSTACK_H

typedef struct{
   char  sym;
   int col;
   int row;
}DATATYPE;

typedef struct
{
   DATATYPE* head;
   int tlen;
   int top;// clen
}SeqStack;

SeqStack*CreateSeqStack(int size);
int DestroySeqStack(SeqStack*ss);
int PushSeqStack(SeqStack*ss,DATATYPE*data);
int PopSeqStack(SeqStack*ss);
int IsEmptySeqStack(SeqStack*ss);
int IsFullSeqStack(SeqStack*ss);
int GetSizeSeqStack(SeqStack*ss);
DATATYPE*GetTopSeqStack(SeqStack*ss);
#endif // SEQSTACK_H