数据结构和算法（栈和队列）

最新推荐文章于 2022-07-15 10:11:00 发布
最新推荐文章于 2022-07-15 10:11:00 发布
阅读量214 收藏 2
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 数据结构&算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38365430/article/details/91345300
本文详细介绍了栈的数据结构，包括其定义、特点、顺序存储和链式存储方式，以及栈在二进制数转换、逆波兰计算器和中缀表达式转换中的应用。通过具体的代码示例，展示了栈的操作如创建、入栈、出栈、销毁等。

栈的定义：

线性表的一种特殊具体形式，具有后进先出的特点，它要求只在表尾进行删除和插入操作

栈的插入和删除操作

栈的插入操作（Push），叫做进栈

栈的删除操作（Pop），叫做出栈

栈的顺序存储结构：

定义：

typedef struct
{
    ElemType *base;    //指向栈底的指针变量
    ElemType *top;     //指向栈顶的指针变量
    int stackSize;     //栈的当前可使用的最大容量
}sqStack;

创建一个栈：

#define STACK_INIT_SIZE 100

initStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if(!s->base)
    {
        exit(0);
    }
    s->top = s->base;    //最开始，栈顶就是栈底
    s->stackSize = STACK_INIT_SIZE;
}

入栈操作：

#define SATCKINCREMENT 10

Push(sqStack *s, ElemType e)
{
    //如果栈满，追加空间
    if(s->top - s->base >= s->stackSize)
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if(!s->base)
        {
            exit(0);
        }
        s->top = s->base + s->stackSize;                 //设置栈顶
        s->stackSize = s->stackSize + STACKINCREMENT;    //设置栈的最大容量
    }

    *(s->top) = e;
    s->top++;
}

出栈操作：

Pop(sqStack *s, ElemType *e)
{
    if(s->top == s->base)    //栈已空空如也
    {
        return；
    }
    *e = *--(s->top);
}

栈的其他操作

清空一个栈：

ClearStack(sqStack *s)
{
    s->top = s->base;    //数据存在，无法找到
}

销毁一个栈：

DestroyStack(sqStack *s)
{
    int i, len;
    len = s->stackSize;
    for(i=0 ; i<len ; i++)
    {
        free(s->base);
        s->base++;
    }
    s->base = s->top = NULL;
    s->stackSize = 0;
}

计算栈的当前容量：

int StackLen(sqStack s)
{
    return(s.top - s.base);
}

实例：将二进制数转化为十进制数

/*将二进制数转化为十进制数*/

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

#define STACK_INIT_SIZE 20
#define STACKINCREMENT  10

typedef char ElemType;

typedef struct
{
    ElemType *base;
    ElemType *top;
    int stackSize;
}sqStack;

/*初始化栈*/
void InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if( !s->base )
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

/*入栈*/
void Push(sqStack *s, ElemType e)
{
    if( s->top - s->base >= s->stackSize)       //栈满，追加空间
    {
        s->base = (ElemType*)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if(!s->base)
        {
            exit(0);
        }
        s->top = s->base + s->stackSize;                //设置栈顶
        s->stackSize = s->stackSize + STACKINCREMENT;   //设置栈的最大容量
    }

    *(s->top) = e;
    s->top++;
}

/*出栈*/
void Pop(sqStack *s, ElemType *e)
{
    if(s->top == s->base)
    {
        return;
    }

    *e = *--(s->top);
}

/*计算栈的当前容量*/
int StackLen(sqStack s)
{
    return(s.top - s.base);
}

int main(void)
{
    ElemType c;
    sqStack s;
    int len, i, sum = 0;

    InitStack(&s);

    printf("Please enter binary number, enter # to end:\n");
    scanf("%c", &c);
    while( c != '#')
    {
        Push(&s, c);
        scanf("%c", &c);
    }

    getchar();      //在使用char类型时，换行同样是字符，需要从缓冲区去掉

    len = StackLen(s);
    printf("The current capacity of the stack is %d\n", len);

    for(i=0 ; i<len ; i++)
    {
        Pop(&s, &c);
        sum = sum + (c-48) * pow(2, i);
    }

    printf("The result is %d\n", sum);

    return 0;
}

