数据结构--（栈）总结

已于 2024-01-25 20:23:15 修改
阅读量812 收藏 20
点赞数 19
文章标签： 数据结构
于 2024-01-25 20:22:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50502677/article/details/135852641
版权

目录

1.顺序栈

（1）数据结构

（2）函数列表

1.初始化栈

2.判空

3.出栈

4.入栈

5.返回栈中元素个数

6.返回栈顶元素

7.清空栈

8.销毁栈

9.打印栈

（3）完整代码

（4）运行结果

2.链式栈

（1）数据结构

（2）函数列表

1.初始化栈

2.判空

3.入栈

4.出栈

5.返回栈中元素个数

6.返回栈顶元素

7.清空栈

8.销毁栈

9.打印栈

（3）完整代码

（4）运行结果

1.顺序栈

说明：本篇代码中，顺序栈栈顶指针初始值为 -1，代码中，数组采用的是 int 类型的指针，指向一块通过malloc 开辟的内存空间。也可以通过 Elemtype data[MAXSIZE] 指定。

（1）数据结构
#define MAXSIZE 100
typedef int Elemtype;
typedef struct SqStack
{
	//Elemtype data[MAXSIZE];
	Elemtype* data;	//指向一块内存
	int top;	//栈顶指针
}SqStack;
（2）函数列表
        1.初始化栈
//初始化栈
SqStack* Init_Stack()
{
	/*1.为结构体分配内存*/
	SqStack* Sq = (SqStack*)malloc(sizeof(SqStack));

	/*2.初始化数据指针*/
	Sq->data = (Elemtype*)malloc(sizeof(Elemtype) * MAXSIZE);

	/*3.初始化栈顶指针*/
	Sq->top = -1;

	return Sq;
}
        2.判空

注：判空时需要先判断头节点是否存在，即：判断头节点是否为空，再判断是否有元素。顺序不能反转。因为当头节点未定义时，使用 Sq->top 会造成空指针的引用，引发段错误。

//判断一个栈是否为空
bool Stack_Is_Empty(SqStack* Sq)
{
	/*1.判断头节点是否为空*/
	if (Sq == NULL)
	{
		printf("栈未定义！\n");
		return true;
	}

	/*2.判断是否有元素*/
	if (Sq->top == -1)
	{
		return true;
	}
	return false;
}
        3.出栈
//出栈
bool Pop(SqStack* Sq, Elemtype* d)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return false;
	}

	/*2.出栈*/
	*d = Sq->data[Sq->top--];  // 修正这里的顺序
	return true;
}
        4.入栈

注：元素入栈前，需要先判空，再判断栈是否已经满了，不能颠倒顺序，栈空时可能造成使用空指针的情况。

//入栈
bool Push(SqStack* Sq, Elemtype d)
{
	/*1.判空*/
	if (Sq == NULL)
	{
		printf("栈为空\n");
		return false;
	}

	/*2.判满*/
	if (Sq->top == MAXSIZE - 1)
	{
		printf("栈满,无法入栈！\n");
		return false;
	}

	/*3.入栈*/
	Sq->top += 1;
	Sq->data[Sq->top] = d;  // 修正这里的顺序

	return true;
}
        5.返回栈中元素个数

注：数组下标从 0 开始，栈底默认为 -1 所以元素的个数需要在 top 的基础上 +1

//返回栈的元素个数
int Get_Stack_Length(SqStack* Sq)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return 0;
	}
	return Sq->top + 1;
}
        6.返回栈顶元素
//返回栈顶元素
bool Get_Top(SqStack* Sq, Elemtype* d)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return false;
	}

	*d =  Sq->data[Sq->top];
	return true;
}
        7.清空栈

注：直接重置 top 为 -1 即可，top 作为栈顶指针，元素读取超过 top 都是 "越界" 的情况，不考虑。新的数据会覆盖老的数据，不会造成影响。

//清空一个栈
void Clear_Stack(SqStack* Sq)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return;
	}

	/*2.重置 data 数组*/
	Sq->top = -1;
}
        8.销毁栈

注：data 数组也是通过 malloc 在堆区创建的，需要手动释放，并且先与 Sq 头指针释放，否则先释放了 Sq 头指针，再去释放 data 所指向的内存可能会造成未知结果。因为 Sq 已经被释放，Sq 不一定还存有 data 的地址，或 Sq 已经被置空，造成空指针引用，引发段错误。

