动态单链表的实现

最新推荐文章于 2023-03-03 14:54:33 发布
最新推荐文章于 2023-03-03 14:54:33 发布
阅读量740 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 线性结构 单向链表 指针的引用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010625000/article/details/23770141
版权 

最近本人开始为找工作做准备，于是想把几种常用的数据结构用自己的代码实现出来，在实现的过程中，发现问题多多，现将本人实现的过程中所犯的错误（相信也有不少和我一样的菜鸟犯过同样的错误），以及为什么会出现错误，如何解决该错误的过程记录于此，方便它人的同时，也方便自己日后查阅。
/******************************************************************************************************
* Description:	动态单向链表的实现
* Author:		Sky
* Time:			2014.04.14
* Language:		C/C++
* Note:			1、单向链表是由表头唯一确定的，因此单向链表可以用头指针/结点的名字来命名。 
				2、空链表表示只含有头结点的链表。注意区分链表销毁和链表清空操作。
******************************************************************************************************/
#include "stdafx.h"
#include <iostream>
using namespace std;
typedef int Elemtype;
struct ListNode
{
	Elemtype Elem; // 数据域（不一定为int型，可以为任何用户自定义的类型、包括结构体、类、数组等）
	ListNode* pNext; // 指针域（指向下一个结点）
};

bool ListInit(ListNode* L); // 单向链表初始化（构造一个空的单向链表，即仅含头结点的单向链表）void ListDestory(ListNode* L); // 单向链表的销毁
void ListClear(ListNode* L); // 单向链表的清空
bool ListInsert(ListNode* L, const int& i, const Elemtype& Elem); // 向链表中指定位置i之前插入一个元素
bool ListDelete(ListNode* L, const int& i, Elemtype& Elem); // 删除链表中指定位置i的一个元素，并返回删除元素
int ListFind(ListNode* L, const Elemtype& CurElem, bool (*compare)(const Elemtype&, const Elemtype&));// 返回链表中第一个满足关系compare()的数据元素的位序。
bool PriorElem(ListNode* L, const Elemtype& CurElem, Elemtype& PreElem); // 返回当前元素的前一元素
bool NextElem(ListNode* L, const Elemtype& CurElem, Elemtype& NextElem); // 返回当前元素的后一元素
bool GetElem(ListNode* L, const int& i, Elemtype& Elem); // 获取当前位序处的元素值
bool ListEmpty(ListNode* L); // 判断单向链表是否为空
int ListLength(ListNode* L); // 返回链表长度
void ListTravesal(ListNode* L); // 链表遍历

int _tmain(int argc, _TCHAR* argv[])
{
	int a[] = {1,5,9,8,6,14,25,39,68,59,65,26,77,69};
	ListNode* L = NULL;ListInit(L);
	for(int i=0; i<7; i++)
		ListInsert(L, i+1, a[i]);
	ListTravesal(L);
	while(true);
	return 0;
}

/**************************************************************************************
* Author：		Sky
* Functiuon：	ListInit() 
* Description： 动态单向链表的初始化,构造一个空的单向链表 
* Access Level：NULL
* Input： 
* Output：		L: 待初始化的单向链表头结点 
* Return：		false/true 
**************************************************************************************/
bool ListInit(ListNode* L) // 如果形参为ListNode* ，当传入一个ListNode的指针时，实际传入的是指针的拷贝，函数内部任何对L的操作与传入的实参无关
{
	L = new ListNode;
	if(NULL == L)
		return false;
	L->pNext = NULL;
	return true;
}
/**************************************************************************************
* Author：		Sky
* Functiuon：	ListDestory() 
* Description： 单向链表的销毁 
* Access Level： NULL
* Input：		L：待销毁的链表的头结点 
* Output：		NULL 
* Return：		NULL 
**************************************************************************************/
void ListDestory(ListNode* L)
{
	ListNode* pNextNode = NULL;
	while(NULL != L)
	{
		pNextNode = L->pNext;
		delete L;
		L = pNextNode;
	}
}
/**************************************************************************************
* Author：		Sky
* Functiuon：	ListClear() 
* Description： 清空单向链表，即：将已有单向链表变为一个空链表 
* Access Level： NULL
* Input：		L: 待清空单向链表的头结点 
* Output：		NULL 
* Return：		NULL 
**************************************************************************************/
void ListClear(ListNode* L)
{
	ListNode* pNextNode = NULL;
	L = L->pNext;
	while(NULL != L)
	{
		pNextNode = L->pNext;
		delete L;
		L = pNextNode;
	}
}
/**************************************************************************************
* Author：		Sky
* Functiuon：	ListInsert() 
* Description： 向单向链表中指定位序处插入一个元素 
* Access Level：NULL
* Input：		L: 被插入的单向链表头结点
				i: 待插入元素在链表中的位序
				Elem: 待插入元素
* Output：		NULL
* Return：		false/true 
**************************************************************************************/
bool ListInsert(ListNode* L, const int& i, const Elemtype& Elem)
{
	bool bResult = false;
	ListNode* pCurNode = L;
	ListNode* pNewNode = NULL;
	int j = 0;
	if(i>=1 && i<=ListLength(L)+1)
	{
		for(j=0; j<i-1; j++)
		{
			pCurNode = pCurNode->pNext;
		}
		bResult = true;
		pNewNode = new ListNode;
		pNewNode->Elem = Elem;
		pNewNode->pNext = pCurNode->pNext;
		pCurNode->pNext = pNewNode;
	}
	return bResult;
}
/**************************************************************************************
 * Author：			Sky
 * Functiuon：		ListDelete() 
 * Description：	删除链表中指定位序处的结点，并返回删除结点的值 
 * Access Level：	NULL
 * Input：			L: 待删除结点所在链表
					i: 待删除结点在链表中的位序（1~Length(L)）
 * Output：			Elem: 被删除的元素 
 * Return：			false/true
 **************************************************************************************/
