数据结构——链表实现栈和队列

利用链表实现栈就必须了解栈的入栈和出栈的顺序：先进后出

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define TYPE int

typedef struct Node
{
	TYPE data;
	struct Node* next;
}Node;

typedef struct StackList
{
	Node* top;
	size_t cnt;
}StackList;

// 创建结点
Node* create_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

// 创建栈
StackList* create_stack_list(void)
{
	StackList* stack = malloc(sizeof(StackList));
	stack->top = NULL;
	stack->cnt = 0;
	return stack;
}

// 栈空
bool empty_stack_list(StackList* stack)
{
	return NULL == stack->top;
}

// 出栈
bool pop_stack_list(StackList* stack)
{
	if(empty_stack_list(stack))
		return false;

	Node* temp = stack->top;
	stack->top = temp->next;
	free(temp);
	
	return stack->cnt--;
}

// 销毁栈
void destroy_stack_list(StackList* stack)
{
	while(pop_stack_list(stack));
	free(stack);
}

// 入栈
void push_stack_list(StackList* stack,TYPE data)
{
	Node* node = create_node(data);
	node->next = stack->top;
	stack->top = node;
	stack->cnt++;
}

// 栈顶
TYPE top_stack_list(StackList* stack)
{
	return stack->top->data;
}

// 长度
size_t size_stack_list(StackList* stack)
{
	return stack->cnt;
}

int main(int argc,const char* argv[])
{
	StackList* stack = create_stack_list();
	for(int i=0; i<10; i++)
	{
		push_stack_list(stack,i);
		printf("top:%d cnt:%d\n",top_stack_list(stack),size_stack_list(stack));
	}
	printf("---------------------\n");
	while(!empty_stack_list(stack))
	{
		printf("top:%d cnt:%d\n",top_stack_list(stack),size_stack_list(stack));
		pop_stack_list(stack);
	}
	destroy_stack_list(stack);
}

利用链表实现栈就必须了解队列的入队和出队顺序：先进先出

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define TYPE int

typedef struct Node
{
	TYPE data;
	struct Node* next;
}Node;

Node* create_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

typedef struct QueueList
{
	Node* front;
	Node* rear;
}QueueList;

// 创建队列
QueueList* create_queue_list(void)
{
	QueueList* queue = malloc(sizeof(QueueList));
	queue->front = NULL;
	queue->rear = NULL;
	return queue;
}

bool empty_queue_list(QueueList* queue)
{
	return NULL == queue->front;
}

// 入队
void push_queue_list(QueueList* queue,TYPE data)
{
	Node* node = create_node(data);
	if(empty_queue_list(queue))
	{
		queue->front = node;
		queue->rear = node;
	}
	else
	{
		queue->rear->next = node;
		queue->rear = node;
	}
}

bool pop_queue_list(QueueList* queue)
{
	if(empty_queue_list(queue))
		return false;

	Node* temp = queue->front;
	queue->front = temp->next;
	free(temp);
	return true;
}

TYPE front_queue_list(QueueList* queue)
{
	return queue->front->data;
}

TYPE rear_queue_list(QueueList* queue)
{
	return queue->rear->data;
}

size_t size_queue_list(QueueList* queue)
{
	size_t size = 0;
	for(Node* n=queue->front; NULL!=n; n=n->next,size++);
	return size;
}

void destroy_queue_list(QueueList* queue)
{
	while(pop_queue_list(queue));
	free(queue);
}

int main(int argc,const char* argv[])
{
	QueueList* queue = create_queue_list();
	for(int i=0; i<10; i++)
	{
		push_queue_list(queue,i);
		printf("rear:%d\n",rear_queue_list(queue));
	}
	while(!empty_queue_list(queue))
	{
		printf("front:%d\n",front_queue_list(queue));
		pop_queue_list(queue);
	}
	destroy_queue_list(queue);
}