//销毁栈
SqStack* Destory_Stack(SqStack* Sq)
{
	/*1.判空*/
	if (Sq == NULL)
		return NULL;

	/*2.释放结点*/
	free(Sq->data);
	Sq->data = NULL;
	free(Sq);
	Sq = NULL;
	return Sq;
}
        9.打印栈

注：栈是先进后出的线性结构，这里通过 for 循环遍历，只是为了验证代码是否准确。

//打印栈
void Print_SqStack(SqStack* Sq)
{
	printf("\n打印栈：\n");
	printf("------------------------\n");
	if (Stack_Is_Empty(Sq))
	{
		printf("栈空！");
	}
	else
	{
		for (int i = 0; i <= Sq->top; i++)
		{
			printf("%d ", Sq->data[i]);
		}
	}
	printf("\n------------------------\n");
}
（3）完整代码
#include<stdio.h>
#include<stdbool.h>

#define MAXSIZE 100
typedef int Elemtype;
typedef struct SqStack
{
	//Elemtype data[MAXSIZE];
	Elemtype* data;	//指向一块内存
	int top;	//栈顶指针
}SqStack;

//初始化栈
SqStack* Init_Stack()
{
	/*1.为结构体分配内存*/
	SqStack* Sq = (SqStack*)malloc(sizeof(SqStack));

	/*2.初始化数据指针*/
	Sq->data = (Elemtype*)malloc(sizeof(Elemtype) * MAXSIZE);

	/*3.初始化栈顶指针*/
	Sq->top = -1;

	return Sq;
}

//判断一个栈是否为空
bool Stack_Is_Empty(SqStack* Sq)
{
	/*1.判断头节点是否为空*/
	if (Sq == NULL)
	{
		printf("栈未定义！\n");
		return true;
	}

	/*2.判断是否有元素*/
	if (Sq->top == -1)
	{
		return true;
	}
	return false;
}

//出栈
bool Pop(SqStack* Sq, Elemtype* d)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return false;
	}

	/*2.出栈*/
	*d = Sq->data[Sq->top--];  // 修正这里的顺序
	return true;
}

//入栈
bool Push(SqStack* Sq, Elemtype d)
{
	/*1.判空*/
	if (Sq == NULL)
	{
		printf("栈为空\n");
		return false;
	}

	/*2.判满*/
	if (Sq->top == MAXSIZE - 1)
	{
		printf("栈满,无法入栈！\n");
		return false;
	}

	/*3.入栈*/
	Sq->top += 1;
	Sq->data[Sq->top] = d;  // 修正这里的顺序

	return true;
}

//返回栈的元素个数
int Get_Stack_Length(SqStack* Sq)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return 0;
	}
	return Sq->top + 1;
}

//返回栈顶元素
bool Get_Top(SqStack* Sq, Elemtype* d)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return false;
	}

	*d =  Sq->data[Sq->top];
	return true;
}

//清空一个栈
void Clear_Stack(SqStack* Sq)
{
	/*1.判空*/
	if (Stack_Is_Empty(Sq))
	{
		printf("栈为空\n");
		return;
	}

	/*2.重置 data 数组*/
	Sq->top = -1;
}

//销毁栈
SqStack* Destory_Stack(SqStack* Sq)
{
	/*1.判空*/
	if (Sq == NULL)
		return NULL;

	/*2.释放结点*/
	free(Sq->data);
	Sq->data = NULL;
	free(Sq);
	Sq = NULL;
	return Sq;
}


//打印栈
void Print_SqStack(SqStack* Sq)
{
	printf("\n打印栈：\n");
	printf("------------------------\n");
	if (Stack_Is_Empty(Sq))
	{
		printf("栈空！");
	}
	else
	{
		for (int i = 0; i <= Sq->top; i++)
		{
			printf("%d ", Sq->data[i]);
		}
	}
	printf("\n------------------------\n");
}

int main()
{
	//创建栈
	SqStack* Sq = Init_Stack();

	//判空
	Stack_Is_Empty(Sq);
	
	//入栈测试
	printf("1 2 3 4 5入栈\n");
	Push(Sq, 1);
	Push(Sq, 2);
	Push(Sq, 3);
	Push(Sq, 4);
	Push(Sq, 5);

	//输出元素个数
	printf("栈中有 %d 个元素\n", Get_Stack_Length(Sq));
	Print_SqStack(Sq);

	//获取栈顶元素
	Elemtype data;
	Get_Top(Sq, &data);
	printf("栈顶元素为：%d", data);

	//出栈
	printf("\n\n出栈两个元素\n");
	Pop(Sq, &data);
	printf("出栈:%d\n", data);
	Pop(Sq, &data);
	printf("出栈:%d\n", data);
	Print_SqStack(Sq);

	//获取栈顶元素
	Get_Top(Sq, &data);
	printf("栈顶元素为：%d\n", data);

	//清空栈
	printf("\n清空栈");
	Clear_Stack(Sq);
	//判空
	Stack_Is_Empty(Sq);
	Print_SqStack(Sq);

	//销毁栈
	printf("\n销毁栈");
	Sq = Destory_Stack(Sq);
	Print_SqStack(Sq);
	return 0;
}
（4）运行结果