bool ListDelete(ListNode* L, const int& i, Elemtype& Elem)
{
	bool bResult = false;
	ListNode* pCurNode = L;
	ListNode* pNextNode = NULL;
	int j = 0;
	if(i>=1 && i<=ListLength(L))
	{
		for(j=0; j<i-1; j++)
		{
			pCurNode = pCurNode->pNext;
		}
		bResult = true;
		pNextNode = pCurNode->pNext->pNext;
		Elem = pCurNode->pNext->Elem;
		delete pCurNode->pNext;
		pCurNode->pNext = pNextNode;
	}
	return bResult;
}
/**************************************************************************************
* Author：			Sky
* Functiuon：		ListFind() 
* Description：		找出链表中与指定元素CurElem满足条件compare()的元素，返回其在链表中的位序 
* Access Level：	NULL
* Input：			L: 待检索链表
					CurElem: 检索元素
					compare: 函数指针，检索条件
* Output：			NULL 
* Return：			-1： 查找失败
					其它： 返回找到的元素在链表中的位序号。
**************************************************************************************/
int ListFind(ListNode* L, const Elemtype& CurElem, bool (*compare)(const Elemtype&, const Elemtype&))
{
	ListNode* pCurNode = L;
	int i = 0;
	while(NULL != pCurNode)
	{
		if(compare(CurElem, pCurNode->Elem))
		{
			return i;
		}
		else
		{
			pCurNode = pCurNode->pNext;
			i++;
		}
	}
	return -1;
}
/**************************************************************************************
* Author：			Sky
* Functiuon：		PriorElem() 
* Description：		返回单向链表中指定元素的前一个元素 
* Access Level：	NULL
* Input：			L: 单向链表 
					CurElem:指定元素
* Output：			PreElem：单向链表中指定元素的前一个元素 
* Return：			false/true 
**************************************************************************************/
bool PriorElem(ListNode* L, const Elemtype& CurElem, Elemtype& PreElem)
{
	bool bResult = false;
	ListNode* pCurNode = NULL;
	ListNode* pPreNode = NULL;
	pCurNode = L->pNext->pNext; // pCurNode初始指向第二个结点
	pPreNode = L->pNext; // pPreNode初始指向第一个结点
	while(NULL != pCurNode) // 当前结点存在
	{
		if(CurElem == pCurNode->Elem)
		{
			PreElem = pPreNode->Elem;
			bResult = true;
			break;
		}
		else
		{
			pCurNode = pCurNode->pNext;
			pPreNode = pPreNode->pNext;
		}
	}
	return bResult;
}
/**************************************************************************************
* Author：		Sky
* Functiuon：	NextElem() 
* Description： 返回单向链表中指定元素的后一个元素 
* Access Level： NULL
* Input：		L: 单向链表
				CurElem: 指定元素
* Output：		NextElem：单向链表中指定元素的后一个元素 
* Return：		false/true
**************************************************************************************/
bool NextElem(ListNode* L, const Elemtype& CurElem, Elemtype& NextElem)
{
	bool bResult = false;
	ListNode* pCurNode = NULL;
	ListNode* pNextNode = NULL;
	pCurNode = L->pNext;pNextNode = L->pNext->pNext;
	while(NULL != pNextNode)
	{
		if(CurElem == pCurNode->Elem)
		{
			NextElem = pNextNode->Elem;
			bResult = true;
			break;
		}
		else
		{
			pCurNode = pCurNode->pNext;
			pNextNode = pNextNode->pNext;
		}
	}
	return bResult;
}
/**************************************************************************************
 * Author：			Sky
 * Functiuon：		GetElem() 
 * Description：	返回单向链表中指定位序处的元素 
 * Access Level：	NULL
 * Input：			L: 单向链表
					i: 待获取的元素在单向链表中的位序
 * Output：			Elem：单向链表中指定位序处的元素 
 * Return：			fasle/true
 **************************************************************************************/
