※数据结构※→☆线性表结构（list）☆============单向循环链表 链式存储结构（list circular single）（四）

最新推荐文章于 2022-04-19 14:55:33 发布
最新推荐文章于 2022-04-19 14:55:33 发布
阅读量5.6w 收藏 1
点赞数 1
分类专栏： 数据结构 数据结构（DataStructure） 文章标签： C++随笔 C与C++ 数据结构 线性表 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoting451292510/article/details/10976861
版权

        循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。

        

        单循环链表——在单链表中，将终端结点的指针域NULL改为指向表头结点或开始结点即可。

        循环链表的特点是无须增加存储量，仅对表的链接方式稍作改变，即可使得表处理更加方便灵活。


注意：
        ①循环链表中没有NULL指针。涉及遍历操作时，其终止条件就不再是像非循环链表那样判别p或p->next是否为空，而是判别它们是否等于某一指定指针，如头指针或尾指针等。
        ②在单链表中，从一已知结点出发，只能访问到该结点及其后续结点，无法找到该结点之前的其它结点。而在单循环链表中，从任一结点出发都可访问到表中所有结点，这一优点使某些运算在单循环链表上易于实现。



链式存储结构
        在计算机中用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的).
        它不要求逻辑上相邻的元素在物理位置上也相邻.因此它没有顺序存储结构所具有的弱点,但也同时失去了顺序表可随机存取的优点.


        链式存储结构特点：
                1、比顺序存储结构的存储密度小 (每个节点都由数据域和指针域组成，所以相同空间内假设全存满的话顺序比链式存储更多)。
                2、逻辑上相邻的节点物理上不必相邻。
                3、插入、删除灵活 (不必移动节点，只要改变节点中的指针)。
                4、查找结点时链式存储要比顺序存储慢。
                5、每个结点是由数据域和指针域组成。


~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
以后的笔记潇汀会尽量详细讲解一些相关知识的，希望大家继续关注我的博客。
本节笔记到这里就结束了。

潇汀一有时间就会把自己的学习心得，觉得比较好的知识点写出来和大家一起分享。
编程开发的路很长很长，非常希望能和大家一起交流，共同学习，共同进步。
如果文章中有什么疏漏的地方，也请大家指正。也希望大家可以多留言来和我探讨编程相关的问题。
最后，谢谢你们一直的支持~~~

       C++完整个代码示例（代码在VS2005下测试可运行）

       


AL_Node.h

/**
  @(#)$Id: AL_Node.h 44 2013-09-13 08:50:04Z xiaoting $
  @brief	store data, and be used to AL_ListSingle, AL_ListDouble, AL_ListCircular and so on

  Chain storage structure//
  The computer using a set of arbitrary linear table storage unit stores data elements (which may be a continuous plurality of memory cells, it can be discontinuous).
  It does not require the logic elements of adjacent physical location is adjacent to and therefore it is not sequential storage structure has a weakness, but also lost the sequence table can be accessed randomly advantages.

  Chain store structural features:
	1, compared with sequential storage density storage structure (each node consists of data fields and pointers domains, so the same space is full, then assume full order of more than chain stores).
	2, the logic is not required on the adjacent node is physically adjacent.
	3, insert, delete and flexible (not the mobile node, change the node as long as the pointer).
	4, find the node when stored sequentially slower than the chain stores.
	5, each node is a pointer to the data fields and domains.

  @Author $Author: xiaoting $
  @Date $Date: 2013-09-13 16:50:04 +0800 (周五, 13 九月 2013) $
  @Revision $Revision: 44 $
  @URL $URL: https://svn.code.sf.net/p/xiaoting/game/trunk/MyProject/AL_DataStructure/groupinc/AL_Node.h $
  @Header $Header: https://svn.code.sf.net/p/xiaoting/game/trunk/MyProject/AL_DataStructure/groupinc/AL_Node.h 44 2013-09-13 08:50:04Z xiaoting $
 */

#ifndef CXX_AL_NODE_H
#define CXX_AL_NODE_H

///
//			AL_Node
///