2.链式栈

（1）数据结构

注：代码使用的是带头节点的双向链表模型作为栈。链表的头结点作为栈底

typedef int Elemtype;
typedef struct Node
{
	Elemtype data;
	struct Node* next;
	struct Node* prev;
}Node;

//头节点做栈顶
typedef struct LinkStack
{
	Node* top;	//指向栈顶
	Node* bottom;	//指向栈底
	int length;	//元素数量
}LinkStack;
（2）函数列表
        1.初始化栈
//初始化一个栈
LinkStack* Init_Stack()
{
	/*1.初始化头节点*/
	LinkStack* Link = (LinkStack*)malloc(sizeof(LinkStack));
	Link->top = NULL;
	Link->bottom = NULL;
    Link->length = 0;;
	return Link;
}
        2.判空
//判断一个栈是否为空
bool Stack_Is_Empty(LinkStack* LS)
{
	if (LS == NULL || LS->bottom == NULL)
	{
		printf("栈空\n");
		return true;
	}
	return false;
}
        3.入栈
//入栈
bool Push(LinkStack* LS,Elemtype d)
{
	/*1.判空*/
    if (LS == NULL)
    {
        printf("栈空！\n");
        return false;
    }
    
    /*2.创建结点*/
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = d;
    newNode->next = NULL;
    newNode->prev = NULL;


    /*3.插入元素*/
    if (LS->top == NULL)
    {   //链表中没有结点
        LS->top = newNode;
        LS->bottom = newNode;
    }
    else
    {   //首结点做栈顶，头插
        LS->top->prev = newNode;
        newNode->next = LS->top;
        LS->top = newNode;
    }
    LS->length++;
    return true;
}
        4.出栈
//出栈
bool Pop(LinkStack* LS, Elemtype *d)
{
    /*1.判空*/
    if (Stack_Is_Empty(LS))
    {
        printf("栈空\n");
        return false;
    }

    /*2.获取结点的值*/
    *d = LS->top->data;

    /*3.出栈、释放空间*/
    Node* p = LS->top;
    LS->top = p->next;

    /*4.判断链表是否还有结点*/
    if(LS->top != NULL)
        LS->top->prev = NULL;
    else
    {
        LS->top = NULL;
        LS->bottom = NULL;
    }

    free(p);
    p = NULL;
    LS->length--;
    return true;
}
        5.返回栈中元素个数
//返回栈的元素个数
int Get_Stack_Length(LinkStack* LS)
{
    if (Stack_Is_Empty(LS))
    {
        printf("空栈\n");
        return 0;
    }
    return LS->length;
}
        6.返回栈顶元素
//返回栈顶元素
void Get_Stack_Top(LinkStack* LS,Elemtype *d)
{
    if (Stack_Is_Empty(LS))
    {
        printf("空栈\n");
        return;
    }
    *d = LS->top->data;
}
        7.清空栈
//清空一个栈
void Clear_Stack(LinkStack* LS)
{
    /*1.判空*/
    if (Stack_Is_Empty(LS))
        return;

    /*2.逐个释放*/
    Node* p = NULL;
    while (LS->top)
    {
        p = LS->top;
        LS->top = p->next;
        free(p);
        p = NULL;
    }

    /*3.更新头节点*/
    LS->bottom = NULL;
    LS->top = NULL;
    LS->length = 0;
}
        8.销毁栈
//销毁一个栈
LinkStack* Destory_Stack(LinkStack* LS)
{
    Clear_Stack(LS);
    if (LS == NULL)
        return LS;
    free(LS);
    LS = NULL;
    return LS;
}
        9.打印栈