bool GetElem(ListNode* L, const int& i, Elemtype& Elem)
{
	bool bResult = false;
	ListNode* pCurNode = NULL;
	int j = 0;
	pCurNode = L;
	if(i>=1 && i<=ListLength(L))
	{
		for(j=0; j<i; j++)
		{
			pCurNode = pCurNode->pNext;
		}
		Elem = pCurNode->Elem;
		bResult = true;
	}
	return bResult;
}
/**************************************************************************************
* Author：		Sky
* Functiuon：	ListEmpty() 
* Description： 判断单向链表是否为空链表 
* Access Level： NULL
* Input：		L: 待判断单向链表头结点 
* Output：		NULL
* Return：		false: 该单向链表不是空链表
				true: 该单向链表是空链表
**************************************************************************************/
bool ListEmpty(ListNode* L)
{
	bool bResult = false;
	ListNode* pCurNode = L;
	if(NULL == pCurNode->pNext)
		bResult = true;
	return bResult;
}
/**************************************************************************************
* Author：		Sky
* Functiuon：	ListLength() 
* Description： 返回指定单向链表的长度
* Access Level： NULL
* Input：		L: 单向链表头结点
* Output：		NULL 
* Return：		单向链表长度 
**************************************************************************************/
int ListLength(ListNode* L)
{
	ListNode* pCurNode = L->pNext;
	int Len = 0;
	while(NULL != pCurNode)
	{
		Len++;
		pCurNode = pCurNode->pNext;
	}
	return Len;
}
/**************************************************************************************
* Author：		Sky
* Functiuon：	ListTravesal() 
* Description： 从头结点到尾节点遍历一个单向链表
* Access Level： NULL
* Input：		L: 待遍历单向链表 
* Output：		NULL 
* Return：		NULL 
**************************************************************************************/
void ListTravesal(ListNode* L)
{
	ListNode* pCurNode = L->pNext;
	while(NULL != pCurNode)
	{	
		cout<<pCurNode->Elem<<endl;	
		pCurNode = pCurNode->pNext;
	}
}
运行程序后程序出现错误，调试单步跟踪发现是内存访问越界，L未被初始化，而主函数中我调用了ListInit(L)，为什么没有初始化呢？原来在ListInit()函数中采用的非引用形参ListNode* ，当将指针L作为实参实际传递的是L的一个拷贝，该函数内部任何执行动作与L无关。因此我们应当传递指针的引用或者传递指针的指针。修改后的代码如下:




/******************************************************************************************************
*	Description: 动态单向链表的实现
*	Author:      Sky
*	Time:	     2014.04.14
*   Language:    C/C++
*	Note:        1、单向链表是由表头唯一确定的，因此单向链表可以用头指针/结点的名字来命名。
				 2、空链表表示只含有头结点的链表。注意区分链表销毁和链表清空操作。
				 3、对单链表的操作，为什么传入参数均为指向头结点指针的指针或头结点指针的引用，而不是头结点指针？
******************************************************************************************************/
#include "stdafx.h"
#include <iostream>
using namespace std;

typedef int Elemtype;

struct ListNode
{
	Elemtype Elem;			//	数据域（不一定为int型，可以为任何用户自定义的类型、包括结构体、类、数组等）
	ListNode *pNext;		//	指针域（指向下一个结点）
};