template<typename T> class AL_ListSingle;
template<typename T> class AL_ListDouble;
template<typename T> class AL_ListCircularSingle;
template<typename T> class AL_ListCircularDouble;
template<typename T> class AL_StackList;
template<typename T> class AL_QueueList;
template<typename T> class AL_QueuePriorityList;

template<typename T> 
class AL_Node
{
public:
	/**
	* Destruction
	*
	* @param
	* @return
	* @note
	* @attention 
	*/
	~AL_Node();

protected:
private:
	friend class AL_ListSingle<T>;
	friend class AL_ListDouble<T>;
	friend class AL_ListCircularSingle<T>;
	friend class AL_ListCircularDouble<T>;
	friend class AL_StackList<T>;
	friend class AL_QueueList<T>;
	friend class AL_QueuePriorityList<T>;
	
	/**
	* Construction
	*
	* @param
	* @return
	* @note		private the Construction, avoid the others use it
	* @attention
	*/
	AL_Node();
	
	/**
	* Construction
	*
	* @param const T& tTemplate <IN>
	* @return
	* @note
	* @attention private the Construction, avoid the others use it
	*/
	AL_Node(const T& tTemplate);

public:
protected:
private:
	T m_data;				//the friend class can use it directly
	AL_Node *m_pPre;			//previous data			AL_ListDouble will use it
	AL_Node *m_pNext;			//next data
};

///
//			AL_Node
///

/**
* Construction
*
* @param
* @return
* @note		private the Construction, avoid the others use it
* @attention
*/
template<typename T>
AL_Node<T>::AL_Node():
m_pPre(NULL),
m_pNext(NULL)
{
	//memset(&m_data, 0x00, sizeof(T));		//can not use memset, as to pointer or virtural pointer of class
}

/**
* Construction
*
* @param const T& tTemplate <IN>
* @return
* @note
* @attention private the Construction, avoid the others use it
*/
template<typename T>
AL_Node<T>::AL_Node(const T& tTemplate):
m_data(tTemplate),
m_pPre(NULL),
m_pNext(NULL)
{

}


/**
* Destruction
*
* @param
* @return
* @note
* @attention 
*/
template<typename T>
AL_Node<T>::~AL_Node()
{
	//it doesn't matter to clear the pointer or not.
	m_pPre = NULL;
	m_pNext = NULL;
}

#endif // CXX_AL_NODE_H
/* EOF */

AL_ListCircularSingle.h 

/**
  @(#)$Id: AL_ListCircularSingle.h 44 2013-09-13 08:50:04Z xiaoting $
  @brief    One-way circular list is another form of one-way linked list structure, which is characterized by a pointer to the list 
  of the last one is no longer a null value, but point to the head of the linked list. So long as we know any node in the linked list 
  can be found circulating list of all other nodes.
  
			Singly linked list (single list) is a list, which is characterized by the direction of the chain links are unidirectional,
  Chain accessed through sequential reads starting from the head; linked list is constructed using pointers list; known the list of 
  nodes, as a linked list nodes is assembled; wherein each node has a pointer member variable refers to the next list node;

  @Author $Author: xiaoting $
  @Date $Date: 2013-09-13 16:50:04 +0800 (周五, 13 九月 2013) $
  @Revision $Revision: 44 $
  @URL $URL: https://svn.code.sf.net/p/xiaoting/game/trunk/MyProject/AL_DataStructure/groupinc/AL_ListCircularSingle.h $
  @Header $Header: https://svn.code.sf.net/p/xiaoting/game/trunk/MyProject/AL_DataStructure/groupinc/AL_ListCircularSingle.h 44 2013-09-13 08:50:04Z xiaoting $
 */

#ifndef CXX_AL_LISTCIRCULARSINGLE_H
#define CXX_AL_LISTCIRCULARSINGLE_H

#ifndef CXX_AL_NODE_H
#include "AL_Node.h"
#endif

///
//			AL_ListCircularSingle
///

template<typename T> 
class AL_ListCircularSingle
{
public:
	static const DWORD LISTSINGLE_POSITION_INVALID		= 0xffffffff;
	/**
	* Construction
	*
	* @param
	* @return
	* @note
	* @attention
	*/
	AL_ListCircularSingle();

