Explicação detalhada da implementação da cadeia de pilha (Pilha) ---- estrutura linear

A operação de tabela linear de armazenamento linear foi aprendida anteriormente , ou seja, o relacionamento 1 para 1 entre elementos, como a ordem da tabela linear, armazenamento encadeado e representação, é uma manifestação da linearidade entre elementos de dados.

Além das tabelas lineares, as estruturas de dados armazenadas linearmente incluem pilhas e filas, strings, arrays e tabelas generalizadas .

Hoje, compartilho com vocês principalmente uma estrutura de dados muito importante na estrutura de dados, que é ------> pilha

Como entender "pilha"?

As pilhas são amplamente utilizadas em nossas vidas. Por exemplo, os pratos que usamos para cozinhar e cozinhar geralmente precisam ser colocados um a um de baixo para cima quando precisamos colocá-los, e precisamos usá-los de cima para o próximo. Um para tirar para usar.
Também como os carregadores das pistolas que vimos, quando carregamos os carregadores, precisamos pressionar as balas de cima para baixo uma a uma, e quando as balas são disparadas, elas serão ejetadas de baixo para cima uma por one, etc. Espere, a arte vem da vida, haha, existem muitos exemplos de aplicações de pilha na vida, todos podem entender.

Para resumir as características da pilha é o último a entrar primeiro a sair (LIFO) .
Correspondente a isso está a característica first-in-first- out (FIFO) da fila .

Chamamos a operação de adicionar elementos de baixo para cima como ----> operação push
, e chamamos a operação de reduzir elementos de cima para baixo como ----> operação pop

Como a pilha só pode ser operada a partir do topo da pilha , ou seja, a adição e a exclusão só podem ser operadas a partir do topo, também fazemos da pilha uma lista linear com operações limitadas .

Como já existe uma implementação sequencial da pilha no livro , embora seja pseudo-código (na verdade, não é usado para olhar para isso, haha), então implementei a implementação em cadeia da pilha e a forneci para sua referência.

Finalmente, o que eu mesmo adicionei é implementado com a saída de todos os elementos do topo da pilha para o fundo da pilha (usando uma pilha auxiliar) .

Diretório de artigos

Definição da estrutura da pilha de cadeia

Definição de elemento de pilha simples e definição de pilha de cadeia

#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

//定义栈内存储的元素Student 
struct Student{
    
    	
	int id;				//学生id 
	int age;			//学生年龄 
	Student *next;		//指向下一元素的指针 
};


//定义以链式存储的数据栈 
typedef struct Node{
    
    	
	Student *base;		//定义栈底指针，用于指向栈底元素 
	Student *top;		//定义栈顶指针，用于指向栈顶元素, 它们初始化均为NULL 
}*Stack;

Todas as declarações de métodos


int initStack(Stack &stack);						//初始化链表栈 
int clearStack(Stack &stack);						//清空栈内的所有数据 
int destroyStack(Stack &stack);						//销毁链表数据栈 
int stackEmpty(Stack &stack);						//判断链表栈是否为NULL 
int stackLength(Stack &stack);						//获取栈长的函数 
int getStackTop(Stack &stack, Student &student);		//获取栈顶元素 
int pushStack(Stack &stack, Student student);			//压栈操作，将一个元素压入栈中 
int popStack(Stack &stack, Student &student);			//出栈操作，将一个元素弹出栈，并以参数student返回 
void printStack(Stack &stack);						//以栈顶到栈底的形式输出栈内所有元素 
void stackTraverse(Stack &stack);					//以栈底到栈顶的形式输出栈内所有元素

Inicializar operações de pilha

inicialização da pilha


//数据结构----初始化链式数据栈操作 
int initStack(Stack &stack)
{
    
    
	stack = (Node *)malloc(sizeof(Node));			//使用malloc函数动态为数据栈开辟空间 
	stack->base = NULL;					//栈底指针指向NULL 
	stack->top = NULL;					//栈顶指针指向NULL 
	
	return OK;					//返回建栈成功信息 
}

operação de empurrar

A operação push empurra um elemento de dados para a pilha de acordo com os parâmetros passados pela função


//数据结构----push压栈操作，将一个数据元素压入栈中 
int pushStack(Stack &stack, Student student)
{
    
    
	Student *student1 = (Student *)malloc(sizeof(Student));		//动态开辟一个元素空间 
	
	student1->id = student.id;				//信息收集，获取将压栈元素的id 
	student1->age = student.age;			//获取将压栈元素的age 
	
	if(stack->base == NULL)					//若栈底为NULL时，说明栈内还没有元素 
	{
    
    
		stack->base = student1;			//栈底指向该元素student1 
		stack->top = student1;			//栈顶指向该元素student1 
	}
	else									//否则 
	{
    
    
		stack->top->next = student1; 		//将元素student1压入栈中 
		stack->top = student1;				//栈顶指针指向新元素student1 
	}
	
	stack->top->next = NULL;		//设置下次待压入元素的地址暂为NULL(与链式线性表的增加元素有些许类似) 
	
	return OK;
}

operação pop

Operação pop, pop o elemento superior da pilha e salve as informações pop para retornar por meio de parâmetros de função