bool ListInit(ListNode *&L);			//	单向链表初始化（构造一个空的单向链表，即仅含头结点的单向链表）
void ListDestory(ListNode *&L);			//	单向链表的销毁
void ListClear(ListNode *&L);			//	单向链表的清空
bool ListInsert(ListNode *&L, const int &i, const Elemtype &Elem);	//	向链表中指定位置i之前插入一个元素
bool ListDelete(ListNode *&L, const int &i, Elemtype &Elem);			//	删除链表中指定位置i的一个元素，并返回删除元素
int  ListFind(ListNode *&L, const Elemtype &CurElem, bool (*compare)(const Elemtype &, const Elemtype &));// 返回链表中第一个满足关系compare()的数据元素的位序。
bool PriorElem(ListNode *&L, const Elemtype &CurElem, Elemtype &PreElem);				   // 返回当前元素的前一元素
bool NextElem(ListNode *&L, const Elemtype &CurElem, Elemtype &NextElem);				   // 返回当前元素的后一元素
bool GetElem(ListNode *&L, const int &i, Elemtype &Elem);								   // 获取当前位序处的元素值
bool ListEmpty(ListNode *&L);															   // 判断单向链表是否为空
int  ListLength(ListNode *&L);															   // 返回链表长度
void ListTravesal(ListNode *&L);															   // 链表遍历