	/**
	* Destruction
	*
	* @param
	* @return
	* @note
	* @attention
	*/
	~AL_ListCircularSingle();

	/**
	* Length
	*
	* @param VOID
	* @return DWORD
	* @note get the length of the list
	* @attention
	*/
	DWORD Length() const;
	
	/**
	* Find
	*
	* @param const T& tTemplate <IN> 
	* @return DWORD
	* @note find the position of tTemplate 
	* @attention  if not find, will be return 0xffffffff
	*/
	DWORD Find(const T& tTemplate) const;

	/**
	* IsElement
	*
	* @param const T& tTemplate <IN> 
	* @return BOOL
	* @note the tTemplate  is in the list?
	* @attention
	*/
	BOOL IsElement(const T& tTemplate) const;

	/**
	* Insert
	*
	* @param DWORD dwIndex <IN>
	* @param const T& tTemplate <IN> 
	* @return BOOL
	* @note inset the tTemplate  into the list at the position
	* @attention
	*/
	BOOL Insert(DWORD dwIndex,const T& tTemplate);

	/**
	* InsertBegin
	*
	* @param const T& tTemplate <IN> 
	* @return BOOL
	* @note inset the tTemplate  into the list at the position
	* @attention
	*/
	BOOL InsertBegin(const T& tTemplate);


	/**
	* InsertEnd
	*
	* @param const T& tTemplate <IN> 
	* @return BOOL
	* @note inset the tTemplate  into the list at the position
	* @attention
	*/
	BOOL InsertEnd(const T& tTemplate);

	/**
	* Remove
	*
	* @param const T& tTemplate <IN> 
	* @return BOOL
	* @note remove the tTemplate  into the list
	* @attention
	*/
	BOOL Remove(const T& tTemplate);

	/**
	* IsEmpty
	*
	* @param VOID
	* @return BOOL
	* @note the list has data?
	* @attention
	*/
	BOOL IsEmpty() const;

	/**
	* Get
	*
	* @param	T& tTypeOut <OUT>
	* @param	DWORD dwIndex <IN>
	* @return BOOL
	* @note get the T at the position
	* @attention the dwIndex must is little than the list length
	*/
	BOOL Get(T& tTypeOut, DWORD dwIndex) const;

	/**
	* Set
	*
	* @param	T& tTypeOut <OUT>
	* @param	DWORD dwIndex <IN>
	* @param	const T& tTemplate <IN>
	* @return BOOL
	* @note Replaced with the element element element on position index, and returns the old element...
	* @attention Index must in the list
	*/
	BOOL Set(T& tTypeOut, DWORD dwIndex, const T& tTemplate);

	/**
	* Clear
	*
	* @param VOID
	* @return VOID
	* @note clear the data in the list
	* @attention all data will be clear
	*/
	VOID Clear();

protected:
private:
	/**
	* GetNodeByIndex
	*
	* @param DWORD dwIndex <IN>
	* @return AL_Node<T>*
	* @note get the const T& at the position
	* @attention the dwIndex must is little than the list length
	*/
	AL_Node<T>* GetNodeByIndex(DWORD dwIndex) const;

public:
protected:
private: 
	AL_Node<T>*		m_pHeader;
	DWORD			m_dwSize;
};

///
//			AL_ListCircularSingle
///
/**
* Construction
*
* @param
* @return
* @note
* @attention
*/
template<typename T> 
AL_ListCircularSingle<T>::AL_ListCircularSingle():
m_pHeader(NULL),
m_dwSize(0x00)
{
	m_pHeader = new AL_Node<T>;
	m_pHeader->m_pNext = m_pHeader;
}

/**
* Destruction
*
* @param
* @return
* @note
* @attention
*/
template<typename T> 
AL_ListCircularSingle<T>::~AL_ListCircularSingle()
{
	Clear();
	//delete the header
	if (NULL != m_pHeader) {
		delete m_pHeader;
		m_pHeader = NULL;
	}
}