//打印栈
void Print_Stack(LinkStack* LS)
{
    printf("\n打印栈\n");
    printf("-------------------\n");
    if (Stack_Is_Empty(LS))
        printf("空栈！");
    else
    {
        Node* p = LS->top;
        while (p)
        {
            printf("%d ", p->data);
            p = p->next;
        }
        /*逆向打印，验证链式栈是否正确链接*/
        printf("\n");
        p = LS->bottom;
        while (p)
        {
            printf("%d ", p->data);
            p = p->prev;
        }
    }
    printf("\n-------------------\n");
}
（3）完整代码
#include<stdio.h>
#include<stdbool.h>

typedef int Elemtype;
typedef struct Node
{
	Elemtype data;
	struct Node* next;
	struct Node* prev;
}Node;

//头节点做栈顶
typedef struct LinkStack
{
	Node* top;	//指向栈顶
	Node* bottom;	//指向栈底
	int length;	//元素数量
}LinkStack;

//初始化一个栈
LinkStack* Init_Stack()
{
	/*1.初始化头节点*/
	LinkStack* Link = (LinkStack*)malloc(sizeof(LinkStack));
	Link->top = NULL;
	Link->bottom = NULL;
    Link->length = 0;;
	return Link;
}

//判断一个栈是否为空
bool Stack_Is_Empty(LinkStack* LS)
{
	if (LS == NULL || LS->bottom == NULL)
	{
		printf("栈空\n");
		return true;
	}
	return false;
}

//入栈
bool Push(LinkStack* LS,Elemtype d)
{
	/*1.判空*/
    if (LS == NULL)
    {
        printf("栈空！\n");
        return false;
    }
    
    /*2.创建结点*/
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = d;
    newNode->next = NULL;
    newNode->prev = NULL;


    /*3.插入元素*/
    if (LS->top == NULL)
    {   //链表中没有结点
        LS->top = newNode;
        LS->bottom = newNode;
    }
    else
    {   //首结点做栈顶，头插
        LS->top->prev = newNode;
        newNode->next = LS->top;
        LS->top = newNode;
    }
    LS->length++;
    return true;
}

//出栈
bool Pop(LinkStack* LS, Elemtype *d)
{
    /*1.判空*/
    if (Stack_Is_Empty(LS))
    {
        printf("栈空\n");
        return false;
    }

    /*2.获取结点的值*/
    *d = LS->top->data;

    /*3.出栈、释放空间*/
    Node* p = LS->top;
    LS->top = p->next;

    /*4.判断链表是否还有结点*/
    if(LS->top != NULL)
        LS->top->prev = NULL;
    else
    {
        LS->top = NULL;
        LS->bottom = NULL;
    }

    free(p);
    p = NULL;
    LS->length--;
    return true;
}

//返回栈的元素个数
int Get_Stack_Length(LinkStack* LS)
{
    if (Stack_Is_Empty(LS))
    {
        printf("空栈\n");
        return 0;
    }
    return LS->length;
}

//返回栈顶元素
void Get_Stack_Top(LinkStack* LS,Elemtype *d)
{
    if (Stack_Is_Empty(LS))
    {
        printf("空栈\n");
        return;
    }
    *d = LS->top->data;
}

//清空一个栈
void Clear_Stack(LinkStack* LS)
{
    /*1.判空*/
    if (Stack_Is_Empty(LS))
        return;

    /*2.逐个释放*/
    Node* p = NULL;
    while (LS->top)
    {
        p = LS->top;
        LS->top = p->next;
        free(p);
        p = NULL;
    }

    /*3.更新头节点*/
    LS->bottom = NULL;
    LS->top = NULL;
    LS->length = 0;
}

//销毁一个栈
LinkStack* Destory_Stack(LinkStack* LS)
{
    Clear_Stack(LS);
    if (LS == NULL)
        return LS;
    free(LS);
    LS = NULL;
    return LS;
}

//打印栈
void Print_Stack(LinkStack* LS)
{
    printf("\n打印栈\n");
    printf("-------------------\n");
    if (Stack_Is_Empty(LS))
        printf("空栈！");
    else
    {
        Node* p = LS->top;
        while (p)
        {
            printf("%d ", p->data);
            p = p->next;
        }
        /*逆向打印，验证链式栈是否正确链接*/
        printf("\n");
        p = LS->bottom;
        while (p)
        {
            printf("%d ", p->data);
            p = p->prev;
        }
    }
    printf("\n-------------------\n");
}

