数据结构链表（无头单向非循环链表、带头双向循环链表）

最新推荐文章于 2021-05-22 18:53:26 发布

han_shi_lei

最新推荐文章于 2021-05-22 18:53:26 发布

阅读量528

点赞数 1

本文链接：https://blog.csdn.net/han_shi_lei/article/details/88203376

版权

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。
8种链表结构：
1、单向、双向
在这里插入图片描述
2、带头、不带头

3、单链表、循环链表

以下是两种最常用的链表：
1、无头单向非循环链表

2、带头双向循环链表

无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。
无头单向非循环链表的实现
Slist.h

 #pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLDataType;
//链表中的一个结点
typedef struct SLNode{
	SLDataType value;
	//指向链表中第二个结点的地址
	struct SLNode *next;
}   SLNode;
//一个链表
typedef struct SList{
	//指向链表中第一个结点的地址
	SLNode *first;    //SLNode *head;
}	SList;


//初始化
void SListInit(SList *list);

//销毁
void SlistDestory(SList *list);

//增
//头插
void SListPushFront(SList *list, SLDataType value);
//尾插
void SListPushBack(SList *list, SLDataType value);
//在pos后面插入value
void SListInsertAfter(SLNode *pos, SLDataType value);
//在pos前面插入value
void SListInsertBefore(SList *list, SLNode *pos,SLDataType value);

//删
//头删
void SListPopFront(SList *list);
//尾删
void SListPopBack(SList *list);
//删除 pos 后面的 value
void SListEraseAfter(SLNode *pos);
//改
void SListModify(SLNode * pos, SLDataType value);

//查
//去找到链表中遇到的第一个 value，如果没找到，返回NULL
SLNode * SListFind(const SList *list, SLDataType value);

//打印
void SListPrint(const SList *list);

Slist.c

#include "SList.h"

static SLNode *SListBuyNode(SLDataType value)
{
	SLNode *node = (SLNode*)malloc(sizeof(SLNode));
	assert(node);
	node->value = value;
	node->next = NULL;

	return node;

}
void SListInit(SList *list)
{
	assert(list != NULL);
	list->first = NULL;
}
void SlistDestory(SList *list)
{
	assert(list != NULL);

	SLNode *cur = list->first;
	SLNode *next;
	while (cur != NULL){
		next = cur->next;
		free(cur);
		cur = next;
	}
	list->first = NULL;
}

void SListPushFront(SList *list, SLDataType value)
{
	assert(list != NULL);
	/*SLNode *node = (SLNode *)malloc(sizeof(SLNode));*/
	SLNode *node = SListBuyNode(value);
	assert(node != NULL);
	/*node->value = value;*/
	node->next = list->first;
	list->first = node;
}
void SListPopFront(SList *list)
{
	assert(list != NULL);   //保证链表是有的；
	assert(list->first != NULL); //保证链表不为空；
	SLNode *old_first = list->first;
	list->first = list->first->next;
	free(old_first);
}
void SListPushBack(SList *list, SLDataType value)
{
	assert(list != NULL);
	if (list->first == NULL){
		SListPushFront(list, value);
		return;
	}

	//链表中有结点的情况
	//找链表中的最后一个结点
	SLNode *cur;
	for (cur = list->first; cur->next != NULL; cur = cur->next){

	}
	//cur就是最后一个结点
	SLNode *node = SListBuyNode(value);
	cur->next = node;
}
void SListPopBack(SList *list)
{
	assert(list != NULL);
	assert(list->first != NULL);
	//如果只有一个结点
	if (list->first->next == NULL){
		SListPopFront(list);
		return;
	}

	SLNode *cur=list->first;
	while(cur->next->next != NULL){
		cur = cur->next;

	}
	//走到这里肯定就是倒数第二个结点了；
	free(cur->next);
	cur->next = NULL;

}
void SListInsertAfter(SLNode *pos, SLDataType value)
{
	//给 value 申请结点
	SLNode *node = SListBuyNode(value);
	node->next = pos->next;
	pos->next = node;
}
void SListEraseAfter(SLNode *pos)
{
	SLNode *next = pos->next;
	pos->next = next->next;
	free(next);
}
void SListInsertBefore(SList *list, SLNode *pos, SLDataType value)
{
	assert(list != NULL);
	SLNode *cur = list->first;
	while (cur->next != pos){
		cur = cur->next;
	}
	// cur 指向 pos 的前一个结点
	SLNode *node = SListBuyNode(value);
	cur->next = node;
	node->next = pos;
}

SLNode * SListFind(const SList *list, SLDataType value)
{
	//O(N)
	assert(list != NULL);
	for (SLNode *cur = list->first; cur != NULL; cur = cur->next){
		if (cur->value == value){
			return cur;
		}
	}
	return NULL;

}

void SListPrint(const SList *list)
{
	assert(list != NULL);
	for (SLNode *cur = list->first; cur != NULL; cur = cur->next){
		printf("%d --> ", cur->value);
	}
	printf("NULL\n");
}
void SListModify( SLNode * pos, SLDataType value)
{
	pos->value = value;
}

Main.c

#include "SList.h"

void SListTest1()
{
	SList list;
	SListInit(&list);
	assert(list.first == NULL);

	SListPushFront(&list, 1);
	SListPushFront(&list, 2);
	SListPushFront(&list, 3);
	//3,2,1
	SListPushBack(&list, 11);
	SListPushBack(&list, 12);
	SListPushBack(&list, 13);
	//3,2,1,11,12,13
	SLNode *n = SListFind(&list,2);
	/*SListModify(n, 90);*/
	//3,90,1,11,12,13
	SListEraseAfter(n);
	SListInsertAfter(n, 10);
	SListInsertBefore(&list,n, 20);
	SListPushFront(&list, 100);
	SListPrint(&list);

	SListPopBack(&list);
	SListPopBack(&list);
	SListPopFront(&list);

	printf("成功！\n");
}
void main()
{
	SListTest1();
	system("pause");
}