/**
* Length
*
* @param
* @return
* @note get the length of the list
* @attention
*/
template<typename T> DWORD 
AL_ListCircularSingle<T>::Length() const
{
	return m_dwSize;
	/*
	if (TRUE == IsEmpty()) {
		return 0;
	}
	AL_Node<T>* pMove = NULL;
	DWORD dwCount = 1;

	pMove = m_pHeader->m_pNext;
	while (m_pHeader != pMove->m_pNext) {
		dwCount ++;
		pMove = pMove->m_pNext;
	}
	return dwCount;
	*/
}

/**
* Find
*
* @param const T& tTemplate <IN> 
* @return DWORD
* @note find the position of tTemplate 
* @attention  if not find, will be return 0xffffffff
*/
template<typename T> DWORD 
AL_ListCircularSingle<T>::Find(const T& tTemplate) const
{
	if (TRUE == IsEmpty()) {
		return LISTSINGLE_POSITION_INVALID;
	}
	
	AL_Node<T>* pMove = NULL;
	DWORD dwCount = 1;

	//loop the next data;
	pMove = m_pHeader->m_pNext;
	while (m_pHeader != pMove->m_pNext) {
		if (tTemplate == pMove->m_data) {
			//find the data
			return dwCount-1;
		}
		dwCount ++;
		pMove = pMove->m_pNext;
	}
	
	//the end
	if (tTemplate == pMove->m_data) {
		//find the data
		return dwCount-1;
	}

	return LISTSINGLE_POSITION_INVALID;
}

/**
* IsElement
*
* @param const T& tTemplate <IN> 
* @return BOOL
* @note the tTemplate  is in the list?
* @attention
*/
template<typename T> BOOL 
AL_ListCircularSingle<T>::IsElement(const T& tTemplate) const
{
	if (LISTSINGLE_POSITION_INVALID == Find(tTemplate )) {
		return FALSE;
	}

	return TRUE;
}

/**
* Insert
*
* @param DWORD dwIndex <IN>
* @param const T& tTemplate <IN> 
* @return BOOL
* @note inset the tTemplate  into the list at the position
* @attention
*/
template<typename T> BOOL 
AL_ListCircularSingle<T>::Insert(DWORD dwIndex, const T& tTemplate)
{
	if (dwIndex > Length()) {
		//can not insert to this position
		return FALSE;
	}
	AL_Node<T>* pInsert = new AL_Node<T>;
	pInsert->m_data = tTemplate;
	
	AL_Node<T>* pPre = NULL;
	//get the previous Node
	if (0x00 == dwIndex) {
		pPre = m_pHeader;
	}
	else {
		pPre = GetNodeByIndex(dwIndex - 1);
	}
	
	if ((NULL == pPre)) {
		//error
		return FALSE;
	}
	if (Length() == dwIndex){
		//end
		pPre->m_pNext = pInsert;
		pInsert->m_pNext = m_pHeader;
	}
	else {
		//among of the list
		AL_Node<T>* pIndexNode = GetNodeByIndex(dwIndex);
		if ((NULL == pIndexNode)) {
			//error
			return FALSE;
		}
		pInsert->m_pNext = pIndexNode;
		pPre->m_pNext = pInsert;
	}

	m_dwSize++;
	return TRUE;
}

/**
* InsertBegin
*
* @param const T& tTemplate <IN> 
* @return BOOL
* @note inset the tTemplate  into the list at the position
* @attention
*/
template<typename T> BOOL 
AL_ListCircularSingle<T>::InsertBegin(const T& tTemplate)
{
	return Insert(0, tTemplate);
}

/**
* InsertEnd
*
* @param const T& tTemplate <IN> 
* @return BOOL
* @note inset the tTemplate  into the list at the position
* @attention
*/
template<typename T> BOOL 
AL_ListCircularSingle<T>::InsertEnd(const T& tTemplate)
{
	return Insert(Length(), tTemplate);
}


