链表 队列 栈的实现

目录

1.单链表

2.双链表

3.栈

4.队列

---

实现数据结构时需要注意：

1.增加数据时判断空间是否足够，删除数据时判断数据结构是否为空。

2.需要更改一个类型的内容时，函数传参要传递他的地址。比如更改一个int类型的内容，必须传int*,更改int*,则要传递二级指针int**。

1.单链表

结构：包含一个next指针和数据data。

特点：单向不循环不含哨兵位

SLIST.h
#pragma once
typedef int SLDataType;
typedef struct SListNode
{
	SLDataType data;
	struct SListNode* next;
}SLNode;
// 动态申请一个节点
 SLNode* BuySListNode(SLDataType x);
// 单链表打印
void SListPrint(SLNode* plist);
// 单链表尾插
void SListPushBack(SLNode** pplist, SLDataType x);
// 单链表的头插
void SListPushFront(SLNode** pplist, SLDataType x);
// 单链表的尾删
void SListPopBack(SLNode** pplist);
// 单链表头删
void SListPopFront(SLNode** pplist);
// 单链表查找
SLNode* SListFind(SLNode* plist, SLDataType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SLNode* pos, SLDataType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SLNode* pos);
// 在pos的前面插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLDataType x);
// 删除pos位置
void SLTErase(SLNode** pphead, SLNode* pos);
void SLTDestroy(SLNode** pphead);

SLIST.c
#include"SLIST.h"
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
// 动态申请一个节点
SLNode* BuySListNode(SLDataType x)
{
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}
// 单链表打印
void SListPrint(SLNode* plist)
{
	    assert(plist);
		printf("%d ", plist->data);
		while (plist->next != NULL)
		{
			plist = plist->next;
			printf("%d ", plist->data);
		}
	}
// 单链表尾插
void SListPushBack(SLNode** pplist, SLDataType x)
{
	SLNode* next = BuySListNode(x);
	//链表为空
	if (*pplist == NULL)
	{
		*pplist = next;
	}
	//链表不为空
	else
	{
		SLNode* tail = *pplist;
		//找到尾节点
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = next;
	}
}
// 单链表的头插
void SListPushFront(SLNode** pplist, SLDataType x)
{
	SLNode* pcur = *pplist;
	SLNode* head = BuySListNode(x);
	head->next =pcur;
	*pplist = head;
}
// 单链表的尾删
void SListPopBack(SLNode** pplist)
{
	assert(*pplist);
	if ((*pplist)->next == NULL)
	{
		free(*pplist);
		*pplist = NULL;
	}
	else
	{

		SLNode* tail = *pplist;
		//找到尾节点的前一个结点
		while (tail->next->next!= NULL)
		{
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;
	}
}
// 单链表头删
void SListPopFront(SLNode** pplist)
{
	assert(*pplist);
	SLNode* head = *pplist;
	*pplist = head->next;
	free(head);
	head = NULL;
}
// 单链表查找
SLNode* SListFind(SLNode* plist, SLDataType x)
{
	SLNode* pcur =plist;
	while (pcur!= NULL)
	{
		if (pcur->data == x)return pcur;
		else pcur = pcur->next;
	}
	return NULL;
}
// 单链表在pos位置之后插入x
void SListInsertAfter(SLNode* pos, SLDataType x)
{
	assert(pos);
	SLNode* newnode = BuySListNode(x);
	newnode->next = pos->next;
	pos->next = newnode;
}
// 单链表删除pos位置之后的值
void SListEraseAfter(SLNode* pos)
{
	assert(pos);
	SLNode* next = pos->next->next;
	free(pos->next);
	pos->next = next;
}

// 在pos的前面插入
void SLTInsert(SLNode** pphead, SLNode* pos, SLDataType x)
{
	assert(pos);
	//pos为链表首元素
	SLNode* newnode = BuySListNode(x);
	SLNode* pcur = *pphead;
	if (pcur == pos)
	{
		newnode->next = pos;
		*pphead = newnode;
	}
	else
	{
		while (pcur->next != pos)
		{
			pcur = pcur->next;
		}
		pcur->next = newnode;
		newnode->next = pos;
	}
}
// 删除pos位置
void SLTErase(SLNode** pphead, SLNode* pos)
{
	SLNode* pcur = *pphead;
		while (pcur->next != pos)
		{
			pcur = pcur->next;
		}
		pcur->next = pos->next;
		free(pos);
		pos = NULL;
}
void SLTDestroy(SLNode** pphead)
{
	assert(pphead&&*pphead);
	SLNode*pcur=*pphead;
    while(pcur)
    {
        SLNode*next=pcur->next;
        free(pcur);
        pcur=next;
    }
    *pphead=NULL;
}

2.双链表

结构：包含两个指针next和prev以及数据data

特点：含哨兵位，双向循环

注意：初始化创建哨兵位时，头节点和尾节点都指向自己。打印链表时从phead->next开始打印。

list.h
#pragma once
typedef int SLTDataType;
typedef struct ListNode
{
	SLTDataType data;
	struct ListNode* next;
	struct ListNode* prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, SLTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, SLTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, SLTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, SLTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

list.c
#include"list.h"
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>

ListNode* BuyNode(SLTDataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = x;
	newnode->prev=newnode->next = NULL;
	return newnode;
}
// 创建返回链表的头结点.
ListNode* ListCreate()
{
	ListNode* phead = BuyNode(-1);
	phead->prev = phead->next = phead;
	return phead;
}
// 双向链表销毁
void ListDestory(ListNode* pHead)
{
	ListNode* pcur = pHead;
	while (pcur)
	{
		ListNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(pHead);
	pHead = NULL;
}
// 双向链表打印
void ListPrint(ListNode* pHead)
{
	assert(pHead);
	ListNode* pcur = pHead->next;
	while (pcur!=pHead)
	{
		printf("%d ", pcur->data);
		pcur = pcur->next;
	}
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, SLTDataType x)
{
	ListNode* newnode = BuyNode(x);
	newnode->prev = pHead->prev;
	newnode->next = pHead;
	pHead->prev->next = newnode;
	pHead->prev = newnode;
}
// 双向链表尾删
void ListPopBack(ListNode* pHead)
{
	assert(pHead&&pHead->next!=pHead);
	ListNode* tail = pHead->prev;
	tail->prev->next = pHead;
	pHead->prev = tail->prev;
	free(tail);
	tail = NULL;
}
// 双向链表头插
void ListPushFront(ListNode* pHead, SLTDataType x)
{
	assert(pHead);
	ListNode* newnode = BuyNode(x);
	newnode->prev = pHead;
	newnode->next = pHead->next;
	pHead->next = newnode;
	pHead->prev->prev = newnode;
}
// 双向链表头删
void ListPopFront(ListNode* pHead)
{
	assert(pHead && pHead->next != pHead);
	ListNode* head = pHead->next;
	pHead->next = head->next;
	head->next->prev = pHead;
	free(head);
	head = NULL;
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, SLTDataType x)
{
	assert(pHead && pHead->next != pHead);
	ListNode* pcur = pHead->next;
	while (pcur != pHead)
	{
		if (pcur->data == x)return pcur;
		pcur = pcur->next;
	}
	return NULL;
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, SLTDataType x)
{
	assert(pos);
	ListNode* newnode = BuyNode(x);
	newnode->prev = pos->prev;
	newnode->next = pos;
	pos->prev->next = newnode;
	pos->prev = newnode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
	assert(pos);
	pos->prev->next = pos->next;
	pos->next->prev = pos->prev;
	free(pos);
	pos = NULL;
}

3.栈

结构：含一个数组，一个top（若top为0记录栈顶元素的下一位置，top为-1记录的是栈顶元素的位置），一个capacity记录数组的大小。

特点：后入先出

注意：空间不够时realloc数组，最好扩大原来容量的2-3倍。

stack.h
#pragma once
#include<stdbool.h>
// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top; // 栈顶
	int capacity; // 容量
}Stack;
// 初始化栈
void StackInit(Stack* ps);
// 入栈
void StackPush(Stack* ps, STDataType data);
// 出栈
void StackPop(Stack* ps);
// 获取栈顶元素
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0
bool StackEmpty(Stack* ps);
// 销毁栈
void StackDestroy(Stack* ps);

stack.c
#include<stdio.h>
#include<stdlib.h> 
#include<assert.h>
#include<stdbool.h>
#include"stack.h"
void StackInit(Stack* ps)
{ 
	assert(ps);
	ps->a = (STDataType*)malloc(sizeof(STDataType)*4);
	if (ps->a == NULL)
	{
		perror("malloc fail");
		return;
	}
	ps->top =0;//是栈顶元素的下一位置，若为-1则为栈顶元素
	ps->capacity = 4;
}
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);
	//原来数组空间不够
	if (ps->top == ps->capacity)
	{
	    STDataType* tmp=(STDataType*)realloc(ps->a,sizeof(STDataType) * ps->capacity * 2);
		if (tmp== NULL)
		{
			perror("realloc fail");
			return;
		}
		else
		{
			ps->a = tmp;
			ps->capacity = ps->capacity * 2;
		}
	}
	ps->a[ps->top] = data;
	ps->top++;
}
bool StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;
}
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
}
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	return ps->a[ps->top-1];
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

