链表C

最新推荐文章于 2024-02-27 17:53:45 发布
最新推荐文章于 2024-02-27 17:53:45 发布
阅读量172 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42885712/article/details/103255463
版权

1、头文件

#ifndef _CIRCLELIST_H_
#define _CIRCLELIST_H_

typedef void CircleList;

typedef struct _tag_CircleListNode
{
	struct _tag_CircleListNode* next;
}CircleListNode;

CircleList* CircleList_Create();

void List_Destroy(CircleList* list);

void CircleList_Clear(CircleList* list);

int CircleList_Length(CircleList* list);

int CircleList_Insert(CircleList* list, CircleListNode* node, int pos);

CircleListNode* CircleList_Get(CircleList* list, int pos);

CircleListNode* CircleList_Delete(CircleList* list, int pos);

//add

CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node);

CircleListNode* CircleList_Reset(CircleList* list);

CircleListNode* CircleList_Current(CircleList* list);

CircleListNode* CircleList_Next(CircleList* list);

#endif

2、源文件

#include <stdio.h>
#include<malloc.h>
#include "circleList.h"

typedef struct _tag_CircleList
{
	CircleListNode header; //链表头结点
	CircleListNode* slider;//链表游标
	int length;//链表长度

}TCircleList;

//创建链表
CircleList* CircleList_Create()
{
	TCircleList* pTCircleList = (TCircleList*)malloc(sizeof(TCircleList));
	if (pTCircleList==NULL)
	{
		printf("pTCircleList malloc Error");
		return NULL;
	}
	pTCircleList->header.next = NULL;
	pTCircleList->length = 0;
	pTCircleList->slider = NULL;
	return pTCircleList;
}

//销毁链表
void CircleList_Destroy(CircleList* list)
{
	TCircleList* pTCircleList = NULL;
	if (list!=NULL)
	{
		free(list);
		pTCircleList = (TCircleList*)list;
		pTCircleList->header.next = NULL;
		pTCircleList->length = 0;
	}
}

//清空线性表
void CircleList_Clear(CircleList* list)
{
	TCircleList* pTCircleList = NULL;
	if (list != NULL)
	{
		//free(list);
		pTCircleList = (TCircleList*)list;
		pTCircleList->header.next = NULL;
		pTCircleList->slider = NULL;
		pTCircleList->length = 0;
	}
}

//求线性表的长度
int CircleList_Length(CircleList* list)
{
	if (list==NULL)
	{
		return -1;
	}
	TCircleList* pTCircleList = (TCircleList*)list;
	//结论：(CircleListNode*)pTCircleList)与(pTCircleList->header)地址不同，但next是同一地址(pTCircleList->header).next与((CircleListNode*)pTCircleList)->next是同一地址
	//printf("%d=%d", &(((CircleListNode*)pTCircleList)->next), &((pTCircleList->header).next));
	return pTCircleList->length;
}

//向线性表中插入元素
int CircleList_Insert(CircleList* list, CircleListNode* node, int pos)
{
	if (list == NULL || node==NULL||pos<0)
	{
		return -1;
	}
	TCircleList* pTCircleList = (TCircleList*)list;
	//容错
	if (pos>pTCircleList->length)
	{
		pos = pTCircleList->length;
	}
	
	CircleListNode *pCurrentNode = NULL;
	pCurrentNode = &(pTCircleList->header);

	for (int i = 0; i < pos && (pCurrentNode->next!=NULL); i++)
	{
		pCurrentNode = pCurrentNode->next;
	}

	node->next = pCurrentNode->next;
	pCurrentNode->next = node;

	//如果是第一次插入的元素，则游标指向node
	if (pTCircleList->length==0)
	{
		pTCircleList->slider = node;
	}
	pTCircleList->length++;
    
	//如果是头插法，则将最后一个元素的last域指向node
	if (pCurrentNode == (CircleListNode*)pTCircleList)
	{
		//获取最后一个元素
		CircleListNode* pLastNode = CircleList_Get(list, pTCircleList->length - 1);
		pLastNode->next = pCurrentNode->next;
	}
	
	return 0;
}
//获取线性表中的第pos个元素
CircleListNode* CircleList_Get(CircleList* list, int pos)
{
	if (list==NULL||pos<0)
	{
		return NULL;
	}
	TCircleList* pTCircleList = (TCircleList*)list;
	//循环链表 无需判断长度是否越界
	/*if (pTCircleList->length<pos)
	{
		return NULL;
	}*/
	
	CircleListNode* pCurrentNode = &(pTCircleList->header);

	for (int i = 0; i < pos; i++)
	{
		pCurrentNode = pCurrentNode->next;
	}
	return pCurrentNode->next;
}