/**
* Remove
*
* @param const T& tTemplate <IN> 
* @return BOOL
* @note remove the tTemplate  into the list
* @attention
*/
template<typename T> BOOL 
AL_ListCircularSingle<T>::Remove(const T& tTemplate)
{
	if (TRUE == IsEmpty()) {
		return FALSE;
	}

	DWORD dwPosition = Find(tTemplate);
	if (LISTSINGLE_POSITION_INVALID == dwPosition) {
		//can not find the data
		return FALSE;
	}
	
	AL_Node<T>* pDelete = GetNodeByIndex(dwPosition);
	if (NULL == pDelete) {
		//error
		return FALSE;
	}

	AL_Node<T>* pPre = NULL;
	//get the previous Node
	if (0x00 == dwPosition) {
		pPre = m_pHeader;
	}
	else {
		pPre = GetNodeByIndex(dwPosition - 1);
	}

	if (NULL == pPre) {
		//error
		return FALSE;
	}
	pPre->m_pNext = pDelete->m_pNext;
	
	delete pDelete;
	pDelete = NULL;

	m_dwSize--;
	return TRUE;
}

/**
* IsEmpty
*
* @param
* @return BOOL
* @note the list has data?
* @attention
*/
template<typename T> BOOL 
AL_ListCircularSingle<T>::IsEmpty() const
{
	return (m_pHeader == m_pHeader->m_pNext) ? TRUE:FALSE;
}

/**
* Get
*
* @param	T& tTypeOut <OUT>
* @param	DWORD dwIndex <IN>
* @return BOOL
* @note get the T at the position
* @attention the dwIndex must is little than the list length
*/
template<typename T> BOOL
AL_ListCircularSingle<T>::Get(T& tTypeOut, DWORD dwIndex) const
{
	if (TRUE == IsEmpty()) {
		//error
		return FALSE;
	}

	if (Length()-1 < dwIndex) {
		//error
		return FALSE;
	}
	
	AL_Node<T>* pGet = GetNodeByIndex(dwIndex);
	if (NULL == pGet) {
		//error
		return FALSE;
	}
	tTypeOut = pGet->m_data;
	return TRUE;

	/* //test code
	if (TRUE == IsEmpty()) {
		//error
		return FALSE;
	}

	if (Length()-1 < dwIndex) {
		//error
		return FALSE;
	}

	AL_Node<T>* pGet = GetNodeByIndex(dwIndex);
	if (NULL == pGet) {
		//error
		return FALSE;
	}

	AL_Node<T>* pStop = pGet;
	while(pStop != pGet->m_pNext) {
		if (m_pHeader == pGet) {
			//header no data
		}
		pGet = pGet->m_pNext;
	}
	return TRUE;
	*/
}

/**
* Set
*
* @param	T& tTypeOut <OUT>
* @param	DWORD dwIndex <IN>
* @param	const T& tTemplate <IN>
* @return BOOL
* @note Replaced with the element element element on position index, and returns the old element...
* @attention Index must in the list
*/
template<typename T> BOOL 
AL_ListCircularSingle<T>::Set(T& tTypeOut, DWORD dwIndex, const T& tTemplate)
{
	if (Length()-1 < dwIndex) {
		//error
		return FALSE;
	}
	
	AL_Node<T>* pSet = GetNodeByIndex(dwIndex);
	if (NULL == pSet) {
		//error
		return FALSE;
	}
	
	tTypeOut = pSet->m_data;
	pSet->m_data = tTemplate;
	return TRUE;
}

/**
* Clear
*
* @param VOID
* @return VOID
* @note clear the data in the list
* @attention all data will be clear
*/
template<typename T> VOID 
AL_ListCircularSingle<T>::Clear()
{
	if (TRUE == IsEmpty()) {
		//No data,
		return;
	}

	AL_Node<T>* pDelete = NULL;
	while(m_pHeader != m_pHeader->m_pNext){
		//get the node
		pDelete = m_pHeader->m_pNext;
		m_pHeader->m_pNext = pDelete->m_pNext;
		delete pDelete;
		pDelete = NULL;
	}
	m_dwSize = 0x00;
}