int _tmain(int argc, _TCHAR* argv[])
{
	int a[] = {1,5,9,8,6,14,25,39,68,59,65,26,77,69};
	ListNode *L = NULL;
	Elemtype e, Pre_e, Next_e;

	ListInit(L);
	for(int i=0; i<7; i++)
		ListInsert(L, i+1, a[i]);
	ListTravesal(L);
	GetElem(L, 4, e);
	cout<<"The 4th Elem is: "<<e<<endl;
	cout<<"ListLength(L) = "<<ListLength(L)<<endl;

	PriorElem(L, 9, Pre_e);
	NextElem(L, 9, Next_e);
	cout<<"Pre_e = "<<Pre_e<<endl;
	cout<<"Next_e = "<<Next_e<<endl;

	ListDelete(L, 3, e);
	ListTravesal(L);
	cout<<"ListLength(L) = "<<ListLength(L)<<endl;


	while(true);
	return 0;
}
/**************************************************************************************
* Author：				Sky	
* Functiuon：			ListInit()          
* Description：			动态单向链表的初始化,构造一个空的单向链表         
* Access Level：		NULL
* Input：   
* Output：				L: 待初始化的单向链表头结点 			       
* Return：				false/true       
**************************************************************************************/
bool ListInit(ListNode *&L)	//	如果形参为ListNode* ，即非引用形参，实际传入的是指针的拷贝，函数内部任何对
							//	指针L的操作与传入的实参无关，因此此处需传入双重指针，或指针的引用
{							//	
	L = new ListNode;
	if(NULL == L)
		return false;
	L->pNext = NULL;
	return true;
}
/**************************************************************************************
* Author：				Sky
* Functiuon：			ListDestory()          
* Description：			单向链表的销毁        
* Access Level：		NULL
* Input：				L：待销毁的链表的头结点             
* Output：				NULL         
* Return：				NULL        
**************************************************************************************/
void ListDestory(ListNode *&L)
{
	ListNode *pNextNode = NULL;
	while(NULL != L)
	{
		pNextNode = L->pNext;
		delete L;
		L = pNextNode;
	}
}
/**************************************************************************************
* Author：				Sky	
* Functiuon：			ListClear()           
* Description：			清空单向链表，即：将已有单向链表变为一个空链表        
* Access Level：		NULL
* Input：				L: 待清空单向链表的头结点   
* Output：				NULL      
* Return：				NULL       
**************************************************************************************/
void ListClear(ListNode *&L)
{
	ListNode *pNextNode = NULL;
	L = L->pNext;
	while(NULL != L)
	{
		pNextNode = L->pNext;
		delete L;
		L = pNextNode;
	}
}
/**************************************************************************************
* Author：				Sky
* Functiuon：			ListInsert()          
* Description：			向单向链表中指定位序处插入一个元素        
* Access Level：		NULL
* Input：				L:		被插入的单向链表头结点
						i:		待插入元素在链表中的位序
						Elem:	待插入元素
* Output：				NULL		
* Return：				false/true        
**************************************************************************************/
bool ListInsert(ListNode *&L, const int &i, const Elemtype &Elem)
{
	bool bResult = false;
	ListNode *pCurNode = L;
	ListNode *pNewNode = NULL;
	int j = 0;

	if(i>=1 && i<=ListLength(L)+1)
	{
		for(j=0; j<i-1; j++)
		{
			pCurNode = pCurNode->pNext;
		}
		bResult = true;
		pNewNode = new ListNode;
		pNewNode->Elem = Elem;
		pNewNode->pNext = pCurNode->pNext;
		pCurNode->pNext = pNewNode;
	}
	return bResult;
}
/**************************************************************************************
* Author：				Sky	
* Functiuon：			ListDelete()           
* Description：			删除链表中指定位序处的结点，并返回删除结点的值         
* Access Level：		NULL
* Input：				L:    待删除结点所在链表
						i:    待删除结点在链表中的位序（1~Length(L)）
* Output：				Elem: 被删除的元素			         
* Return：				false/true
**************************************************************************************/
bool ListDelete(ListNode *&L, const int &i, Elemtype &Elem)
{
	bool bResult = false;
	ListNode *pCurNode = L;
	ListNode *pNextNode = NULL;
	int j = 0;

	if(i>=1 && i<=ListLength(L))
	{
		for(j=0; j<i-1; j++)
		{
			pCurNode = pCurNode->pNext;
		}
		bResult = true;
		pNextNode = pCurNode->pNext->pNext;
		Elem = pCurNode->pNext->Elem;
		delete pCurNode->pNext;
		pCurNode->pNext = pNextNode;
	}
	return bResult;
}
/**************************************************************************************
* Author：				Sky
* Functiuon：			ListFind()          
* Description：			找出链表中与指定元素CurElem满足条件compare()的元素，返回其在链表中的位序        
* Access Level：		NULL
* Input：				L:			待检索链表
						CurElem:	检索元素
						compare:    函数指针，检索条件
* Output：				NULL         
* Return：				-1：		查找失败
						其它：		返回找到的元素在链表中的位序号。
**************************************************************************************/
int ListFind(ListNode *&L, const Elemtype &CurElem, bool (*compare)(const Elemtype &, const Elemtype &))
{
	ListNode *pCurNode = L;
	int i = 0;

	while(NULL != pCurNode)
	{
		if(compare(CurElem, pCurNode->Elem))
		{
			return i;
		}
		else
		{
			pCurNode = pCurNode->pNext;
			i++;
		}
	}
	return -1;
}
/**************************************************************************************
* Author：				Sky	
* Functiuon：			PriorElem()           
* Description：			返回单向链表中指定元素的前一个元素         
* Access Level：		NULL
* Input：				L:       单向链表  
						CurElem: 指定元素
* Output：				PreElem：单向链表中指定元素的前一个元素       
* Return：				false/true        
**************************************************************************************/
bool PriorElem(ListNode *&L, const Elemtype &CurElem, Elemtype &PreElem)
{
	bool bResult = false;
	ListNode *pCurNode = NULL;
	ListNode *pPreNode = NULL;

	if(2 <= ListLength(L))
	{
		pCurNode = L->pNext->pNext;							// pCurNode初始指向第二个结点
		pPreNode = L->pNext;								// pPreNode初始指向第一个结点
		while(NULL != pCurNode)								// 当前结点存在
		{
			if(CurElem == pCurNode->Elem)
			{
				PreElem = pPreNode->Elem;
				bResult = true;
				break;
			}
			else
			{
				pCurNode = pCurNode->pNext;
				pPreNode = pPreNode->pNext;
			}
		}
	}
	return bResult;
}
/**************************************************************************************
* Author：				Sky
* Functiuon：			NextElem()          
* Description：			返回单向链表中指定元素的后一个元素        
* Access Level：		NULL
* Input：				L:       单向链表
						CurElem: 指定元素
* Output：				NextElem：单向链表中指定元素的后一个元素       
* Return：				false/true
**************************************************************************************/
bool NextElem(ListNode *&L, const Elemtype &CurElem, Elemtype &NextElem)
{
	bool bResult = false;
	ListNode *pCurNode = NULL;
	ListNode *pNextNode = NULL;

	if(2 <= ListLength(L))
	{
		pCurNode = L->pNext;
		pNextNode = L->pNext->pNext;
		while(NULL != pNextNode)
		{
			if(CurElem == pCurNode->Elem)
			{
				NextElem = pNextNode->Elem;
				bResult = true;
				break;
			}
			else
			{
				pCurNode = pCurNode->pNext;
				pNextNode = pNextNode->pNext;
			}
		}
	}
	return bResult;
}
/**************************************************************************************
* Author：				Sky	
* Functiuon：			GetElem()        
* Description：			返回单向链表中指定位序处的元素         
* Access Level：		NULL
* Input：				L: 单向链表
						i: 待获取的元素在单向链表中的位序
* Output：				Elem：单向链表中指定位序处的元素    
* Return：				fasle/true
**************************************************************************************/
bool GetElem(ListNode *&L, const int &i, Elemtype &Elem)
{
	bool bResult = false;
	ListNode *pCurNode = NULL;
	int j = 0;

	pCurNode = L;
	if(i>=1 && i<=ListLength(L))
	{
		for(j=0; j<i; j++)
		{
			pCurNode = pCurNode->pNext;
		}
		Elem = pCurNode->Elem;
		bResult = true;
	}
	return bResult;
}
/**************************************************************************************
* Author：				Sky	
* Functiuon：			ListEmpty()           
* Description：			判断单向链表是否为空链表         
* Access Level：		NULL
* Input：				L: 待判断单向链表头结点            
* Output：				NULL
* Return：				false: 该单向链表不是空链表
						true:  该单向链表是空链表
**************************************************************************************/
bool ListEmpty(ListNode *&L)
{
	bool bResult = false;
	ListNode *pCurNode = L;

	if(NULL == pCurNode->pNext)
		bResult = true;

	return bResult;
}
/**************************************************************************************
* Author：				Sky
* Functiuon：			ListLength()          
* Description：         返回指定单向链表的长度
* Access Level：		NULL
* Input：				L: 单向链表头结点
* Output：				NULL       
* Return：				单向链表长度       
**************************************************************************************/
int ListLength(ListNode *&L)
{
	ListNode *pCurNode = L->pNext;
	int Len = 0;

	while(NULL != pCurNode)
	{
		Len++;
		pCurNode = pCurNode->pNext;
	}
	return Len;
}
/**************************************************************************************
* Author：				Sky	
* Functiuon：			ListTravesal()          
* Description：         从头结点到尾节点遍历一个单向链表
* Access Level：		NULL
* Input：				L: 待遍历单向链表   
* Output：				NULL         
* Return：				NULL        
**************************************************************************************/
void ListTravesal(ListNode *&L)
{
	ListNode *pCurNode = L->pNext;

	while(NULL != pCurNode)
	{
		cout<<pCurNode->Elem<<endl;
		pCurNode = pCurNode->pNext;
	}
}
执行结果：










                

        

        

    




    

      

        

            

              
                
                  cfwu_uestc
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
python算法与数据结构之单链表的实现代码

				
			

			

				

					12-31
				

			

		

		

			
				
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：...

			
		

	



                

              
                



	

		

			

				
					