//数据结构----出栈操作，将栈顶元素进行弹出 
int popStack(Stack &stack, Student &student)
{
    
    
	Student *p = stack->base, *q;		//定义p指针暂时指向栈底元素 
	
	if(stackEmpty(stack)) return ERROR;		//若栈空则返回失败信息 
	
	if(stack->top == stack->base)		//若栈顶指针和栈底指针指向同一元素，表示栈内仅有一个元素 
	{
    
    
		student = *stack->top;			//以参数的形式保存栈顶元素并返回 
		free(stack->top);			//释放栈顶元素，进行出栈删除 
		stack->base = NULL;				 
		stack->top = NULL;			//栈底、顶指针再次指向NULL，代表暂无任何元素 
		return OK;					//返回成功信息 
	}
	
	while(p->next != stack->top)		//若栈内的元素 >= 2
	p = p->next;					//p指针从栈底循环上挪 ，直到p指向指向栈顶元素之下的元素 
	
	q = stack->top;					//q指针指向栈顶元素					
	student = *q;					//将栈顶元素赋值给参数student待返回 
	stack->top = p;						//栈顶指针下挪 
	stack->top->next = NULL;			//设置下次待压入元素的地址暂为NULL
	
	free(q);						//释放原栈顶指针 
	return OK;							//返回成功信息 
	
}

Imprima todos os elementos de cima para baixo

Use a pilha auxiliar para enviar todos os elementos do topo para a base da pilha


//数据结构----自栈顶至栈底的方式输出所有元素 
void printStack(Stack &stack)
{
    
    
	int i = 0;
	Stack new_stack; 
	initStack(new_stack);		//定义一个新的栈，并且进行初始化 
	
	Student student;			//定义元素变量student 
	printf("自栈顶到栈底的数据元素排列:\n");
	
	
	//stack出栈顺序：			A、B、C、D、E	---->  结果：stack栈空 
	//同时new_stack压栈顺序： 	A、B、C、D、E	---->  结果：new_stack已保存原stack栈 
	 
	while(!(stackEmpty(stack)))		//若原栈不为NULL，重复循环 
	{
    
    
		popStack(stack, student);  				 //出栈操作 
		printf("id = %d, age = %d.\n", student.id, student.age);	//信息输出 
		pushStack(new_stack, student);			 //压栈操作 
		i++;							// 计数器累加 
	}
	printf("共有数据 %d 条.\n\n", i);		   	//输出结果的个数 
	stack = new_stack;							//进行栈复制，原栈已恢复！ 
	return;						//返回 
}

Imprima todos os elementos de baixo para cima


//数据结构----自栈底至栈顶的方式输出所有元素 
void stackTraverse(Stack &stack)
{
    
    
	int i = 0;
	Student *student = stack->base;					//定义随机变量指针student指向栈底元素 
	printf("自栈底到栈顶的数据元素排列:\n");
	while(student != NULL)							//循环遍历输出 
	{
    
    
		printf("id = %d, age = %d.\n", student->id, student->age);
		student = student->next;				//指针随栈进行上挪输出下一元素 
		i++;								//计数器累加 
	}
	printf("共有数据 %d 条.\n\n", i);		//输出累加数据 
	return;
}

Obter o elemento superior da pilha

Obtenha o elemento superior da pilha da cadeia


//数据结构----获取栈顶元素 
int getStackTop(Stack &stack, Student &student)
{
    
    
	if(stack->top != NULL)					//若栈顶元素不为NULL 
	{
    
    
		student = *stack->top;				//将栈顶元素传递给参数变量 
		return OK;				//返回成功信息 
	}
	else return ERROR;			//否则返回失败信息 
}

Obtenha o comprimento da pilha da cadeia


//数据结构----测试栈长函数 
int stackLength(Stack &stack)
{
    
    
	Student *student = stack->base;			//定义随机变量元素指向栈底元素 
	int i = 0;
	while(student != NULL)					//循环遍历统计 
	{
    
    
		student = student->next;			//不断指向栈上层元素 
		i++;					//计数器累加 
	}
	
	return i;					//返回长度 
}

Destrua a pilha, limpe a pilha, julgue a operação vazia da pilha


//数据结构----销毁链式数据栈操作 
int destroyStack(Stack &stack)
{
    
    
	clearStack(stack);			//清空数据栈内的所有元素 
	free(stack);				//释放栈的地址空间内存 
	stack = NULL;				//设置栈指针为NULL，即销毁
	return OK;					//返回成功信息 
}


//数据结构----清理链式数据栈 
int clearStack(Stack &stack)
{
    
    
	Student student;						//定义临时元素变量Student 
	while(stack->base != NULL)				//当栈底指针不为NULL时，循环进行出栈操作 
	popStack(stack,student);			//元素出栈 
	
	if(stack->base == NULL) return OK;		//若栈底已为NULL，返回成功信息 
	else return ERROR;					//否则返回失败信息 
}



//数据结构----判断栈空函数 
int stackEmpty(Stack &stack)
{
    
    
	if(stack->base == NULL && stack->top == NULL)
		return TRUE;						//若栈底指针和栈顶指针指向NULL，返回true 
	else	
		return FALSE;						//否则返回false 
}

Não vou mais escrever o código de teste desses métodos aqui. Os amigos podem se referir e se comunicar sozinhos e progredir juntos. Recentemente, também estou aprendendo matemática avançada e outros cursos. Pode ser um pouco lento para atualizar. Haha, próximo tempo vou preparar a implementação da fila chain. , vamos lá~