int main() {
    LinkStack* stack = Init_Stack();

    // 测试 Push
    printf("入栈10，20，30，40，50\n");
    for (int i = 1; i <= 5; i++) {
        Push(stack, i * 10);
    }

    // 测试 Get_Stack_Length
    printf("栈的长度：%d\n", Get_Stack_Length(stack));

    // 测试 Get_Stack_Top
    int data;
    Get_Stack_Top(stack,&data);

    // 测试 Print_Stack
    Print_Stack(stack);

    // 测试 Pop
    printf("出栈3个元素\n");
    for (int i = 0; i < 3; i++) {
        Pop(stack,&data);
    }

    // 测试 Pop 后的 Get_Stack_Length
    printf("Pop 后栈的长度：%d\n", Get_Stack_Length(stack));

    // 测试 Pop 后的 Print_Stack
    printf("Pop 后栈的内容：\n");
    Print_Stack(stack);

    // 测试 Clear_Stack
    printf("清空栈\n");
    Clear_Stack(stack);

    // 测试 Clear_Stack 后的 Get_Stack_Length
    printf("Clear_Stack 后栈的长度：%d\n", Get_Stack_Length(stack));
    Print_Stack(stack);

    // 测试 Clear_Stack 后的 Stack_Is_Empty
    if (Stack_Is_Empty(stack)) {
        printf("Clear_Stack 后栈为空。\n");
    }
    else {
        printf("Clear_Stack 后栈不为空。\n");
    }

    // 测试 Destory_Stack
    printf("销毁栈\n");
    stack = Destory_Stack(stack);
    Print_Stack(stack);

    return 0;
}
（4）运行结果