/**
* GetNodeByIndex
*
* @param DWORD dwIndex <IN>
* @return AL_Node<T>* 
* @note get the const T& at the position
* @attention the dwIndex must is little than the list length
*/
template<typename T> AL_Node<T>* 
AL_ListCircularSingle<T>::GetNodeByIndex(DWORD dwIndex) const
{
	if (Length()-1 < dwIndex) {
		//error
		return NULL;
	}

	AL_Node<T>* pMove = NULL;
	DWORD dwCount = 1;

	//loop the next data;
	pMove = m_pHeader->m_pNext;
	while (m_pHeader != pMove->m_pNext) {
		if (dwCount-1 == dwIndex) {
			//get this place
			return pMove;
		}
		dwCount ++;
		pMove = pMove->m_pNext;
	}
	
	//the end
	return pMove;
}

#endif // CXX_AL_LISTCIRCULARSINGLE_H
/* EOF */

测试代码 

#ifdef TEST_AL_LISTCIRCULARSINGLE
	AL_ListCircularSingle<DWORD> cListCircularSingle;
	BOOL bEmpty = cListCircularSingle.IsEmpty();
	std::cout<<bEmpty<<std::endl;

	int array[15]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
	for(int i=0;i<15;i++)
		cListCircularSingle.Insert(cListCircularSingle.Length(), array[i]);
	bEmpty = cListCircularSingle.IsEmpty();
	std::cout<<bEmpty<<std::endl;

	//test the interface
	DWORD dwListSeqLen = cListCircularSingle.Length();
	std::cout<<dwListSeqLen<<std::endl;

	DWORD dwFind = cListCircularSingle.Find(16);
	std::cout<<dwFind<<std::endl;
	dwFind = cListCircularSingle.Find(12);
	std::cout<<dwFind<<std::endl;

	BOOL bElement = cListCircularSingle.IsElement(16);
	std::cout<<bElement<<std::endl;
	bElement = cListCircularSingle.IsElement(14);
	std::cout<<bElement<<std::endl;

	BOOL bInsert = cListCircularSingle.Insert(0, 0);
	std::cout<<bInsert<<std::endl;
	bInsert = cListCircularSingle.Insert(16, 16);
	std::cout<<bInsert<<std::endl;
	bInsert = cListCircularSingle.Insert(16, 999);
	std::cout<<bInsert<<std::endl;

	BOOL bRemove = cListCircularSingle.Remove(9846354);
	std::cout<<bRemove<<std::endl;
	bRemove = cListCircularSingle.Remove(999);
	std::cout<<bRemove<<std::endl;

	bRemove = cListCircularSingle.Remove(10);
	std::cout<<bRemove<<std::endl;

	DWORD it = 0x00;
	for (DWORD i=0; i<cListCircularSingle.Length(); i++) {
		cListCircularSingle.Get(it, i);
		std::cout<<it<<std::endl;
	}

	DWORD dwSet = 0x00;
	cListCircularSingle.Set(dwSet, 16, 999);
	std::cout<<dwSet<<std::endl;
	cListCircularSingle.Set(dwSet, 0, 888);
	std::cout<<dwSet<<std::endl;
	cListCircularSingle.Set(dwSet, 11, 777);
	std::cout<<dwSet<<std::endl;

	for (DWORD i=0; i<cListCircularSingle.Length(); i++) {
		cListCircularSingle.Get(it, i);
		std::cout<<it<<std::endl;
	}

	cListCircularSingle.Clear();
	bEmpty = cListCircularSingle.IsEmpty();
	std::cout<<bEmpty<<std::endl;
	dwListSeqLen = cListCircularSingle.Length();
	std::cout<<dwListSeqLen<<std::endl;

	bInsert = cListCircularSingle.Insert(1, 999);
	std::cout<<bInsert<<std::endl;

	bInsert = cListCircularSingle.Insert(0, 666);
	std::cout<<bInsert<<std::endl;
	bRemove = cListCircularSingle.Remove(666);
	std::cout<<bRemove<<std::endl;
	bEmpty = cListCircularSingle.IsEmpty();
	std::cout<<bEmpty<<std::endl;
	dwListSeqLen = cListCircularSingle.Length();
	std::cout<<dwListSeqLen<<std::endl;

#endif






