2.3 Estrutura de dados e pilha de algoritmos

introdução

Mencionei o termo pilha quando falei sobre alocação de memória na linguagem C. Existem dois tipos de memória: memória estática e memória dinâmica.

Entre eles, a memória estática é alocada na pilha, a memória dinâmica é alocada no heap

Um exemplo de código irregular:

#include <stdio.h>
#include <malloc.h>

void f(int k)
{
	int m;
	double * q = (double *)malloc(200);
}

int main(void)
{
	int i = 10;
	int * p = (int *)malloc(100);

	return 0;
}

No código acima, m, q, i e p são memória estática (variáveis ​​locais), que são alocadas na pilha; malloc (100) e malloc (200) são memória dinâmica, que são alocadas na pilha

A memória estática alocada na pilha é alocada automaticamente pelo sistema operacional, enquanto a memória dinâmica alocada na pilha é feita pelo próprio programador

A pilha e o heap aqui representam a maneira de alocar memória, a memória estática é a memória alocada empurrando e removendo a pilha e as variáveis ​​dinâmicas são a memória alocada por classificação de heap

Definição de pilha

Uma pilha é uma estrutura de armazenamento que pode realizar dados do tipo "primeiro a entrar, último a sair"

Uma pilha é semelhante a uma caixa onde as coisas são colocadas, as coisas que são colocadas primeiro são retiradas por último

Classificação de pilhas

Pilha estática: use array como o kernel básico

Pilha dinâmica: O kernel básico é uma lista vinculada, que é a mais usada [na verdade, algumas funções da lista vinculada mencionadas acima foram cortadas]

Algoritmo de empilhamento

Saia da pilha: pop ()

Empurre a pilha: empurre () 

Na verdade, do ponto de vista do algoritmo, esta pilha é muito mais simples do que a lista vinculada e não há nenhuma operação complicada como a pesquisa, mas a pilha pode realizar muitas coisas, vamos esperar para ver

Desempenho intuitivo da pilha

Implementação do código do algoritmo da pilha [Pull + Push]

/*这个栈的构造过程中总共有两个结构体，注意它们的区分*/

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


// 定义节点这个结构体的数据类型
typedef struct Node
{
	int data;
	struct Node * pNext;
}NODE, * PNODE;  //NODE和PNODE数据类型，分别代表struct Node和struct Node *


// 栈本身是通过这个结构体来实现的，类似于链表的头指针（无数据）和尾指针
typedef struct Stack
{
	PNODE pTop;     //指向栈的顶部，相当于尾指针，操作最频繁的位置，不需要首指针
	PNODE pBottom;  //指向栈的底部，相当于头指针
}STACK, * PSTACK;


//函数声明时不一定要写形参，但是需要写形参的数据类型
void init(PSTACK);
void push(PSTACK, int);
void traverse(PSTACK);
bool pop(PSTACK, int *);
bool empty(PSTACK);    //判断栈是否为空
void clear(PSTACK pS);



int main(void)
{
	int val;
	STACK S;  // 等价于 struct Stack S，里面的pTop和pBottom都有了，但是里面放的都是垃圾值，所以还没有形成栈

	init(&S);

	push(&S, -6);
	push(&S, 21);
	push(&S, 34);
	push(&S, -7);
	push(&S, 99);

	if (pop(&S, &val))
		printf("出栈的元素为 %d\n", val);
	
	traverse(&S);

	clear(&S);

	traverse(&S);

	return 0;
}


//初始化，造出一个空栈（pTop和pBottom指向一个不放数据的头结点）这才算构造成功
void init(PSTACK pS)   //传入地址
{
	//下面这两句话等价
	pS->pTop = new NODE;                        //C++方式，新建一个NODE并把地址赋给前面的
	//pS->pTop = (PNODE)malloc(sizeof(NODE));   //C语言方式
	
	if (NULL == pS->pTop)
	{
		printf("动态内存分配失败！\n");
		exit(-1);     //整个程序终止
	}
	else
	{
		pS->pBottom = pS->pTop;
		pS->pBottom->pNext = NULL;   //链表的头结点指针域置空，这一步千万不要忘，否则就不是链表了
	} 
}


//压栈
void push(PSTACK pS, int val)
{
	//第一步：先造一个节点出来
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	//第二步：新节点的数据域赋值，新节点的指针域指向下面节点(其实就是尚未改变的pTop)，注意栈是从上往下指
	pNew->data = val;
	pNew->pNext = pS->pTop;
	//第三步：pTop上移指向新节点
	pS->pTop = pNew;
	return;
}


//遍历输出这个栈
void traverse(PSTACK pS)
{
	PNODE p;
	p = pS->pTop;
	printf("链表自顶向下依次为：\n");
	while (p != pS->pBottom)
	{
		printf("%d\n", p->data);
		p = p->pNext;
	}
	return;
}


//弹出栈内的最后一个元素，并把出栈的元素存入pVal指针所指向的变量中，出栈失败返回false
bool pop(PSTACK pS, int * pVal)
{
	if (empty(pS))
		return false;
	else
	{
		/* 下面这样写其实不好，内存泄漏
		*pVal = pS->pTop->data;
		pS->pTop = pS->pTop->pNext;
		return true;
		*/
		//应该这样写
		PNODE r = pS->pTop;
		*pVal = r->data;
		pS->pTop = r->pNext;
		free(r);
		r = NULL;
		return true;
	}
}

//判断栈是否为空
bool empty(PSTACK pS)
{
	if (pS->pTop == pS->pBottom)
		return true;
	else
		return false;
}


//清空数据，回到初始化状态，但是注意内存泄漏问题，所以不能直接pTop赋值为pBottom
void clear(PSTACK pS)
{
	if (empty(pS))
		return;
	else
	{
		PNODE p = pS->pTop;  //p在上面
		PNODE q = NULL;      //q在p下面，最开始可以是NULL
		
		//这个while循环很重要，可能要背下来了
		while (p != pS->pBottom)
		{
			q = p->pNext;
			free(p);
			p = q;
		}

		pS->pTop = pS->pBottom;
	}
}

A aplicação da pilha [pilha é muito, muito útil]

Chamada de função (fluxo do programa) empurrando e removendo a pilha

Interromper

Escreva uma calculadora: avaliação de expressão (uma pilha para símbolos aritméticos e uma pilha para valores)

Alocação de memória

Carregando

Ande no labirinto (armazene todos os cruzamentos selecionados)