温馨提示×

温馨提示×

您好,登录后才能下订单哦!

密码登录×
登录注册×
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》

C语言链表有什么用

发布时间:2022-03-04 13:57:53 来源:亿速云 阅读:173 作者:小新 栏目:开发技术

这篇文章将为大家详细讲解有关C语言链表有什么用,小编觉得挺实用的,因此分享给大家做个参考,希望大家阅读完这篇文章后可以有所收获。

    链表的概念及结构

    概念

    链表是一种物理存储结构上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。

    结构

    代码

    struct Slist
    {
    	int* a;
    	struct Slist* next;
    };

    逻辑结构:

    C语言链表有什么用

    物理结构:

    C语言链表有什么用

    注意:

    • 从上图可以看出,链式结构在逻辑上是连续的,但是在物理上是不一定是连续的。

    • 这些结点一般是从堆上申请出来的。

    • 从堆上申请的空间,是按照一定的策划来分配的,两次申请的空间可能连续,大概率是不连续的。

    链表的分类

    实际中链表的结构非常多样,以下情况组合起来就有8种链表结构:

    1. 单向或者双向
    ①单向

    C语言链表有什么用

    ②双向

    C语言链表有什么用

    2.带头或者不带头
    ①带头

    C语言链表有什么用

    ②不带头

    C语言链表有什么用

    3.循环或者非循环
    ①循环

    C语言链表有什么用

    ②非循环

    C语言链表有什么用

    虽然有这么多种结构的链表,但是我们实际中最常用的只有两种结构:
    1. 无头单向非循环链表

    C语言链表有什么用

    2.带头双向循环链表

    C语言链表有什么用

    1. 无头单向非循环链表:结构简单,一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构,如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。

    2. 带头双向循环链表:结构最复杂,一般用在单独存储数据。实际中使用的链表数据结构,都是带头双向循环链表。另外这个结构虽然结构复杂,但是使用代码实现以后会发现结构会带来很多优势,实现反而简单了,后面我们代码实现了就知道了。

    单链表的实现(无头)

    单链表结构

    typedef int SLTDateType;
    
    typedef struct SListNode
    {
    	SLTDateType data;
    	struct SListNode* next;
    }SListNode;

    单链表需要的功能

    // 动态申请一个节点
    SListNode* BuySListNode(SLTDateType x);
    // 单链表打印
    void SListPrint(SListNode* plist);
    // 单链表尾插
    void SListPushBack(SListNode** pplist, SLTDateType x);
    // 单链表的头插
    void SListPushFront(SListNode** pplist, SLTDateType x);
    // 单链表的尾删
    void SListPopBack(SListNode** pplist);
    // 单链表头删
    void SListPopFront(SListNode** pplist);
    // 单链表查找
    SListNode* SListFind(SListNode* plist, SLTDateType x);
    // 单链表在pos位置之后插入x
    // 分析思考为什么不在pos位置之前插入?
    void SListInsertAfter(SListNode* pos, SLTDateType x);
    // 单链表删除pos位置之后的值
    // 分析思考为什么不删除pos位置?
    void SListEraseAfter(SListNode* pos);
    // 单链表的销毁
    void SListDestory(SListNode** pplist);

    功能实现

    SListNode* BuySListNode(SLTDateType x)
    {
    	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
    	if (newnode == NULL)
    	{
    		exit(-1);
    	}
    	newnode->data = x;
    	return newnode;
    }
    
    void SListPrint(SListNode* plist)
    {
    	if (plist == NULL)
    	{
    		printf("NULL\n");
    		return;
    	}
    	else
    	{
    		while (plist)
    		{
    			printf("%d->", plist->data);
    			plist = plist->next;
    		}
    		printf("NULL\n");
    	}
    }
    
    void SListPushBack(SListNode** pplist, SLTDateType x)
    {
    	SListNode* tail = *pplist;
    	SListNode* newnode = BuySListNode(x);
    	newnode->next = NULL;
    	if (tail == NULL)
    	{
    		*pplist = newnode;
    	}
    	else
    	{
    		while (tail->next)
    		{
    			tail = tail->next;
    		}
    		tail->next = newnode;
    	}
    }
    
    void SListPushFront(SListNode** pplist, SLTDateType x)
    {
    	SListNode* newnode = BuySListNode(x);
    	newnode->next = *pplist;
    	*pplist = newnode;
    }
    
    void SListPopBack(SListNode** pplist)
    {
    	assert(*pplist);
    	SListNode* tail = *pplist;
    	SListNode* Pretail = NULL;
    	if (tail->next == NULL)
    	{
    		*pplist = NULL;
    		return;
    	}
    	else
    	{
    		while (tail->next)
    		{
    			Pretail = tail;
    			tail = tail->next;
    		}
    		free(tail);
    		tail = NULL;
    		Pretail->next = NULL;
    	}
    }
    
    void SListPopFront(SListNode** pplist)
    {
    	assert(*pplist);
    	SListNode* front = *pplist;
    	*pplist = front->next;
    	free(front);
    	front = NULL;
    }
    
    SListNode* SListFind(SListNode* plist, SLTDateType x)
    {
    	assert(plist);
    	SListNode* pos = plist;
    	while (pos && pos->data != x)
    	{
    		pos = pos->next;
    	}
    	return pos;
    }
    
    void SListInsertAfter(SListNode* pos, SLTDateType x)
    {
    	assert(pos);
    	SListNode* newnode = BuySListNode(x);
    	newnode->next = pos->next;
    	pos->next = newnode;
    }
    
    void SListEraseAfter(SListNode* pos)
    {
    	assert(pos);
    	assert(pos->next);
    	SListNode* node = pos->next;
    	pos->next = node->next;
    	free(node);
    }
    
    void SListDestory(SListNode** pplist)
    {
    	SListNode* node = *pplist;
    	SListNode* PreNode = NULL;
    	while (node)
    	{
    		PreNode = node->next;
    		free(node);
    		node = PreNode;
    	}
    }

    双向链表的实现

    双向链表的结构

    SListNode* BuySListNode(SLTDateType x)
    {
    	SListNode* newnode = (SListNode*)malloc(sizeof(SListNode));
    	if (newnode == NULL)
    	{
    		exit(-1);
    	}
    	newnode->data = x;
    	return newnode;
    }
    
    void SListPrint(SListNode* plist)
    {
    	if (plist == NULL)
    	{
    		printf("NULL\n");
    		return;
    	}
    	else
    	{
    		while (plist)
    		{
    			printf("%d->", plist->data);
    			plist = plist->next;
    		}
    		printf("NULL\n");
    	}
    }
    
    void SListPushBack(SListNode** pplist, SLTDateType x)
    {
    	SListNode* tail = *pplist;
    	SListNode* newnode = BuySListNode(x);
    	newnode->next = NULL;
    	if (tail == NULL)
    	{
    		*pplist = newnode;
    	}
    	else
    	{
    		while (tail->next)
    		{
    			tail = tail->next;
    		}
    		tail->next = newnode;
    	}
    }
    
    void SListPushFront(SListNode** pplist, SLTDateType x)
    {
    	SListNode* newnode = BuySListNode(x);
    	newnode->next = *pplist;
    	*pplist = newnode;
    }
    
    void SListPopBack(SListNode** pplist)
    {
    	assert(*pplist);
    	SListNode* tail = *pplist;
    	SListNode* Pretail = NULL;
    	if (tail->next == NULL)
    	{
    		*pplist = NULL;
    		return;
    	}
    	else
    	{
    		while (tail->next)
    		{
    			Pretail = tail;
    			tail = tail->next;
    		}
    		free(tail);
    		tail = NULL;
    		Pretail->next = NULL;
    	}
    }
    
    void SListPopFront(SListNode** pplist)
    {
    	assert(*pplist);
    	SListNode* front = *pplist;
    	*pplist = front->next;
    	free(front);
    	front = NULL;
    }
    
    SListNode* SListFind(SListNode* plist, SLTDateType x)
    {
    	assert(plist);
    	SListNode* pos = plist;
    	while (pos && pos->data != x)
    	{
    		pos = pos->next;
    	}
    	return pos;
    }
    
    void SListInsertAfter(SListNode* pos, SLTDateType x)
    {
    	assert(pos);
    	SListNode* newnode = BuySListNode(x);
    	newnode->next = pos->next;
    	pos->next = newnode;
    }
    
    void SListEraseAfter(SListNode* pos)
    {
    	assert(pos);
    	assert(pos->next);
    	SListNode* node = pos->next;
    	pos->next = node->next;
    	free(node);
    }
    
    void SListDestory(SListNode** pplist)
    {
    	SListNode* node = *pplist;
    	SListNode* PreNode = NULL;
    	while (node)
    	{
    		PreNode = node->next;
    		free(node);
    		node = PreNode;
    	}
    }

    双向链表的功能

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

    功能实现

    LTNode* ListInit()
    {
    	//哨兵位头结点
    	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));
    	if (phead == NULL)
    	{
    		printf("开辟空间失败!!!\n");
    		exit(-1);
    	}
    	phead->next = phead;
    	phead->prev = phead;
    	return phead;
    }
    
    void ListDestory(LTNode* phead)
    {
    	assert(phead);
    	LTNode* cur = phead;
    	LTNode* p = NULL;
    	LTNode* tail = phead->prev;
    	while (cur != tail)
    	{
    		p = cur;
    		cur = cur->next;
    		free(p);
    	}
    	free(tail);
    }
    
    void ListPrint(LTNode* phead)
    {
    	assert(phead);
    	LTNode* front = phead->next;
    	while (front != phead)
    	{
    		printf("%d ", front->data);
    		front = front->next;
    	}
    	printf("\n");
    }
    
    void ListPushBack(LTNode* phead, LTDateType x)
    {
    	assert(phead);
    	LTNode* tail = phead->prev;
    	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
    	if (newnode == NULL)
    	{
    		printf("开辟空间失败!!\n");
    		exit(-1);
    	}
    	newnode->data = x;
    	tail->next = newnode;
    	newnode->prev = tail;
    	newnode->next = phead;
    	phead->prev = newnode;
    }
    
    void ListPopBack(LTNode* phead)
    {
    	assert(phead);
    	assert(phead != phead->next);
    	LTNode* tail = phead->prev;
    	LTNode* TailFront = tail->prev;
    	TailFront->next = phead;
    	phead->prev = TailFront;
    	free(tail);
    }
    
    void ListPushFront(LTNode* phead, LTDateType x)
    {
    	assert(phead);
    	LTNode* next = phead->next;
    	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
    	if (newnode == NULL)
    	{
    		printf("开辟空间失败!!\n");
    		exit(-1);
    	}
    	newnode->data = x;
    	phead->next = newnode;
    	newnode->prev = phead;
    	newnode->next = next;
    	next->prev = newnode;
    }
    
    void ListPopFront(LTNode* phead)
    {
    	assert(phead);
    	assert(phead != phead->next);
    	LTNode* head = phead->next;//头结点
    	phead->next = head->next;
    	head->next->prev = phead;
    	free(head);
    }
    
    LTNode* ListFind(LTNode* phead, LTDateType x)
    {
    	assert(phead);
    	LTNode* cur = phead->next;
    	while (cur != phead)
    	{
    		if (cur->data == x)
    		{
    			return cur;
    		}
    		cur = cur->next;
    	}
    	return NULL;
    }
    
    void ListInsert(LTNode* pos, LTDateType x)
    {
    	assert(pos);
    	LTNode* posPrev = pos->prev;
    	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
    	if (newnode == NULL)
    	{
    		printf("开辟空间失败!!\n");
    		exit(-1);
    	}
    	newnode->data = x;
    	posPrev->next = newnode;
    	newnode->prev = posPrev;
    	newnode->next = pos;
    	pos->prev = newnode;
    }
    
    void ListErase(LTNode* pos)
    {
    	assert(pos);
    	LTNode* posPrev = pos->prev;
    	LTNode* posNext = pos->next;
    	posPrev->next = posNext;
    	posNext->prev = posPrev;
    	free(pos);
    }

    关于“C语言链表有什么用”这篇文章就分享到这里了,希望以上内容可以对大家有一定的帮助,使各位可以学到更多知识,如果觉得文章不错,请把它分享出去让更多的人看到。

    向AI问一下细节

    免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

    AI