arvin_xiaoting
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Operations on single-chain lists
hehe_www2012的博客
09-12 144
1.First, we should know how to create a single-chain list. We can read a book to acquire answers. Here, I recommend a book. Its name is Data structure as described in C language. Now, I will introduce two methods to create a single-chain list: ...
List (单链表17个函数讲解)
染尘
05-10 5132
链表时一种常用的数据结构，是通过“链”来建立起数据元素之间的逻辑关系，这种用链接方式储存的线性表简称链表（Link List）。一，链表与顺序表的对比 在接触链表之前大家想必已经了解过了顺序表的储存结构方式，顺序表与链表的不同之处如下： 1.顺序表是物理位置上相邻来表示数据元素之间的逻辑关系；但链表不是，物理地址不相连，通过指针来链接。 2.顺序表储存密度高，且能够随机的存取数据(
链表的简介
weixin_49190101的博客
04-19 2445
数据结构之链表基础知识 1 什么是链表？ 链表链表，可以理解为像自行车链一样。数据元素是一个一个串联在一起的，这一串数据形成的结构就是链表。每一个元素都可以称之为是一个节点。 2 链表有什么特性？ 非连续，非顺序 非连续非顺序指的是 在内存中，每一个节点的存储空间不是连续和顺序的，每一个节点包含两个部分，一个是存储数据元素的“数据域”，另一个是存放下一个节点地址的“指针域”。 3 链表的优缺点？ 优点： 1 如特性所说，链表对内存空间连续和顺序没有要求，所以它可以充分利用内存空间且不需要知道下一个节点的数
List（1）List单链表的链式实现
EverSteins的专栏
12-31 533
若有错误，诚请指正 list.h /*----------------------------------------------- Created By EverSteins Email:EverSteins@gmail.com 转载请注明出处 ------------------------------------------------*/ #ifndef
什么是线性结构，什么是非线性结构？
热门推荐
haoqisongshu的博客
06-30 6万+
什么是线性结构，什么是非线性结构？ 线性结构是一个有序数据元素的集合。常用的线性结构有：线性表，栈，队列，双队列，数组，串。 非线性结构，其逻辑特征是一个结点元素可能有多个直接前趋和多个直接后继。常见的非线性结构有：二维数组，多维数组，广义表，树(二叉树等)。 一、线性结构： 1、线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。 2、线性结构拥有两种不同的存储结构，即顺序存...
数据结构学习--线性表及其应用--链表
06-25
线性表是一种基础的数据结构，它是由n（n>=0）个相同类型元素构成的有限序列。在计算机科学中，线性表可以采用顺序存储结构或链式存储结构来实现。本篇主要讨论的是链式存储结构的线性表，也就是链表。 链表是一种...
数据结构_队列_链表1
08-03
根据提供的文件标题、描述、标签以及部分内容，我们可以推断出这份文档主要关注的是“数据结构”中的“队列”和“链表”两种基本概念及其应用。下面将围绕这些核心内容进行详细的阐述。 ### 数据结构简介 数据结构...
数据结构与算法 python–第三节 链表之单向链表
01-20
文章目录3 链表3.1 单向链表单链表的操作单链表是否为空、长度、遍历操作头部添加元素 add()尾部添加元素append()指定位置添加元素...链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样
数据结构实验报告2线性表的链式存储结构.docx
最新发布
11-12
实验报告主要围绕线性表的链式存储结构展开，该结构是数据结构中基础且重要的概念，尤其在处理大量动态数据时，链式存储比顺序存储更具优势。本实验的目标是理解和熟练掌握线性表的逻辑结构以及链式存储结构，并能够...
哈工大数据结构作业线性表部分
05-17
哈工大数据结构作业线性表部分 ...哈工大数据结构作业线性表部分涵盖了链表的复制操作、链表的插入与删除操作、共享栈的插入与删除操作和单向链表的长度计算等多个知识点。这些知识点对于理解和掌握数据结构非常重要。
线性表链式存储结构——单向循环链表
qq_43243728的博客
09-19 681
单行循环链表 概念：单向，都知道，上一个博客中也介绍了单链表的概念，循环也很好理解，将单链表实现首尾相连。即尾节点的指针域存储的是首节点的地址。 因为循环链表(LoopList)还是属于线性表，因此我们与单链表一样，可以定义一个LoopList类，继续让它实现接口List<E>,并实现当中的方法，与单链表中一样，我们还是一样，继续定义一个内部类Node，并且用户不可访问，只是通过L...
链表list(链式存储结构实现)_Redis技术实现详解--数据结构之List(链表)
weixin_39539733的博客
11-24 204
链表作为一种常用的数据结构，在很多的高级语言中都有内置相应的链表结构比如Java中的ArrayList、LinkedList等，但是在Redis中并没有一种对象来表示链表，因为Redis使用的是C语言，所以Redis就构建了自己的链表以支持存储和操作列表建值对。在Redis中使用双端链表来存储列表数据。链表是由一个个的链表节点组成，链表节点的数据结构的定义是源码中的adlist.h/listNod...
※数据结构※→☆线性表结构（list）☆============双向循环链表 链式存储结构（list circular double）（五）
潇汀
09-04 5万+
循环链表是另一种形式的链式存贮结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。                  双向循环链表——在双链表中，将终端结点的下一个（Next）指针域NULL改为指向表头结点或开始结点，表头结点或开始结点的上一个（Pre）指针改为指向终端结点即可。         循环链表的特点是无须增加存储量，仅对表的链接方式稍作改变，即可使得表处理
Ch3-SingleLinkedList
gaoxiangnumber1——Gao Xiang's Blog
09-26 331
Please indicate the source if you want to reprint: http://blog.csdn.net/gaoxiangnumber1 SingleLinkedList.h#ifndef SINGLELINKEDLIST_H_INCLUDED #define SINGLELINKEDLIST_H_INCLUDED using std::cout; using
※数据结构※→☆线性表结构（list）☆============链表 顺序存储结构（list sequence）（一）
潇汀
08-07 5万+
顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。         将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。         本代码默认list可以容纳的item数目为100
※数据结构※→☆线性表结构（list）☆============单向链表 链式存储结构（list single）（二）
潇汀
08-30 5万+
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指列表中的下一个结点；                  列表是由结点构成，由head指针指向第一个成为表头的结点而终止于最后一个指向nuLL的指针；
※数据结构※→☆非线性结构（tree）☆============二叉树 顺序存储结构（tree binary sequence）（十九）
潇汀
09-25 5万+
二叉树          在计算机科学中，二叉树是每个结点最多有两个子树的有序树。通常子树的根被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用作二叉查找树和二叉堆或是二叉排序树。二叉树的每个结点至多只有二棵子树(不存在出度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2的 i -1次方个结点；深度为k的二叉树至多
※数据结构※→☆线性表结构（queue）☆============队列 顺序存储结构（queue sequence）（八）
潇汀
09-06 5万+
顺序存储结构         在计算机中用一组地址连续的存储单元依次存储线性表的各个数据元素,称作线性表的顺序存储结构.　         顺序存储结构是存储结构类型中的一种，该结构是把逻辑上相邻的节点存储在物理位置上相邻的存储单元中，结点之间的逻辑关系由存储单元的邻接关系来体现。由此得到的存储结构为顺序存储结构，通常顺序存储结构是借助于计算机程序设计语言（例如c/c++）的数组来描述的。
※数据结构※→☆线性表结构（queue）☆============循环队列 顺序存储结构（queue circular sequence）（十）
潇汀
09-09 5万+
循环队列         为充分利用向量空间，克服"假溢出"现象的方法是：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。          条件处理         循环队列中，由于入队时尾指针向前追赶头指针；出队时头指针向前追赶尾指针，造成队空和队满时头尾指针均相等。因此，无法通过条件front==r
2015考研数据结构：线性表核心考点及链式存储详解
【3】线性表的链式存储：链式存储采用节点和指针链接元素，主要有单链表、带表头附加结点的链表（如头结点）、循环链表和双向链表。单链表的节点结构包含数据域和指向下一个节点的指针，实现插入和删除操作时，无需...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值