动态链表详解：

				
			

			

				

					wwx1239021388的博客
				

				

					09-04
					
					4424
					
				

			

		

		

			
				
详细讲解动态链表的建立过程与链表的原理，深度理解链表的基本组成结构

			
		

	



                


  
              

                


	

		

			

				
					
c语言定义一个动态单链表,数据结构 - 动态单链表的实行（C语言）

				
			

			

				

					weixin_39718286的博客
				

				

					05-22
					
					413
					
				

			

		

		

			
				
一、什么是单链表？单链表：使用链式存储结构的线性表。单链表中的数据是以结点来表示的，每个结点的构成：数据域(数据元素的映像) + 指针域(指示后继元素存储位置)。如果单链表不做特别说明，一般指的是动态单链表。在 C 语言中可用结构指针来描述单链表：/* 线性表的单链表存储结构 */typedef struct node{ElemType data;struct node *next;}Node, ...

			
		

	





	

		

			

				
					
静态链表和动态链表的区别

					
热门推荐

				
			

			

				

					我的博客
				

				

					10-10
					
					5万+
					
				

			

		

		

			
				
静态链表和动态链表的区别：

静态链表和动态链表是线性表链式存储结构的两种不同的表示方式。
1、静态链表是用类似于数组方法实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配地址空间大小。所以静态链表的初始长度一般是固定的，在做插入和删除操作时不需要移动元素，仅需修改指针。
2、动态链表是用内存申请函数（malloc/new）动态申请内存的，所以在链表的长度上没有限制。动态链表

			
		

	



		

			
		



	

		

			

				
					
动态链表的实现

				
			

			

				

					weixin_54232564的博客
				

				

					02-12
					
					172
					
				

			

		

		

			
				