不想学习的奈何
关注
数据结构——栈知识总结
qq_43215434的博客
11-10 849
一、栈 1、栈的逻辑结构 栈：限定仅在表尾进行插入和删除操作的线性表。 空栈：不含任何数据元素的栈。 允许插入和删除的一端称为栈顶，另一端称为栈底。 栈的操作特性：后进先出。 ADT Stack Data 栈中元素具有相同类型及后进先出特性， 相邻元素具有前驱和后继关系 Operation InitStack 前置条件：栈不存在 ...
栈知识总结
m0_63330233的博客
10-29 338
栈的定义 ·栈(stack)是一个特殊的线性表，是限定仅在一端（通常是表尾)，进行插入和删除操作的线性表。 ·又称为后进先出(Last In First Out)的线性表，简称LIFO结构。 ·栈的逻辑结构与线性表相同，仍为一对一的关系。 栈的相关概念 栈顶和栈底： 入栈和出栈： 入栈：插入元素到栈顶(即表尾)的操作。 ”入“ = 压入 = PUSH(X) 出栈：从栈顶(即表尾)删除...
栈的总结
ABCDEEE123456的博客
12-22 161
栈的特性: 后进先出 两个概念: 栈底、栈顶 两个操作: 入栈、出栈 当栈满的时候，再使用push指令入栈； 当栈空的时候，再使用pop指令出栈； 这两种情况会造成栈顶越界。 转载于:https://www.cnblogs.com/wangchuan-LC/p/10161970.html...
栈总结
Druid的专栏
09-24 266
栈总结 ARM处理器栈 C编译器堆栈分配
数据结构--表、栈、队列（java）
07-29
**栈**是一种特殊的线性数据结构，遵循LIFO（Last In First Out，后进先出）的原则。栈仅允许在栈顶进行插入和删除操作。 ##### 1. 栈的基本概念 - **栈顶**：栈的最上面的元素，是唯一可以进行操作的位置。 - **...
数据结构学习-队列/栈
最新发布
04-28
### 数据结构学习——队列与栈 #### 一、队列的基本概念 队列是一种特殊的线性表，只允许在表的一端进行插入操作，在另一端进行删除操作。这种操作方式使得队列遵循先进先出（FIFO, First In First Out）的原则。...
数据结构-匹配括号（栈）
11-07
数据结构-匹配括号（栈） 本节课程主要讲解了使用栈来实现括号匹配的算法。栈是一种基本的数据结构，它可以用来解决括号匹配问题。 栈的定义 栈是一种后进先出（LIFO）的数据结构，它可以用来存储和检索数据。栈的...
数据结构--栈与队列的应用.doc
05-04
数据结构--栈与队列的应用 栈是一种常用的数据结构，它是一种后进先出的数据结构，即最后入栈的元素最先出栈。栈的应用非常广泛，如解决递归问题、实现深度优先搜索、实现括号匹配等。 在栈的应用中，我们需要设计...
漫话数据结构-顺序栈.pptx
11-03
总结来说，顺序栈是一种基于数组实现的线性数据结构，它的主要特点是后进先出。通过对栈顶指针的有效管理，我们能够实现对栈的常见操作，包括置栈空、判断栈空、取栈顶元素、入栈和出栈。理解和熟练掌握这些操作对于...
【栈】--栈总结
qikaihang的博客
10-26 137
Java中提供了java.util.Stack实现了栈的使用，但是现在官方已经不建议使用了，建议使用java.util.Deque双向队列作为替换Stack。Deque实现的子类有LinkedList（基于链表）和ArrayDeque（基于数组），下图为继承关系 Deque的含义是“double ended queue”，即双端队列，它既可以当作栈使用，也可以当作队列使用。下表列出了Deque与Queue相对应的接口： 下表列出了Deque与Stack对应的接口： ...
栈总结篇
weixin_33862993的博客
06-29 318
今天想总结一下栈的知识。栈是和线程关联的，每个线程会有一个栈。默认情况下，应用程序的栈是1MB，kernel程序的的栈是256KB。在设置栈的时候有两个参数(/STACK:reserve[,commit]) 其中reserve是栈的最大容量，但线程刚启动的时候，栈并没有那么大，随着需要增长。commit是增长的一个步进。在ring3中，线程相关的信息存储在_TEB块里，位于fs段中。_TEB的最前...
栈的相关总结
Zhongai0049的博客
04-11 1040
栈 最近系统的复习数据结构，并练习力扣上的题目，为了让自己记忆理解的更深刻一点，想在这里整理一下各部分的知识总结。当然如果能帮助到大家就更好了。今天整理的部分是栈，同时还有一些自己的思考。 一.定义与特点： 从数据结构的角度讲： 栈是一种具有一定约束的线性表，它只能在一端进行插入和删除操作，即栈顶。 最大的特点就是先入后出（LIFO:Last in First out）。 常见的操作就是：建立空栈，入栈，出栈。 与之类似可比较的数据结构，有堆和队列。 具体比较如下表： 数据结构 栈 队列 堆
关于栈结构的一些总结
richard1230的博客
04-23 436
先看一个demo: 主函数: 进入f函数 f1函数 总结 能使得esp发生变化的指令: 前几天在分析一款软件的时候,发现在分析栈的时候晕圈了,索性今天就总结一波吧: 先看一个demo: void f1(int a, int b, int c) { int d = a + b + c; } int f(int a,int b) { int c...
栈的知识点总结
Lookdrama的博客
11-02 1341
栈(stack)是一个特殊的线性表，是限定仅在一端（通常是表尾)，进行插入和删除操作的线性表。·又称为后进先出(Last In First Out)的线性表，简称LIFO结构。·栈的逻辑结构与线性表相同，仍为一对一的关系。
数据结构之栈的总结01
www_dong的博客
01-20 288
1. 栈的定义 栈(stack)是限定仅在表尾进行插入和删除操作的线性表。 允许插入和删除的一端称为栈顶(top)，另一端称为栈底(bottom)，不含任何数据元素的栈称为空栈。 栈又被称为后进先出(Last in First out)的线性表，简称LIFO结构。 2. 栈的操作 栈的插入操作，称为进栈，也称为压栈、入栈； 栈的删除操作，称为出栈，也叫做弹栈； 3. 栈的定义 typedef int SElemType; typedef struct { SElemType data[M
栈的基础知识总结
qq_43404873的博客
11-05 1640
栈的介绍 栈是一个先入后出的有序列表 栈中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶(Top),另一端为固定的一端，称为栈底(Bottom) 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除 栈的快速入门 用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来存储栈的数据内容 数组模拟栈思路如下 定义一个top来表示栈顶，初始化为-1 入栈的操作，
数据结构——栈的基本总结
weixin_41582192的博客
07-23 7232
最近刷数据结构的黑宝书，顺便将数据结构进行下总结，就先从最熟悉的栈开始吧。 栈(stack)，数据结构中的一种，准确的来说，应该是数据逻辑结构。 栈的基本特点为: 后进先出，就像生活中我们取放盘子，当一摞盘子在桌子上时候，我们总是会取最上边的盘子，同时，我们在放盘子时，也会放在最上面。同样这种机制也在我们浏览网页时也有出现，在我们浏览网页时，左上角的转到上一页就是这种，最近浏览的网站在最上层，...
数据结构-中序遍历算法详解
总结来说，这个课件提供了关于数据结构的概述，特别是中序遍历算法的实现，同时也展示了数据结构课程的整体框架和学习目标。通过学习，学生将能够理解和应用各种数据结构和算法来解决实际问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值