将二进制转化为八进制数（用两个栈）

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

#define STACK_INIT_SIZE 20
#define STACKINCREMENT 10

typedef char ElemType;

typedef struct
{
    ElemType *top;
    ElemType *base;
    int stackSize;
}spStack;

/*初始化栈*/
void InitStack(spStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if( !s->base )
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

/*入栈*/
void Push(spStack *s, ElemType e)
{
    if(s->top - s->base >= s->stackSize)
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));
        if( !s->base )
        {
            exit(0);
        }
        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = e;
    s->top++;
}

/*出栈*/
void Pop(spStack *s, ElemType *e)
{
    if(s->top == s->base)
    {
        return;
    }
    *e = *--(s->top);
}

/*计算栈的当前容量*/
int Stacklen(spStack s)
{
    return (s.top - s.base);
}

int main()
{
    ElemType c;
    spStack s1, s2;
    int len, i, j, sum;

    InitStack(&s1);
    InitStack(&s2);

    printf("Please enter binary number, enter # to end:\n");
    scanf("%c", &c);
    while( c != '#' )
    {

        Push(&s1, c);
        scanf("%c", &c);
    }

    getchar();

    len = Stacklen(s1);
    printf("The current capacity of the stack is %d\n", len);

    for(i=0 ; i<len ; i+=3)
    {
        sum = 0;

        for(j=0 ; j<3 ; j++)
        {
            Pop(&s1, &c);
            sum = sum + (c-48) * pow(2, j);

            if(s1.base == s1.top)
            {
                break;
            }
        }
        Push(&s2, sum+48);
    }

    printf("\nThe octal number of this number is:\n");
    while(s2.base != s2.top)
    {
        Pop(&s2, &c);
        printf("%c", c);
    }
    printf("(O)\n");

    return 0;
}

将二进制转化为十六进制数（用两个栈）

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

#define STACK_INIT_SIZE 20
#define STACKINCREMENT 10

typedef char ElemType;

typedef struct
{
    ElemType *top;
    ElemType *base;
    int stackSize;
}sqStack;

void InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));

    if( !s->base )
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

void Push(sqStack *s, ElemType e)
{
    if(s->top - s->base >= s->stackSize)
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));

        if( !s->base )
        {
            exit(0);
        }

        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = e;
    s->top++;
}

void Pop(sqStack *s, ElemType *e)
{
    if(s->top == s->base)
    {
        return;
    }

    *e = *--(s->top);
}

int StackLen(sqStack s)
{
    return (s.top - s.base);
}

int main(void)
{
    sqStack s1, s2;
    ElemType c;
    int len, i, j, sum;

    InitStack(&s1);
    InitStack(&s2);

    printf("Please enter binary number, enter # to end:\n");
    scanf("%c", &c);

    while(c != '#')
    {
        Push(&s1, c);
        scanf("%c", &c);
    }

    getchar();

    len = StackLen(s1);

    for(i=0 ; i<len ; i+=4)
    {
        sum = 0;
        for(j=0 ; j<4 ; j++)
        {
            Pop(&s1, &c);
            sum = sum + (c-48) * pow(2, j);

            if(s1.top == s1.base)
            {
                break;
            }
        }

        switch(sum)
        {
        case 10:
            sum = 'A';
            break;
        case 11:
            sum = 'B';
            break;
        case 12:
            sum = 'C';
            break;
        case 13:
            sum = 'D';
            break;
        case 14:
            sum = 'E';
            break;
        case 15:
            sum = 'F';
            break;
        default:
            sum = sum + 48;
        }
        Push(&s2, sum);
    }

    printf("\nThe hexadecimal number of this number is:\n");
    while( s2.base != s2.top )
    {
        Pop(&s2, &c);
        printf("%c", c);
    }
    printf("(H)\n");

    return 0;
}

栈的链式存储：

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

#define ERROR 0
#define OK 1

typedef int Status;
typedef int ElemType;


/*栈的链式存储结构*/

typedef struct StackNode
{
    ElemType data;          //存放栈的数据
    struct StackNode *next;
}StackNode, *LinkStackPtr;

typedef struct LinkStack
{
    LinkStackPtr top;       //top指针
    int count;              //栈元素计数器
}