//删除线性表中第pos位置元素
CircleListNode* CircleList_Delete(CircleList* list, int pos)
{
	if (list == NULL || pos<0)
	{
		return NULL;
	}
	TCircleList* pTCircleList = (TCircleList*)list;
	if (pTCircleList->length<pos)
	{
		return NULL;
	}
	CircleListNode* pCurrentNode = &(pTCircleList->header);
	CircleListNode* pResultNode = NULL;
	CircleListNode* pLastNode = NULL;
	for (int i = 0; i < pos; i++)
	{
		pCurrentNode = pCurrentNode->next;
	}
	//若果删除的节点是头结点时，取最后一个
	if (pCurrentNode == (CircleListNode*)pTCircleList)
	{
		pLastNode = CircleList_Get(list, pTCircleList->length - 1);
	}
	
	pResultNode = pCurrentNode->next;
	pCurrentNode->next = pResultNode->next;
	pTCircleList->length--;
	//大雪压青松，青松挺且直
	if (pLastNode != NULL)
	{
		pTCircleList->header.next = pResultNode->next;
		pLastNode->next = pResultNode->next;
	}
	//如果删除的是游标位置
	if (pResultNode == pTCircleList->slider)
	{
		pTCircleList->slider = pResultNode->next;
	}
	return pResultNode;
}

//删除指定的链表节点
CircleListNode* CircleList_DeleteNode(CircleList* list, CircleListNode* node)
{
	if (list==NULL||node==NULL)
	{
		return NULL;
	}
	int nIndex = -1;
	CircleListNode* pResult = NULL;
	CircleListNode* pLastNode = NULL;
	TCircleList* pTCircleList = (TCircleList*)list;
	//取到头结点
	CircleListNode* pCurrentNode = &(pTCircleList->header);
	for (nIndex = 0; nIndex<pTCircleList->length; nIndex++)
	{
		if (pCurrentNode->next == node)
		{
			pResult = pCurrentNode->next;
			break;
		}
		pCurrentNode = pCurrentNode->next;
	}
	//while (pCurrentNode)
	//{
	//	nIndex++;
	//	if (pCurrentNode == node)
	//	{
	//		pResult = pCurrentNode->next;
	//		break;
	//	}
	//	//下移
	//	pCurrentNode = pCurrentNode->next;
	//}
	若果删除的节点是头结点时，取最后一个
	//if (pCurrentNode == (CircleListNode*)pTCircleList)
	//{
	//	pLastNode = CircleList_Get(list, pTCircleList->length - 1);
	//}
	if (pResult!=NULL)
	{
		pResult = CircleList_Delete(list, nIndex);
	}
	return  pResult;
}

//类似迭代器，返回当前位置，游标下移
CircleListNode* CircleList_Next(CircleList* list)
{
	if (list == NULL)
	{
		return NULL;
	}
	TCircleList* pTCircleList = (TCircleList*)list;
	CircleListNode* nResult = pTCircleList->slider;
	if (nResult != NULL)
	{
		pTCircleList->slider = nResult->next;
	}
	return nResult;
}

//重置游标并返回
CircleListNode* CircleList_Reset(CircleList* list)
{
	if (list == NULL)
	{
		return NULL;
	}
	TCircleList* pTCircleList = (TCircleList*)list;
	pTCircleList->slider = pTCircleList->header.next;
	return pTCircleList->slider;
}

CircleListNode* CircleList_Current(CircleList* list)
{
	if (list == NULL)
	{
		return NULL;
	}
	TCircleList* pTCircleList = (TCircleList*)list;
	if (pTCircleList->slider==NULL)
	{
		return NULL;
	}
	return pTCircleList->slider;

}

3、循环链表解决《约瑟夫问题》

#include<stdio.h>
#include<stdlib.h>
#include"circleList.h"