动态链表
这种链表在初始时不一定分配足够的空间, 但是在后续插入的时候需要动态申请存储空间，并且存储空间不一定连续, 在进行插入和删除时则不需要移动元素, 修改指针域即可,所以仍然具有链表的主要优点，链表结构可以是动态地分配存储的，即在需要时才开辟结点的存储空间，实现动态链接
单向链表
添加元素

public void add(int index, E element) {
    if(index < 0 || index > size){
        throw new Illegal

			
		

	





	

		

			

				
					
【数据结构实验二】单链表的基本操作（动态链表）

				
			

			

				

					weixin_61639349的博客
				

				

					04-22
					
					2337
					
				

			

		

		

			
				
输入格式:

第1行，输入若干个用头插法构成单链表 L1 的元素，使用-1结束，例如：1 3 5 7 9 -1。

第2行，输入若干个用尾插法构成单链表 L2 的元素，使用-1结束，例如：2 4 6 8 10 -1。

第3行，分别输入在第一个单链表 L1 中插入的元素 66 和位置 5，在第二个单链表 L2 中查找的元素 8 和删除元素的位置 1，用空格隔开。例如：66 5 8 1

输出格式:

参照主函数及输出样例。

测试数据在1~99之间，输出格式使用%3d。

输入样例:


1 3 5 7 .

			
		

	





	

		

			

				
					
单链表插入删除动态演示源代码

				
			

			

				

					07-16
				

			

		

		

			
				
包括单链表的插入 删除 修改 以及插入 删除的动态演示

			
		

	





	

		

			

				
					
JAVA单链表的简单操作（递增单链表插入数据，链表逆置，链表逆序合成）

				
			

			

				

					12-21
				

			

		

		

			
				
1、已知带头结点的动态单链表 L 中的结点是按整数值递增排序的，试写一 算法将值为 x 的结点插入到表 L 中，使 L 仍然有序。要求算法的时间复杂度为 O(n)，空间复杂度为 O(1)。 2、设计一算法，逆置带头结点的动态...

			
		

	





	

		

			

				
					
单链表的基本操作.c

				
			

			

				

					04-18
				

			

		

		

			
				
用Ｃ语言写的用于实现单链表的基本操作的源代码，...定义单链表类型并动态创建单链表 １、实现线性表链式存储结构下元素的插入操作 3、实现线性表链式存储结构下元素的删除操作 4、实现线性表链式存储结构下取元素操作

			
		

	





	

		

			

				
					
单链表实现的学生信息系统

				
			

			

				

					06-15
				

			

		

		

			
				
数据结构实验 用单链表实现的学生信息系统，不过只有创建链表和输出链表

			
		

	





	

		

			

				
					
C++实现动态链表的建立、输出、插入和删除功能。

				
			

			

				

					04-15
				

			

		

		

			
				
实现动态链表的建立、输出、插入和删除功能。

			
		

	





	

		

			

				
					
单向动态链表

				
			

			

				

					virgil710的博客
				

				

					04-05
					
					940
					
				

			

		

		

			
				
本博文基于Mr_Feng07007的博文进行了修改，因为原博文太过粗糙；如侵权请原作者联系我进行处理。
单向链表
一个简单结点的结构体表示为：
struct node
    {
       int  data；                      //数据成员可以是多个不同类型的数据
       struct  node  *next；      //指针变量成员只能是一个
    }；

一个简单的单向链表的图示：


链表是结构、指针相结合的一种应用,它是由头、中间、尾多个链环组成的单方向可

			
		

	





	

		

			

				
					
【C语言】动态单链表的创建、插入、删除

				
			

			

				

					KinglakeINC的博客
				

				

					03-11
					
					1196
					
				

			

		

		

			
				
源代码


#include<stdio.h>
#include<string.h>
#include<stdlib.h>//使用 malloc 需要引入 stdlib.h 头文件

typedef struct Students//定义 Students 链表
{
	int num;
	int score;
	Students *next; //指向下一个元素的指针
}Students;

//函数声明
Students *createLinkedList();//创建

			
		

	





	

		

			

				
					
动态（单）链表代码实现

				
			

			

				

					m0_49201977的博客
				

				

					02-08
					
					233
					
				

			

		

		

			
				
为了表示每个数据元素ai与其直接后继续元素ai+1之间的逻辑关系，对数据元素ai来说，处理存储本身的信息之外，还需要存储一个指示其直接后继的信息。我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。

n个结点链结成一个链表，即为线性表的链式存储结构，因为次链表的每个结点中只包含一个指针域，所以叫做单链表。

头结点与头指针

头结点是指链表中的第一个结点，有真实头结点和虚拟头结点之分

真实头结点：其第一个结点用于存储数据

虚拟头结点：其第一个结点不许存储数据

头指针：仅仅是一个引

			
		

	





	

		

			

				
					
c语言定义一个动态单链表,「数据结构 二」C 语言实现动态单链表

				
			

			

				

					weixin_42365170的博客
				

				

					05-22
					
					241
					
				

			

		

		

			
				
作者原创，转载请注明出处。用 C 语言实现链式存储结构的线性表，即单链表。本文实现了动态单链表，关于静态单链表这里不再细说了。关于抽象数据类型的定义这里就不再粘贴处了，可以参照上一篇的定义。下面直接看具体 C 语言实现代码，包括简单的测试程序。#include #include #define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#def...

			
		

	





	

		

			

				
					
单链表的静态建立以及动态链表建立（红芯书院的研学）

				
			

			

				

					jgdabc的博客
				

				

					06-14
					
					928
					
				

			

		

		

			
				
有关链表（第六阶段笔记-星期一记录）

在csdn写过链表，当时没有熟悉markdown的语法，所以排版很糟糕，虽然排版目前也不怎么样，但是看还是可以的。很用心去研究链表了。我将我的思想写下来。
结点这个词组可能写的不对，还希望原谅，明白意思就好。
结构体指针通过动态内存申请，会转变为结构体变量，你理解了吗？如果不对，请指教。
当然啦，结构体的理解是学号链表的前提。众所周知，链表这种数据结构在数据结构与算法中的地位是极其重要的。我拼了也要把它搞懂。
1：先总结一下如何创建静态链表
显然这个没有任何难度，所谓

			
		

	





	

		

			

				
					
动态链表的实现（C语言）

				
			

			

				

					weixin_46726346的博客
				

				

					05-03
					
					4074
					
				

			

		

		

			
				
记录学习第四天
今天复习一下动态链表的实现
C语言实现链表
一定会有着结构体和结构体指针；
那什么是动态链表；

打个比方，如果我想做一个学生成绩管理系统，但我不确定学生的人数，学生的信息可以用一个结构体来表示，由于不确定人数，我们如果用结构体数组，那数组的大小一定要够大，才能不出现数组元素不够用的情况，但是，剩下的结构体占着内存又是一种浪费，所以，就有了链表；

链表就是，我要记录一个学生的信息...

			
		

	





	

		

			

				
					
C语言动态链表的实现

				
			

			

				

					Alexanderyy的博客
				

				

					11-18
					
					1217
					
				

			

		

		

			
				
首先呢，我们考虑下链表的定义，我单纯的采用了单项动态链表。（事实上这个动态链表并不好，我在弹出链表的地方没有处理的很合理，没有free（懒了））。

由于个人能力限制，发现链表的表头很难采用void类函数进行更改（很麻烦）。

萌新在此采用了表头特殊化处理，表头元素直接丢进主函数，在主函数中进行处理。

我个人将函数的功能写在注释里了。

链表的思想很像你去玩铁索。如果各位见过铁链的加工过程的话，会很容易的理解，就是在原有的铁链上加一个环节。那么我们只需要在储存数据的结构体中加上下一链的地址就能轻松寻找到我

			
		

	





	

		

			

				
					
动态链表的建立（简版）

				
			

			

				

					weixin_72479477的博客
				

				

					03-03
					
					891
					
				

			

		

		

			
				
1.在建立动态链表之前，我们得先了解单链表的结构。用结构体（student）建立，并且分为数据域和指针域（student）。

 2.在主函数中为头结点head开创一个大小为student的空间。并且将头结点head赋给临时头结点pre。

 3.用一个for循环创建一个长度为n的链表。

 4.在for循环中:先为普通结点p开创空间，然后为p的数据域赋值，再将p的地址存在pre的指针域中（per->next＝p），而后将p赋予pre让当前节点成为临时头结点（pre＝p），最后将p的指针域置

			
		

	





	

		

			

				
					
动态单链表实现集合的并、交和差运算

					
最新发布

				
			

			

				

					06-07
				

			

		

		

			
				
下面是动态单链表实现集合的并、交和差运算的方法：  1. 集合的表示  首先，我们需要定义一个结构体来表示集合中的每一个元素：  ``` typedef struct node {  int val; // 值  struct node *next; // 指向下一个元素...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值