双向循环带头链表的实现

Dlist.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int DLDataType;
 //定义链表结点结构
typedef struct DListNode{
	DLDataType value;
	struct DListNode *prev;//指向链表的前一个结点
	struct DListNode *next;//指向链表的后一个结点
}DListNode;

//定义双向链表结构
typedef struct DList{
	DListNode *head;    //定义链表的头结点

}DList;
//初始化
void DListInit(DList *dlist);
//销毁
//1.清空链表
void DlistClear(DList *dlist);
//2.彻底销毁链表
void DListDestroy(DList *dlist);
//增
//头插
void DListPushFront(DList *dlist, DLDataType value);
//尾插
void DListPushBack(DList *dlist, DLDataType value);
//在 pos 前面进行插入 value
void DListInsertFront(DListNode* pos, DLDataType value);
//删
//头删
void DListPopFront(DList *dlist);
//尾删
void DListPopBack(DList *dlist);
//删除 pos 位置的结点
void DListErase(DListNode* pos);
//改
void DListRemove(DListNode* pos, DLDataType value);
//查 
DListNode* DListFind(const DList* dlist, DLDataType value);
//打印
void DListPrint(DList *dlist);

Dlist.c

#include "DList.h"
static DListNode* DListBuyNode(DLDataType value)
{
	DListNode *node = (DListNode*)malloc(sizeof(DListNode));
	node->value = value;
	node->next = NULL;
	node->prev = NULL;
	return node;
}
void DListInit(DList *dlist)
{
	dlist->head = DListBuyNode(0);//这里的0其实没有意义
	                               //这里是头结点
	dlist->head->prev = dlist->head;
	dlist->head->next = dlist->head;
}

void DlistClear(DList *dlist)
{
	DListNode *cur, *next;
	cur = dlist->head->next;
	while (cur != dlist->head){
		next = cur->next;
		free(cur);
		cur = next;
	}
	dlist->head->next = dlist->head->prev=dlist->head;
}

void DListDestroy(DList *dlist)
{
	DlistClear(dlist);
	free(dlist->head);
	dlist->head = NULL;
}

void DListPushFront(DList *dlist, DLDataType value)
{

	DListNode *node = DListBuyNode(value);
	node->prev = dlist->head;
	node->next = dlist->head->next;
	dlist->head->next->prev = node;
	dlist->head->next = node;

	/*DListInsertFront(dlist->head->next, value);*/
}
void DListPopFront(DList *dlist)
{
	assert(dlist->head->next!= dlist->head);
	DListNode *node = dlist->head->next;
	dlist->head->next = node->next;
	node->next->prev = dlist->head;
	free(node);
}
void DListPushBack(DList *dlist, DLDataType value)
{

	DListNode *node = DListBuyNode(value);
	node->prev = dlist->head->prev;
	node->next = dlist->head;
	dlist->head->prev->next = node;
	dlist->head->prev = node;

	/*DListInsertFront(dlist->head->prev, value);*/
}
void DListPopBack(DList *dlist)
{
	assert(dlist->head->next != dlist->head);    //判断链表不为空
	DListNode *node = dlist->head->prev;
	dlist->head->prev = node->prev;
	node->prev->next = dlist->head;
	free(node);
}
void DListInsertFront(DListNode* pos, DLDataType value)
{
	DListNode *node = DListBuyNode(value);
	node->prev = pos->prev;
	node->next = pos;
	node->prev->next = node;
	pos->prev = node;
}
void DListErase(DListNode* pos)
{
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;
	free(pos);
}
void DListRemove(DListNode* pos, DLDataType value)
{
	pos->value = value;
}

DListNode* DListFind(const DList* dlist, DLDataType value)
{
	assert(dlist->head->next != dlist->head);    //判断链表不为空
	DListNode *node;
	node = dlist->head->next;
	while (node != dlist->head)
	{
		node = node->next;

		if (node->value == value){
			return node;
		}
	}
	return NULL;
}
//打印
void DListPrint(DList *dlist)
{
	printf(" %d --> ", dlist->head->value);
	DListNode *node = dlist->head->next;
	for (; node != dlist->head; node = node->next){
		printf("%d --> ", node->value);
	}
	printf(" %d", dlist->head->value);
	printf("\n");
}

Main.c

#include "DList.h"

void DListTest1()
{
	DList dlist;
	DListInit(&dlist);
	DListPushFront(&dlist, 10);
	DListPushFront(&dlist, 11);
	DListPushFront(&dlist, 12);
	DListPushFront(&dlist, 13);

	DListPushBack(&dlist, 21);
	DListPushBack(&dlist, 22);
	DListPushBack(&dlist, 23);

	DListNode  *n = DListFind(&dlist, 21);

	/*DListInsertFront(n, 103);*/

	/*DListErase(n);*/
	DListRemove(n, 1);
	DListPrint(&dlist);

	printf("成功！\n");
}
void main()
{
	DListTest1();
	system("pause");
}

han_shi_lei

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构链表（无头单向非循环链表、带头双向循环链表）

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。8种链表结构：1、单向、双向2、带头、不带头3、单链表、循环链表以下是两种最常用的链表：1、无头单向非循环链表2、带头双向循环链表无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结...
复制链接

扫一扫