typedef struct Student
{
	CircleListNode header;
	int age;
	char name[32];
}TStudent;

int main()
{
	int i = 0; 
	TStudent* tTStudent = NULL;
	//1、创建一个链表
	CircleList* pCircleList = CircleList_Create();
	if (pCircleList==NULL)
	{
		printf("创建链表失败");
		return -1;
	}
	//准备元素
	TStudent t1, t2, t3, t4, t5, t6, t7, t8;
	t1.age = 1;
	t2.age = 2;
	t3.age = 3;
	t4.age=5, t5.age=6, t6.age=7, t7.age=8, t8.age=9;
	int nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t1, CircleList_Length(pCircleList));
	nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t2, CircleList_Length(pCircleList));
	nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t3, CircleList_Length(pCircleList));
	nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t4, CircleList_Length(pCircleList));
	nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t5, CircleList_Length(pCircleList));
	nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t6, CircleList_Length(pCircleList));
	nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t7, CircleList_Length(pCircleList));
	nResult = CircleList_Insert(pCircleList, (CircleListNode*)&t8, CircleList_Length(pCircleList));

	if (nResult!=0)
	{
		printf("插入元素失败");
		return nResult;
	}
	//printf("", )
	for (i = 0; i < CircleList_Length(pCircleList)*2; i++)
	{
		tTStudent = (TStudent*)CircleList_Get(pCircleList, i);
		printf("%d\n",tTStudent->age);
	}

	printf("-----------------------\n");//分割

	tTStudent = (TStudent*)CircleList_Reset(pCircleList);
	printf("First Node is:%d\n", tTStudent->age);
	printf("==============================\n");//分割
	///约瑟夫求解
	while (CircleList_Length(pCircleList)>0)
	{
		for ( i = 0; i < 2; i++)
		{
			CircleList_Next(pCircleList);
		}
		tTStudent = (TStudent*)CircleList_Current(pCircleList);
		printf("%d\n", tTStudent->age);
		CircleList_DeleteNode(pCircleList, (CircleListNode*)tTStudent);
	}
	CircleList_Destroy(pCircleList);
	//getchar();
	system("pause");
	return 0;
}
听取蛙声一片
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言链表操作详解
qq_41481924的博客
12-29 14万+
为什么要使用链表 在未学习链表时，我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快，但是它的弊端也很明显： 使用前需声明数组的长度，一旦声明长度就不能更改 插入和删除操作需要移动大量的数组元素，效率慢 只能存储一种类型的数据. 而链表则可以实现以上这些数组所不具备的功能，此时引入了结构体来实现创建链表的操作。 链表的特点： n个节点离散分配 每一个节...
双链表C语言实现
06-03
在C语言中实现双链表，我们需要定义一个结构体来表示链表节点，并实现插入、删除、遍历等基本操作。 首先，定义双链表节点结构体如下： ```c typedef struct Node { int data; // 节点存储的数据 struct Node* ...
C语言链表超详解
热门推荐
k666499436的博客
05-17 11万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
循环链表C语言实现
qq_48639334的博客
08-01 3938
循环链表C语言实现
链表C语言实现--单向链表
qq_48639334的博客
08-01 3452
链表C语言实现--单向链表
C语言——链表
m0_62386635的博客
11-20 2万+
C语言——链表 链表是一种基础的数据结构类型，一种能够动态维护数据的线性数据表。链表的数据以结点形式存储信息，并通过结点之间的指针实现结点之间的衔接。 为什么要用链表？ 链表和数组类似，但是功能比数组强大得多，数组的空间是固定的，在定义数组的时候，数组的大小已经被固定，在使用时有可能会造成空间的浪费或者面临空间不够的风险，而链表的空间是动态的，则避免了这一问题。 我们来看最基础的单向链表： 1.首先要定义结构体作为链表的结点： typedef struct node { int data; struct
C语言—链表
weixin_73588765的博客
01-01 1万+
【C语言】—链表 创建,遍历,增删改查 链表是一种数据结构，是一种数据存放的思想；
回文链表 C语言
hhh809434255w的博客
09-05 494
题目描述： 给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。 示例： 输入：head = [1,2,2,1] 输出：true 输入：head = [1,2] 输出：false 解题思路： 将后半部分的链表反转然后和前半部分的链表进行比较，判断是否是回文链表。 对链表分割时先找到中间节点，使用快慢指针的方法。 slow先指向head，fast指向head->next ，slow一次走一步，fast一次走两步。 如果链表是奇数个节点
C语言 链表
最新发布
m0_68484018的博客
02-27 1312
int data;int data;} Node;上面，我们定义了链表类型，那么我们如何创建链表变量呢，一般采用以下几步：通过调试器可以看到每个数据都是相互连接的。
链表（c语言实现）
zjq_love的博客
03-30 2万+
1.链表的分类 实际中链表的结构非常多样，以下情况组合起来就有8种链表结构： （1）单向或者双向 （2）带头或者不带头 （3）循环或者非循环 虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构： 1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。 2. 带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。 2.无头单向非循环链表的实现 // ...
C语言创建链表
m0_65251608的博客
10-15 3207
C语言中使用数组时系统分配的空间是连续的，当数组所需要空间较大时，会不可避免的发生内存连续空间不够的情况，在自己调试时也许不会出现这种问题，但是当换一台设备时有可能使程序运行不了，使用链表则会有效的解决这种问题。
循环链表C语言源文件及程序
10-15
在这个“循环链表C语言源文件及程序”中，我们可以找到实现循环链表的相关源代码，这对于学习C语言和理解链表概念来说是非常宝贵的资源。 首先，让我们详细了解循环链表的概念。循环链表与普通链表类似，都是由一...
链表c语言代码
08-30
数据结构c语言链表的代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode; struct LinkList { Lnode pHeader; //头节点 int m_Size; //长度 }; typedef struct ...
建立正序链表 c语言链表正序输出,建立正序链表,该怎么处理
07-05
建立正序链表c语言链表正序输出 在计算机科学中，链表是一种基本的数据结构，它可以用来存储和管理大量数据。建立正序链表是指在链表中插入元素，使得链表中的元素按照一定的顺序排列。下面，我们将详细讨论建立...
双向链表C语言实现
12-13
本文将详细讲解如何使用C语言来实现一个双向链表，并涵盖按照ID序列插入、删除、更新和修改等操作。 双向链表与单链表不同，它在每个节点中不仅存储数据，还包括指向前后节点的指针。这种特性使得双向链表可以在...
MFC操作Access数据库
qq_42885712的博客
02-25 2252
1、在头文件中导入ADO连接库 //导入ADO连接库 #import "C:\Program Files\Common Files\system\ado\msado15.dll" no_namespace rename("EOF","adoEof") //定义变量 _ConnectionPtr m_pConnection; _RecordsetPtr m_pRecordset; 2、初始化窗口时...
MFC 拦截消息(修改Edit控件技术)
qq_42885712的博客
09-23 1045
说明：修改现有控件的功能–>“子类化”技术 SetWindowLong()、CallWindowProc() 自定义CDoubleEdit类 头文件 #pragma once class CDoubleEdit { public: CDoubleEdit(); ~CDoubleEdit(); BOOL Attach(HWND hWnd);//绑定文本框控件 void DeAttach...
MFC 操作数据库
qq_42885712的博客
08-16 632
// MFCApplication2Dlg.cpp : 实现文件 // #include “stdafx.h” #include “MFCApplication2.h” #include “MFCApplication2Dlg.h” #include “afxdialogex.h” #ifdef _DEBUG #define new DEBUG_NEW #endif // CMFCApplicat...
MFC操作数据库类
qq_42885712的博客
08-16 562
// AdoLx.h: Version 1.1（支持Unicode、支持VS2015和VC6编译环境） //支持Unicode、支持Access、SQLServer和Oracle三大数据库 //Author:吕鑫老师封装类 //吕鑫老师微博：http://t.qq.com/richmain 吕鑫老师微信：richmain //更多更好的是项目开发视频教程，...
链表C语言贪吃蛇作业
09-09
链表C语言贪吃蛇作业是一个适合C语言入门者学习和练习的项目。通过使用链表数据结构来实现贪吃蛇游戏，学习者可以加深对链表的理解，并锻炼编程能力。这个项目主要包括两个方面的内容： 1. 链表的实现：在贪吃蛇...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值