4.队列

结构：存储两个指针head和tail以及队列元素个数，每个指针里面包含一个next指针和数据data.

特点：先进先出

注意：销毁时要遍历队列，释放每一个节点的空间

queue.h
#pragma once
#include<stdbool.h>
// 链式结构：表示队列
typedef int QDataType;
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;
// 队列的结构
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Queue;
// 初始化队列
void QueueInit(Queue* q);
// 队尾入队列
void QueuePush(Queue* q, QDataType data);
// 队头出队列
void QueuePop(Queue* q);
// 获取队列头部元素
QDataType QueueFront(Queue* q);
// 获取队列队尾元素
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
bool QueueEmpty(Queue* q);
// 销毁队列
void QueueDestroy(Queue* q);

queue.c
#include"queue.h"
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
void QueueInit(Queue* q)
{
	assert(q);
	q->head = q->tail = NULL;
	q->size = 0;
}
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}
	newnode->data = data;
	newnode->next = NULL;
	if (q->head==NULL) 
	{
		q->head = q->tail=newnode;
	}
	else {
		q->tail->next = newnode;
		q->tail = newnode;
	}
	q->size++;
}
void QueuePop(Queue* q)
{
	assert(q && q->head);
	//只有一个节点
	if(q->head->next==NULL)
	{
		free(q->head);
		q->head=q->tail = NULL;
	}
	//有多个节点
	else
	{
		QNode* next = q->head->next;
		free(q->head);
		q->head = next;
	}
	q->size--;
}
QDataType QueueFront(Queue* q)
{
	assert(q);
	assert(!QueueEmpty(q));
	return q->head->data;
}
QDataType QueueBack(Queue* q)
{
	assert(q); 
	assert(!QueueEmpty(q));
    return q->tail->data;
}
int QueueSize(Queue* q)
{
	assert(q);
	return q->size;
}
bool QueueEmpty(Queue* q)
{
	return q->size == 0;
}
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* pcur = q->head;
	while (pcur)
	{
		QNode*next = pcur->next;
		free(pcur);
		pcur = next;
	}
	q->head = q->tail = NULL;
	q->size = 0;
}