/*进栈操作*/

Status Push(LinkStack *s, ElemType e)
{
    LinkStackPtr p = (LinkStackPtr)malloc(sizeof(StackNode));
    p->data = e;
    p->next = s->top;
    s->top = p;
    s->count++;
    return OK;
}

/*判断是否为空栈*/
Status StackEmpty(LinkStack *s)
{
    if(s->count == 0)
    {
        return OK;
    }
    else
    {
        return ERROR;
    }
}

/*出栈操作*/

Status Pop(LinkStack *s, ElemType *e)
{
    LinkStackPtr p;

    if(StackEmpty(*s))
    {
        return ERROR;
    }

    *e = s->top->data;
    p = s->top;
    s->top = s->top->next;
    free(p);
    s->count--;
    return OK;
}

逆波兰计算器

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

#define STACK_INIT_SIZE 10
#define STACKINCREMENT 10
#define MAXBUFFER 10

typedef double ElemType;

typedef struct
{
    ElemType *base;
    ElemType *top;
    int stackSize;
}sqStack;

/*初始化栈*/
void InitStack(sqStack *s)
{
    s->base = (ElemType *)malloc(STACK_INIT_SIZE * sizeof(ElemType));       //以base指针动态分配10个double类型的内存空间

    if(!s->base)
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

void Push(sqStack *s, ElemType e)
{
    if( s->top - s->base >= s->stackSize )
    {
        s->base = (ElemType *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(ElemType));

        if(!s->base)
        {
            exit(0);
        }

        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = e;
    s->top++;
}

void Pop(sqStack *s, ElemType *e)
{
    if( s->top == s->base )
    {
        return;
    }

    *e = *--(s->top);
}

int StackLen(sqStack s)
{
    return (s.top - s.base);
}

int main(void)
{
    sqStack s;
    char c;
    int i = 0;
    ElemType d, e;
    char str[MAXBUFFER];

    InitStack(&s);

    printf("Please enter a value, each value is separated by a space, and enter # to end:\n");
    scanf("%c", &c);

    while( c != '#')
    {
        while( isdigit(c) || c == '.')
        {
            str[i] = c;
            i++;
            str[i] = '\0';

            if(i >= 10)
            {
                printf("Error: The value entered is too large!\n");
                return -1;
            }

            scanf("%c", &c);
            if( c == ' ' )
            {
                d = atof(str);
                Push(&s, d);
                i = 0;
                break;
            }
        }

        switch( c )
        {
        case '+':
            Pop(&s, &e);
            Pop(&s, &d);
            Push(&s, d+e);
            break;
        case '-':
            Pop(&s, &e);
            Pop(&s, &d);
            Push(&s, d-e);
            break;
        case '*':
            Pop(&s, &e);
            Pop(&s, &d);
            Push(&s, d*e);
            break;
        case '/':
            Pop(&s, &e);
            Pop(&s, &d);
            if( e != 0)
            {
                Push(&s, d/e);
            }
            else
            {
                printf("Error: Divisor is 0!\n");
                return -1;
            }
            break;
        }

        scanf("%c", &c);
    }

    Pop(&s, &d);
    printf("The result is %f\n", d);

    return 0;
}

计算器（包括中缀表达式转换成后缀表达式并进行计算）：

/*主函数*/

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include "calculate.h"
#include "polan.h"

#define MAXBUFFER 50

int main(void)
{
    culStack s;
    Stack r;
    char c, d;
    double e, f;
    char str[MAXBUFFER];
    char strg[MAXBUFFER];
    int i = 0, j = 0;

    CulInitStack(&s);

    printf("Please enter an expression and enter # to end:\n");
    scanf("%c", &c);

    while('#' != c)
    {
        while(isdigit(c) || '.' == c)
        {
            str[i++] = c;
            scanf("%c", &c);
        }

        if(')' == c)
        {
            CulPop(&s, &d);
            while('(' != d)
            {
                str[i++] = ' ';
                str[i++] = d;
                CulPop(&s, &d);
            }
        }
        else if('+' == c || '-' == c)
        {
            if(!CulStackLen(s))
            {
                CulPush(&s, c);
            }
            else
            {
                do
                {
                    CulPop(&s, &d);
                    if('(' == d)
                    {
                        CulPush(&s, d);
                    }
                    else
                    {
                        str[i++] = ' ';
                        str[i++] = d;
                    }
                }while(CulStackLen(s) && '(' != d);
                CulPush(&s, c);
            }
        }
        else if('*' == c || '/' == c || '(' == c)
        {
            CulPush(&s, c);
        }
        else if('#' == c)
        {
            break;
        }
        else
        {
            printf("Error: Illegal input!\n");
        }
        str[i++] = ' ';
        scanf("%c", &c);
    }

    while(CulStackLen(s))
    {
        CulPop(&s, &d);
        str[i++] = ' ';
        str[i++] = d;
    }
    str[i] = '\0';

    i = 0;
    while('\0' != str[i])
    {
        printf("%c", str[i]);
        i++;
    }
    printf("\n");

    InitStack(&r);
    i = 0;

    while('\0' != str[i])
    {
        while(isdigit(str[i]) || '.' == str[i])
        {
            strg[j++] = str[i++];
            strg[j] = '\0';
            if( j >= MAXBUFFER)
            {
                printf("Error: The single data entered is too large!\n");
                return -1;
            }
            if(' ' == str[i])
            {
                e = atof(strg);
                Push(&r, e);
                j = 0;
                i++;
                break;
            }
        }

        switch( str[i] )
        {
        case '+':
            Pop(&r, &f);
            Pop(&r, &e);
            Push(&r, e+f);
            i++;
            break;
        case '-':
            Pop(&r, &f);
            Pop(&r, &e);
            Push(&r, e-f);
            i++;
            break;
        case '*':
            Pop(&r, &f);
            Pop(&r, &e);
            Push(&r, e*f);
            i++;
            break;
        case '/':
            Pop(&r, &f);
            Pop(&r, &e);
            if( f != 0)
            {
                Push(&r, e/f);
                i++;
            }
            else
            {
                printf("Error: Divisor is 0!\n");
                return -1;
            }
            break;
        case ' ':
            i++;
            break;
        default:
            break;
        }
    }

    Pop(&r, &e);
    printf("\nThe final calculation result is: %f\n", e);

    return 0;
}

/*中缀转后缀用栈*/
//#include "calculate.h"
#include <stdio.h>

#define STACK_INIT_SIZE 20
#define STACKINCREMENT 10

typedef struct
{
    char *base;
    char *top;
    int stackSize;
}culStack;

void CulInitStack(culStack *s)
{
    s->base = (char *)malloc(STACK_INIT_SIZE * sizeof(char));

    if(!s->base)
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

void CulPush(culStack *s, char d)
{
    if(s->top - s->base >= s->stackSize)
    {
        s->base = (char *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(char));

        if(!s->base)
        {
            exit(0);
        }

        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = d;
    s->top++;
}

void CulPop(culStack *s, char *d)
{
    if(s->top == s->base)
    {
        return;
    }
    *d = *--(s->top);
}

int CulStackLen(culStack s)
{
    return (s.top - s.base);
}

/*逆波兰计算器用栈*/
//#include "polan.h"
#include <stdio.h>

#define STACK_INIT_SIZE 20
#define STACKINCREMENT 10

typedef struct
{
    double *base;
    double *top;
    int stackSize;
}Stack;

void InitStack(Stack *s)
{
    s->base = (double *)malloc(STACK_INIT_SIZE * sizeof(double));       //以base指针动态分配10个类型的内存空间

    if(!s->base)
    {
        exit(0);
    }

    s->top = s->base;
    s->stackSize = STACK_INIT_SIZE;
}

void Push(Stack *s, double e)
{
    if( s->top - s->base >= s->stackSize )
    {
        s->base = (double *)realloc(s->base, (s->stackSize + STACKINCREMENT) * sizeof(double));

        if(!s->base)
        {
            exit(0);
        }

        s->top = s->base + s->stackSize;
        s->stackSize = s->stackSize + STACKINCREMENT;
    }

    *(s->top) = e;
    s->top++;
}

void Pop(Stack *s, double *e)
{
    if( s->top == s->base )
    {
        return;
    }

    *e = *--(s->top);
}

int StackLen(Stack s)
{
    return (s.top - s.base);
}

队列：只允许在一端进行插入操作，而在另一端进行删除操作的线性表（输入缓冲区）

队列的链式存储结构：

typedef struct QNode
{
    ElemType data;
    struct QNode *next;
}QNode, *QueuePrt;

typedef struct 
{
    QueuePrt front, rear;    //队头、队尾指针
}LinkQueue;

创建一个队列：

1.创建一个头结点

2.将队列的头指针和尾指针都指向生成的头结点

initQueue(LinkQueue *q)
{
    q->front = q->rear = (QueuePtr)malloc(sizeof(QNode));
    if( !q->front )
    {
        exit(0);
    }
    q->front->next = NULL;
}

入队列操作：

InsertQueue(LinkQueue *q, ElemType e)
{
    QueuePtr p;

    p = (QueuePtr)malloc(sizeof(QNode));

    if( p == NULL )
    {
        exit(0);
    }
    p->data = e;
    p->next = q->rear->next;
    q->rear->next = p;
    q->rear = p;
}

出队列操作

void DeleteQueue(LinkQueue *q, ElemType *e)
{
    QueuePtr p;

    if(q->front == q->rear)
    {
        return;
    }
    p = q->front->next;
    *e = p->data;
    q->front->next = p->next;
    if( q->rear == p )
    {
        q->rear = q->front;
    }
    free(p);
}

销毁队列操作

void DestroyQueue(LinkQueue *q)
{
    while( q->front )
    {
        q->rear = q->front->next;
        free(q->front);
        q->front = q->rear;
    }
}

输入字符并使之顺序输出：

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

typedef char ElemType;

typedef struct QNode
{
    ElemType data;
    struct QNode *next;
}QNode, *QueuePtr;

typedef struct
{
    QueuePtr front, rear;    //队首、队尾指针
}LinkQueue;

void InitQueue(LinkQueue *q)
{
    q->front = q->rear = (QueuePtr)malloc(sizeof(QNode));
    if( !q->front )
    {
        exit(0);
    }
    q->rear->next = NULL;
}

void InsertQueue(LinkQueue *q, ElemType e)
{
    QueuePtr p;

    p = (QueuePtr)malloc(sizeof(QNode));

    if( p == NULL )
    {
        exit(0);
    }
    p->data = e;
    p->next = q->rear->next;
    q->rear->next = p;
    q->rear = p;
}

void DeleteQueue(LinkQueue *q, ElemType *e)
{
    QueuePtr p;

    if(q->front == q->rear)
    {
        return;
    }
    p = q->front->next;
    *e = p->data;
    q->front->next = p->next;
    if( q->rear == p )
    {
        q->rear = q->front;
    }
    free(p);
}

void DestroyQueue(LinkQueue *q)
{
    while( q->front )
    {
        q->rear = q->front->next;
        free(q->front);
        q->front = q->rear;
    }
}

void TreverseQueue(LinkQueue *q)
{
    QueuePtr p;

    p = q->front->next;
    printf("\nThe queue:\n");
    while( p->next != NULL )
    {
        printf("%c", p->data);
        p = p->next;
    }
    printf("%c\n", p->data);
}

int main(void)
{
    LinkQueue q;
    int x;
    char c;

    printf("This is a program of a linked queue\n");
    printf("\n1.InitQueue     2.InsertQueue     3.DeleteQueue     4.DestroyQueue    0.exit\n");

    while( 1 )
    {
        printf("Please enter the number to choose the operation:\n");
        scanf("%d", &x);

        switch ( x )
        {
            case 1:
                InitQueue(&q);
                break;
            case 2:
                printf("Please enter the string, and enter # to end:\n");
                fflush(stdin);      //不清除缓存会将enter作为第一个字符录入
                scanf("%c", &c);

                while( '#' != c )
                {
                    InsertQueue(&q, c);
                    scanf("%c", &c);
                }
                TreverseQueue(&q);
                break;
            case 3:
                DeleteQueue(&q, &c);
                printf("The deleted data is %c\n", c);
                TreverseQueue(&q);
                break;
            case 4:
                DestroyQueue(&q);
                /*
                if( !q->front )
                {
                    printf("Operation success!\n");
                }
                else
                {
                    printf("Operation failed!\n");
                }
                */
                break;
            case 0:
                exit(0);
        }
    }
    return 0;
}

队列的顺序存储结构

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

#define QueueSize 20

typedef char ElemType;

typedef struct
{
    ElemType *base;               //用于存放内存分配基地址
    //ElemType qa[QueueSize];       //上述情况的数组存放形式

    int front;
    int rear;
}CycleQueue;

void InitArrayQueue(CycleQueue *q)
{
    q->base = (ElemType *)malloc( QueueSize * sizeof(ElemType));

    if( !q->base )
    {
        exit(0);
    }

    q->front = q->rear = 0;
}

void InsertArrayQueue(CycleQueue *q, ElemType e)
{
    if( q->rear == q->front )
    {
        printf("The queue is full!\n");
        return;
    }

    q->base[q->rear] = e;
    q->rear = (q->rear+1) % QueueSize;
}

void DeleteArrayQueue(CycleQueue *q, ElemType *e)
{
    if( q->front == q->rear )
    {
        printf("The queue is empty!\n");
        return;
    }
    *e = q->base[q->front];
    q->front = (q->front+1) % QueueSize;
}

 

顺序栈，运行的时候一片空白。（含改错
2201_75467393的博客
11-03 90
if(S->top == MAXSIZE - 1){//栈满 也可用top=Stacksize+1判断。//栈顶指针,类似于数组下标。#define MAXSIZE 100 //栈中元素的最大个数。if(S->top==-1){//栈空，无法删除。//编译时有警告，但改了之后错上加错。printf("请输入入栈的元素的值：");//先出栈，指针再减一。} //编译没有错误，但运行页面空白。//出栈,删除栈顶元素。
数据结构学习笔记第五节：栈
y_927的博客
05-16 352
一、栈的定义 栈（stack）是限定仅在表位进行插入和删除操作的线性表。 我们把允许插入和删除的一端称为栈顶（top），另外一端称为栈底（bottom），不含任何元素的栈称为空栈。栈又被称为先进后出的线性表，简称LIFO结构。 理解栈的定义需要注意以下几点： 首先它是一个线性表，也就是说，栈元素具有线性关系，即前驱后继关系。只不过它是一种特殊的线性表而已。定义中说是在线性表的表尾进行插入和删除操作，这里表尾是指栈顶而不是栈底。 栈的特殊之处在于限制了这个线性表的插入和删除的位置，它始终只在栈顶进行
非递归后序周游二叉树
C.
05-09 809
非递归后序周游二叉树
SqStack
gaozigeng的博客
07-15 1279
顺序栈
php标准库 SPL 数据结构之 ---------Splstack(栈)
03-21 717
$stack = new Splstack(); //创建栈对象  $stack->push("11");                  $stack->push(22222222);          $stack->push(3); //压入数据 $stack->shift(); // 删除底部数据
《数据结构与算法分析》课程实验报告二 栈和队列
最新发布
07-06
本实验旨在掌握栈和队列的数据结构实现与应用。实验内容包括： 1)通过顺序存储和链式存储分别实现栈（初始化、入栈、出栈、栈顶元素等操作）和队列（初始化、入队、出队、队头元素等操作）； 2)利用栈实现进制转换...
DataAndAlgorithm_C#数据结构与算法_栈和队列_
09-29
本资源"DataAndAlgorithm_C#数据结构与算法_栈和队列_"专注于这两种基础但关键的数据组织方式：栈和队列，以及它们在C#语言中的实现。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，常被比喻为“堆叠的...
【数据结构与算法】经典练习题解析：涵盖栈队列、树、图及排序算法的基础训练
04-11
内容涉及栈和队列的特点、二叉树结构、图的存储与遍历、排序算法、哈希函数的应用等基础知识。文档还提供了详细的答案解析，帮助读者理解和掌握数据结构的核心概念和算法实现。最后，文档附赠了一些考试技巧，包括...
JS常用的数据结构和算法,链表、栈、队列、排序和查找:octocat
04-03
在这个主题下，我们将深入探讨四种基本的数据结构——链表、栈、队列以及基础的排序和查找算法。这些概念不仅在日常开发中广泛应用，也是面试中常被考察的知识点。 **链表** 链表是一种线性数据结构，与数组不同，...
数据结构与算法栈和队列剖析PPT学习教案.pptx
10-05
数据结构与算法栈和队列剖析PPT学习教案.pptx 本资源摘要信息涵盖了数据结构与算法栈和队列剖析的知识点，以下是详细的知识点解析： 一、递归算法 * 递归的特点：递归是程序设计中最有力的方法之一，递归编出的...
java的for循环取出数据只是拿到最后一个_前端基础：JavaScript深入之内存空间详细图解，栈和堆数据结构...
weixin_39676034的博客
11-22 324
栈数据结构栈的结构就是后进先出(LIFO)，使用乒乓球盒子的结构来解释。处于盒子中最顶层的乒乓球5，它一定是最后被放进去，但可以最先被使用。而我们想要使用底层的乒乓球1，就必须将上面的4个乒乓球取出来，让乒乓球1处于盒子顶层。堆数据结构堆数据结构是一种树状结构。它的存取数据的方式与书架和书非常相似。我们只需要知道书的名字就可以直接取出书了，并不需要把上面的书取出来。JSON格式的数据中，我们存储的...
07.栈(一)栈的存储结构及操作
嵌入式Developer_小J的天空
01-08 1215
一、栈 1.栈(stack)：是限定仅在表尾进行插入和删除操作的线性表。其中，允许插入和删除的一端被称为栈顶(top)，另一端被称为栈底(bottom)，不含任何数据元素的栈被称为空栈。栈又被称为后进先出(Last In First Out)的线性表，简称LIFO结构。     栈的插入操作为进栈，栈的删除操作为出栈。 2.栈的抽象数据类型 ADT 栈(stack) Data
Java基础-堆内存与栈内存
qq_44801116的博客
02-27 397
java把内存划分为两种：栈内存和堆内存，堆和栈都是java用来在Ram中存放数据的地方。 栈内存 堆内存 存放的内容 基本类型的变量、对象的引用、方法的调用 存放所有new出来的对象和数组，分配方式类似于链表 进出原则 先入后出（类似水桶） 向高地址扩展的数据结构，是不连续的内存空间，链表的遍历方向是由低地址向高地址 举例说明 例如main函数中调用test0函数，释放时先释放test0，再释放main ---- 回收机制 当超过变量的作用域后，自动释放栈内存空间 垃圾收集器
堆栈指针寄存器 SP详解以及栈的作用
热门推荐
蓝色鲜橙多的博客
05-06 3万+
本文引用地址：http://www.eepw.com.cn/article/201611/321963.htm 韦东山：https://blog.youkuaiyun.com/thisway_diy/article/details/76422943 堆栈是一种具有“后进先出”（LIFO---Last In First Out）特殊访问属性的存储结构。堆 栈一般使用RAM 物理资源作为存储体，再加上LI...
详解命令-pstack
u014389734的博客
01-07 6974
pstack命令可显示每个进程的栈跟踪。pstack 命令必须由相应进程的属主或 root 运行。可以使用 pstack 来确定进程挂起的位置。此命令允许使用的唯一选项是要检查的进程的 PID。 实例 pstree以树结构显示进程 pstree -p work | grep ad sshd(22669)---bash(22670)---ad_preprocess(
数据结构之顺序栈SqStack
Coolxxx的博客
10-03 1万+
顺序栈SqStack // //by coolxxx //#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include //#include #include #define min
数据结构和算法2（栈和队列）
q1015189243的博客
04-18 514
栈 栈的顺序存储结构 typedef struct { ElemType *base; ElemType *top; int stackSize; }sqStack; base是指向栈底的指针，top是指向栈顶的指针，stackSize是指栈的当前可使用的最大容量。 创建一个栈 ...
掌握栈和队列：实现数据结构基础算法
数据结构作为计算机科学与技术的基础课程之一，是学习计算机专业的重要内容，其中栈（Stack）和队列...掌握栈和队列的算法有助于解决各种实际问题，同时，也为进一步学习更复杂的数据结构和算法打下了坚实的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值