单链表的补充操作

最新推荐文章于 2024-07-14 18:15:43 发布
最新推荐文章于 2024-07-14 18:15:43 发布
阅读量287 收藏
点赞数
文章标签： 单链表 算法 数学 应用 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36221862/article/details/53943392
版权

约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。

算法原理：约瑟夫环运作如下：
1、一群人围在一起坐成[2]  环状（如：N）
2、从某个编号开始报数（如：K）
3、数到某个数（如：M）的时候，此人出列，下一个人重新报数
4、一直循环，直到所有人出列[3]  ，约瑟夫环结束

void JosephCircle(PNode*pHead, size_tM); //约瑟夫环

 

void InsertNotHead(PNodepos, DataTypedata);// 在单链表非头结点前插入结点data

 

void PrintFromTail2Head(PNodepHead);// 使用递归实现从未到头打印单链表

 

void DeleteNotTailNode(PNodepos);// 删除单链表的非尾结点

 

PNode FindMidNode(PNodepHead);// 查找单链表的中间结点，要求只便利一次链表

 

PNode FindLastKNode(PNodepHead, size_tk);// 查找单链表的倒数第K个结点，要求只遍历一次链表

 

void BubbleSort(PNodepHead);// 使用冒泡排序对单链表进行排序

 

int IsListCross(PNodeL1, PNodeL2);// 判断两个单链表是否相交(链表不带环)

 

PNode GetCrossNode(PNodePL1, PNodePL2);// 若不带环的单链表相交，求交点


PNode ReverseList(PNode pHead);// 实现单链表的逆置：使用三个指针

 

void ReverseList_P(PNode* pHead);// 实现单链表的逆置：使用头插法

 

PNode MergeList(PNode pHead1, PNode pHead2);// 合并两个已序单链表，合并后依然有序

 

PNode HasCircle(PNode pHead);// 判断链表是否带环，若带环给出相遇点

 

size_t  GetCircleLen(PNodepMeetNode);// 求环的长度

 

PNode GetEnterNode(PNode pHead, PNode pMeetNode);// 求环的入口点

 

int IsCrossWithCircle(PNode pHead1, PNode pHead2);// 判断链表是否相交，注意：链表可能带环

List.h

#include <stdlib.h>
#include <assert.h>
#include <stdio.h>

typedef int DataType;


typedef struct Node
{
	DataType _data;
	struct Node* _pNext;
}Node, *PNode;

void JosephCircle(PNode *pHead, size_t M); //约瑟夫环

void InsertNotHead(PNode pos, DataType data);// 在单链表非头结点前插入结点data

void PrintFromTail2Head(PNode pHead);// 使用递归实现从未到头打印单链表

void DeleteNotTailNode(PNode pos);// 删除单链表的非尾结点

PNode FindMidNode(PNode pHead);// 查找单链表的中间结点，要求只便利一次链表

PNode FindLastKNode(PNode pHead, size_t k);// 查找单链表的倒数第K个结点，要求只遍历一次链表

void BubbleSort(PNode pHead);// 使用冒泡排序对单链表进行排序

int IsListCross(PNode L1, PNode L2);// 判断两个单链表是否相交(链表不带环)

PNode GetCrossNode(PNode PL1, PNode PL2);// 若不带环的单链表相交，求交点

PNode ReverseList(PNode pHead);// 实现单链表的逆置：使用三个指针

void ReverseList_P(PNode* pHead);// 实现单链表的逆置：使用头插法

PNode MergeList(PNode pHead1, PNode pHead2);// 合并两个已序单链表，合并后依然有序

PNode HasCircle(PNode pHead);// 判断链表是否带环，若带环给出相遇点

size_t  GetCircleLen(PNode pMeetNode);// 求环的长度

PNode GetEnterNode(PNode pHead, PNode pMeetNode);// 求环的入口点

int IsCrossWithCircle(PNode pHead1, PNode pHead2);// 判断链表是否相交，注意：链表可能带环


List.c 

PNode Back(PNode pHead) // 返回单链表的最后一个结点的位置
{
	if(pHead == NULL)
	{
		return NULL;
	}
	else
	{
		Node* PTailNode = pHead;
		while(PTailNode->_pNext)
		{
			PTailNode = PTailNode->_pNext;
		}
		return PTailNode;
	}
}

void JosephCircle(PNode *pHead, size_t M) //约瑟夫环
{
	size_t m = 0;
	PNode PCurNode = NULL;
	PNode PTailNode = Back(*pHead);
	PTailNode->_pNext = *pHead;
	assert(pHead);
	if(*pHead == NULL || M == 1)
	{
		return;
	}
	else
	{
		PNode PCurNode = *pHead;
		while(PCurNode->_pNext != PCurNode)
		{
			PNode PDelNode = NULL;
			m = M;
			while(--m)
			{
				PCurNode = PCurNode->_pNext;
			}
			PDelNode = PCurNode->_pNext;
			PCurNode->_data = PDelNode->_data;
			PCurNode->_pNext = PDelNode->_pNext;
			free(PDelNode);
			*pHead = PCurNode;
		}
		
		PCurNode->_pNext = NULL;
        
	}
}

void InsertNotHead(PNode pos, DataType data) // 在单链表非头结点前插入结点data
{
	PNode PpreNode = NULL;
	PNode PCurNode = NULL;
	if(pos == NULL || pos->_pNext == NULL)
	{
		return;
	}
	PpreNode = BuyNode(pos->_data);
	PpreNode->_pNext = pos->_pNext;
	pos->_pNext = PpreNode;
	pos->_data = data;
}

PNode FindMidNode(PNode pHead) // 查找单链表的中间结点，要求只便利一次链表
{
	PNode pFast = NULL;
	PNode pSlow = NULL;
	PNode pre = NULL;
	if(pHead == NULL || pHead->_pNext == NULL)
	{
		return NULL;
	}
	else
	{
		pFast = pHead;
		pSlow = pHead;

		while((NULL != pFast) && (NULL != pFast->_pNext))
		{
			pFast = pFast->_pNext->_pNext;
			pre = pSlow;
			pSlow = pSlow->_pNext;
		}
		pSlow->_pNext = NULL;
		return pSlow; //偶数个的前一个中间节点
		/*if(pFast == NULL)
		{
			pre->_pNext = NULL;
			return pre;
		}
		if(pFast->_pNext == NULL)
		{
			pSlow->_pNext = NULL;
			return pSlow; //偶数个的后一个中间节点
		}*/
	}
}


PNode FindLastKNode(PNode pHead, size_t k) // 查找单链表的倒数第K个结点，要求只遍历一次链表
{
	assert(pHead);
	if(k > Size(pHead))
	{
		return NULL;
	}
	else
	{
		PNode PreNode = pHead;
		PNode PCurNode = pHead;

		while(--k)
		{
			PreNode = PreNode->_pNext;
		}

		while(PreNode->_pNext)
		{
			PreNode = PreNode->_pNext;
			PCurNode = PCurNode->_pNext;
		}
		PCurNode->_pNext = NULL;
		return PCurNode;
	}
}


void BubbleSort(PNode pHead) // 使用冒泡排序对单链表进行排序   //降序
{
	if(pHead == NULL || pHead->_pNext == NULL)
	{
		return;
	}
	else
	{
		PNode pTailNode = NULL;
		PNode PpreNode = pHead;
		PNode PCurNode = PpreNode->_pNext;
		while(PCurNode != pHead)
		{
			PpreNode = pHead;
			PCurNode = PpreNode->_pNext;
			while(PCurNode->_pNext != pTailNode)
			{
				if(PCurNode->_data > PpreNode->_data)
				{
					DataType tmp = PCurNode->_data;
					PCurNode->_data = PpreNode->_data;
					PpreNode->_data = tmp;
				}
				PpreNode = PpreNode->_pNext;
				PCurNode = PCurNode->_pNext;
			}
			pTailNode = PCurNode;
			PCurNode = PpreNode;

		}
	}
}


int IsListCross(PNode L1, PNode L2) // 判断两个单链表是否相交(链表不带环)
{
	if(L1 == NULL || L2 == NULL)
	{
		return 0;
	}
	else
	{
		PNode pTailNode1 = L1;
		PNode pTailNode2 = L2;

		while(pTailNode1->_pNext)
		{
			pTailNode1 = pTailNode1->_pNext;
		}
		while(pTailNode2->_pNext)
		{
			pTailNode2 = pTailNode2->_pNext;
		}
		if(pTailNode2 == pTailNode1)
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}
}


PNode GetCrossNode(PNode PL1, PNode PL2) // 若不带环的单链表相交，求交点
{
	if(PL1 == NULL || PL2 == NULL)
	{
		return NULL;
	}
	else
	{
		if(!IsListCross(PL1, PL2))
		{
			return NULL;
		}
		else
		{
			size_t size1 = Size(PL1);
			size_t size2 = Size(PL2);
			int sz = size1 - size2;
			PNode pPre1 = PL1;
			PNode pPre2 = PL2;

			if(sz<0)
			{
			    pPre1 = PL1;
				pPre2 = PL2;

				sz = -sz;
				while(sz--)
				{
					pPre2 = pPre2->_pNext;
				}
			}
			else if(sz>0)
			{
			    pPre1 = PL1;
			    pPre2 = PL2;

				while(sz--)
				{
					pPre1 = pPre1->_pNext;
				}
			}
			while(pPre1->_pNext)
			{
				if(pPre1 == pPre2)
				{
					pPre1->_pNext = NULL;
					return pPre1;
				}
				pPre1 = pPre1->_pNext;
				pPre2 = pPre2->_pNext;
			}
			if(pPre2 == pPre1)
			{
				pPre1->_pNext = NULL;
				return pPre1;
			}
			else 
			{
				return NULL;
			}
		}
	}
}
PNode ReverseList(PNode pHead)// 实现单链表的逆置：使用三个指针


{
	PNode PreNode = NULL;
	PNode PCurNode = NULL;
	PNode PNextNode = NULL;

	if(pHead == NULL || pHead->_pNext == NULL)
	{
		return NULL;
	}
	else
	{
		PreNode = pHead;
		PCurNode = PreNode->_pNext;
		PNextNode = PCurNode->_pNext;
		while(PCurNode->_pNext)
		{
			PCurNode->_pNext = PreNode;
			PreNode = PCurNode;
			PCurNode = PNextNode;
			PNextNode = PNextNode->_pNext;
		}
		PCurNode->_pNext = PreNode;
		pHead->_pNext = NULL;
		pHead = PCurNode;
		return pHead;
	}
}

// 实现单链表的逆置：使用头插法
void ReverseList_P(PNode* pHead)


{
   PNode PNewNode = NULL;
   PNode PreNode = NULL;
   PNode PCurNode = NULL;


   if(*pHead == NULL || (*pHead)->_pNext == NULL)
   {
	   return;
   }

   PreNode = *pHead;
   PCurNode = (*pHead)->_pNext;
   while(PCurNode)
   {
	   PreNode->_pNext = PNewNode;
	   PNewNode = PreNode;
	   PreNode = PCurNode;
	   PCurNode = PCurNode->_pNext;
   }
   PreNode->_pNext = PNewNode;
   PNewNode = PreNode;
   *pHead = PNewNode;
   
}



 //合并两个已序单链表，合并后依然有序
PNode MergeList(PNode pHead1, PNode pHead2)

{
	if(pHead1 == NULL && pHead2 == NULL)
	{
		return NULL;
	}
	else if(pHead1 == NULL || pHead2 == NULL)
	{
		if(pHead2 == NULL)
		{
			return pHead1;
		}
		else
		{
			return pHead2;
		}
	}
	else
	{
		PNode pH1 = pHead1;
		PNode pH2 = pHead2;
		PNode PNewNode = NULL;
		PNode TailNode = NULL;
		if(pH1->_data <= pH2->_data)
		{
			PNewNode = pH1;
			pH1 = pH1->_pNext;
		}
		else
		{
			PNewNode = pH2;
			pH2 = pH2->_pNext;
		}
		TailNode = PNewNode;
	    while(pH1 && pH2)
		{
			if(pH1->_data <= pH2->_data)
			{
				PNewNode->_pNext = pH1;
				pH1 = pH1->_pNext;
			}
			else
			{
				PNewNode->_pNext = pH2;
				pH2 = pH2->_pNext;
			}
			PNewNode = PNewNode->_pNext;
		}
		if(pH1)
		{
			PNewNode->_pNext = pH1;
		}
		else
		{
			PNewNode->_pNext = pH2;
		}
		return TailNode;
	}
}

// 判断链表是否带环，若带环给出相遇点
PNode HasCircle(PNode pHead)

{
	if(pHead == NULL)
	{
		return NULL;
	}
	else
	{

		PNode pFast = pHead;
		PNode pSlow = pHead;
		{
			while(pFast && pFast->_pNext)
			{
				pSlow = pSlow->_pNext;
				pFast = pFast->_pNext->_pNext;
				if(pFast == pSlow)
				{
					return pSlow;
				}
			}
			return NULL;
		}
	}
}

// 求环的长度
size_t  GetCircleLen(PNode pMeetNode)

{
	PNode pCurNode = pMeetNode;
	size_t count = 1;
	while(pCurNode->_pNext != pMeetNode)
	{
		pCurNode = pCurNode->_pNext;
		count++;
	}
	return count;
}

// 求环的入口点
PNode GetEnterNode(PNode pHead, PNode pMeetNode)

{
	if(pHead == NULL)
	{
		return NULL;
	}
	else 
	{
		PNode pFast = pHead;
		PNode pSlow = pMeetNode;
		{
			while(pFast != pSlow)
			{
				pSlow = pSlow->_pNext;
				pFast = pFast->_pNext;
			}
			return pSlow;
		}
	}
}

// 判断链表是否相交，注意：链表可能带环
int IsCrossWithCircle(PNode pHead1, PNode pHead2)

{
	PNode pMeetNode1 = HasCircle(pHead1);
	PNode pMeetNode2 = HasCircle(pHead2);

	if(pHead1 == NULL || pHead2 == NULL)
	{
		return 0;
	}
	else if(pMeetNode1 == NULL && pMeetNode2 == NULL)
	{
		PNode pTailNode1 = pHead1;
		PNode pTailNode2 = pHead2;

		while(pTailNode1->_pNext)
		{
			pTailNode1 = pTailNode1->_pNext;
		}
		while(pTailNode2->_pNext)
		{
			pTailNode2 = pTailNode2->_pNext;
		}
		if(pTailNode2 == pTailNode1)
		{
			return 1;
		}
		else
		{
			return 0;
		}
	}
	else if(pMeetNode1 && pMeetNode2)
	{
		PNode pCurNode = pMeetNode1;
		while(pCurNode->_pNext != pMeetNode1)
		{
			if(pCurNode == pMeetNode2)
			{
				return 2;
			}
			pCurNode = pCurNode->_pNext;
		}
		return 0;
	}
	else
	{
		return 0;
	}
}







test.c



void Test6()
{
	Node *Node = NULL;
	InitList(&Node);
	PushBack(&Node, 1);
	PushBack(&Node, 2);
	PushBack(&Node, 3);
	PushBack(&Node, 4);
	PushBack(&Node, 5);
	PushBack(&Node, 6);
	PushBack(&Node, 7);
	PrintList(Node);
	JosephCircle(&Node, 3);
	PrintList(Node);
}

void Test7()
{
	Node *Node = NULL;
	InitList(&Node);
	PushBack(&Node, 1);
	PushBack(&Node, 2);
	PushBack(&Node, 3);
	PushBack(&Node, 4);
	PushBack(&Node, 5);
	PushBack(&Node, 6);
	PushBack(&Node, 7);
	PrintList(Node);
	PrintFromTail2Head(Node);
	PrintList(Node);
	InsertNotHead(Find(Node, 5),8);
	PrintList(Node);
}

void Test8()
{
	Node *Node = NULL;
	InitList(&Node);
	PushBack(&Node, 1);
	PushBack(&Node, 2);
	PushBack(&Node, 3);
	PushBack(&Node, 4);
	PushBack(&Node, 5);
	PushBack(&Node, 6);
	PushBack(&Node, 7);
	PrintList(Node);
	DeleteNotTailNode(Find(Node,4));
	PrintList(Node);
}

void Test9()
{
	Node *Node = NULL;
	InitList(&Node);
	PushBack(&Node, 1);
	PushBack(&Node, 2);
	PushBack(&Node, 3);
	PushBack(&Node, 4);
	PushBack(&Node, 5);
	PushBack(&Node, 6);
	//PushBack(&Node, 7);
	PrintList(Node);
	PrintList(FindMidNode(Node));
	PrintList(FindLastKNode(Node, 3));
}

void Test10()
{
	Node *Node = NULL;
	InitList(&Node);
	PushBack(&Node, 6);
	PushBack(&Node, 2);
	PushBack(&Node, 3);
	PushBack(&Node, 7);
	PushBack(&Node, 5);
	PushBack(&Node, 1);
	PrintList(Node);
	BubbleSort(Node);
	PrintList(Node);
}

void Test11()
{
	Node *Node1 = NULL;
	Node *Node2 = NULL;
	Node *TailNode = NULL;
	int ret = 0;
	InitList(&Node1);
	InitList(&Node2);
	PushBack(&Node1, 1);
	PushBack(&Node1, 2);
	PushBack(&Node1, 3);
	PushBack(&Node1, 4);
	PushBack(&Node1, 5);
	PushBack(&Node1, 6);
    PushBack(&Node2, 4);
    PushBack(&Node2, 5);
	TailNode = Back(Node2);
	TailNode->_pNext = Find(Node1, 2);
    ret = IsListCross(Node1, Node2);
	printf("%d\n", ret);
	TailNode = GetCrossNode(Node1, Node2);
	PrintList(TailNode);

}
void Test12()
{
	Node *Node = NULL;
	InitList(&Node);
	PushBack(&Node, 1);
	PushBack(&Node, 2);
	PushBack(&Node, 3);
	PushBack(&Node, 4);
	PushBack(&Node, 5);
	PushBack(&Node, 6);
	PrintList(Node);
	ReverseList_P(&Node);
	PrintList(Node);
}

void Test13()
{
	Node *Node1 = NULL;
	Node *Node2 = NULL;
	Node *NewNode = NULL;
	InitList(&Node1);
	InitList(&Node2);
	PushBack(&Node1, 1);
	PushBack(&Node1, 1);
	PushBack(&Node1, 3);
	PushBack(&Node1, 4);
	PushBack(&Node1, 4);
	PushBack(&Node1, 6);
	PushBack(&Node2, 2);
	PushBack(&Node2, 2);
	PushBack(&Node2, 3);
	PushBack(&Node2, 4);
	PushBack(&Node2, 5);
	PushBack(&Node2, 5);
	NewNode = MergeList(Node1, Node2);
	PrintList(NewNode);
}

void Test14()
{
	Node *Node1 = NULL;
	Node *Node2 = NULL;
	Node *TailNode = NULL;
	size_t ret = 0;
	
	InitList(&Node1);
	InitList(&Node2);
	PushBack(&Node1, 1);
	PushBack(&Node1, 2);
	PushBack(&Node1, 3);
	PushBack(&Node1, 4);
	PushBack(&Node1, 5);
	PushBack(&Node1, 6);
	
	TailNode = Back(Node1);
	TailNode->_pNext = Find(Node1, 2);
    ret = GetCircleLen(HasCircle(Node1));
	TailNode = GetEnterNode(Node1, HasCircle(Node1));
	TailNode->_pNext = NULL;
	PrintList(TailNode);
}


void Test15()
{
	Node *Node1 = NULL;
	Node *Node2 = NULL;
	Node *TailNode1 = NULL;
	Node *TailNode2 = NULL;
	size_t ret = 0;

	InitList(&Node1);
	InitList(&Node2);
	PushBack(&Node1, 1);
	PushBack(&Node1, 2);
	PushBack(&Node1, 3);
	PushBack(&Node1, 4);
	PushBack(&Node1, 5);
	PushBack(&Node1, 6);

	
	PushBack(&Node2, 0);
	PushBack(&Node2, 7);
	PushBack(&Node2, 9);
	PushBack(&Node2, 8);

	TailNode1 = Back(Node1);
	TailNode1->_pNext = Find(Node1, 4);

	TailNode2 = Back(Node2);
	TailNode2->_pNext = Find(Node1, 3);

	ret = IsCrossWithCircle(Node1, Node2);
	if(ret == 0)
	{
		printf("这两个链表不相交\n");
	}
	if(ret == 1)
	{
		printf("这两个不带环链表相交\n");
	}
	if(ret == 2)
	{
		printf("这两个带环链表相交\n");
	}
}




int main(){Test11();system("pause");return 0;}



























                

        

        

    




    

      

        

            

              
                
                  摩天轮的思念
                
              
            

            

                关注
              
            

        

        

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

      

      










                



	

		

			

				
					
单链表部分操作

				
			

			

				

					喵喵的博客
				

				

					06-14
					
					383
					
				

			

		

		

			
				
部分链表知识？


链表中数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域

			
		

	



                

              
                



	

		

			

				
					
单链表实现一个栈

				
			

			

				

					FlyingPig
				

				

					10-12
					
					2558
					
				

			

		

		

			
				
单链表实现的一个栈，只实现了栈的主要功能：push pop

			
		

	



                


  
              

                


	

		

			

				
					
带头结点双向循环 -- 双向链表

				
			

			

				

					qq_53010164的博客
				

				

					04-06
					
					2967
					
				

			

		

		

			
				
一、双向链表初始化
图解：phead链表的最后一个节点要指向第一个节点，第一个节点要指向最后一个节点，而第一个节点和最后一个节点都是第一个节点，所以phead->next = phead->prev = phead;



代码：


LTNode* InitList()
{
	//带头节点，循环链表
	//哨兵位头结点
	LTNode* phead = (LTNode*)malloc(sizeof(LTNode));
	phead->next = phead->prev = phe

			
		

	





	

		

			

				
					
C语言初阶数据结构（三）双向链表(保姆级别详细图解，轻松上手，通俗易懂)

				
			

			

				

					qq_54469537的博客
				

				

					04-19
					
					2196
					
				

			

		

		

			
				
保姆级别C语言双向链表



			
		

	



		

			
		



	

		

			

				
					
[ 数据结构_C实现 ] 双向循环带头链表的简单实现

				
			

			

				

					CSDN博客
				

				

					03-22
					
					3413
					
				

			

		

		

			
				
目录

1.双向循环带头链表的介绍。

2.双向循环带头链表的接口。

3.接口实现。

3.1创建新节点

3.2创建返回链表的头结点

3.3打印链表

3.4双向链表查找

3.5双向链表在pos的前面进行插入

3.5.1 头插

3.5.2 尾插

3.6双向链表删除pos位置的节点

3.6.1 尾删

3.6.2 头删

4.菜单

5.完整代码：

6.功能测试：



1.双向循环带头链表的介绍。

所谓双向循环带头链表可以分为以下3类来进行理解：

首先是双向：双向表示后一个节点可以找到

			
		

	





	

		

			

				
					
带表头结点的单链表ADT_HeaderList

				
			

			

				

					GKHack's Blog
				

				

					09-27
					
					3075
					
				

			

		

		

			
				
单链表的衍生，许多函数和单链表想同，多了一个first表头结点。
带表头结点的数据域element不存放线性表中的元素，要么为空，要么存放辅助数据。
有了表头结点以后，单链表中每个元素结点都有一个前驱结点，简化了插入和删除操作的描述。
给出构造函数，插入函数以及删除函数的实现代码。


实现代码：
template
HeaderList::HeaderList()
{
	Node *

			
		

	





	

		

			

				
					
单链表的快速排序算法

				
			

			

				

					09-15
				

			

		

		

			
				
在计算机科学中，链表是数组的一种补充，尤其在动态内存分配和处理大容量数据时表现出优越性。快速排序算法，是排序算法中的经典之作，由英国计算机科学家C.A.R. Hoare在1960年提出，以其高效的平均性能而闻名。  ...

			
		

	





	

		

			

				
					
数据结构c++顺序表、单链表的基本操作,查找、排序代码借鉴.pdf

				
			

			

				

					11-28
				

			

		

		

			
				
【数据结构C++顺序表与单链表的基本操作】  顺序表和单链表是数据结构中两种基础且重要的线性表实现方式。在C++中，它们被广泛用于存储和处理数据。  1. **顺序表**：  - **存储结构**：顺序表是一种将元素按顺序...

			
		

	





	

		

			

				
					
基于单链表实现集合的并交差运算实验报告.pdf

				
			

			

				

					10-18
				

			

		

		

			
				
首先，我们来看看单链表的基本概念和操作。  单链表是一种线性数据结构，其中每个节点包含一个数据元素和一个指向下一个节点的指针。在本实验中，节点的数据类型为`ElemType`，通常为字符类型`char`，而节点结构定义...

			
		

	





	

		

			

				
					
用单链表实现任意两个一元多项式的加、减法运算

				
			

			

				

					04-21
				

			

		

		

			
				
编程实现以下功能： ①分别输入一元多项式pn (x)和Q n (x)。  从键盘输入一元对项式中各项的系数和...⑦由程序从所存文件中读出多项式的系数和指数，重新构建一元多项式 Pn (x) 和Q n (x)，并可对其再次进行运算操作。

			
		

	





	

		

			

				
					
C++ 实现 链表的操作

				
			

			

				

					05-30
				

			

		

		

			
				
链表分为单链表、双链表等类型，这里我们主要讨论单链表。  在C++中，实现链表通常涉及创建两个类：链表类（LinkList）和链表节点类（LinkNode）。链表类用于管理链表的整体操作，如插入、删除和遍历；链表节点类...

			
		

	





	

		

			

				
					
双链表详解

				
			

			

				

					weixin_63246064的博客
				

				

					02-15
					
					6120
					
				

			

		

		

			
				
目录

一.双链表的定义

二.要实现的功能

三.功能实现

0、创建结点

1、初始化

2、打印

3、尾插

4、尾删

5、头插

6、头删

7、任意插入

8、任意删除

9、查找

四.全部代码的实现

1、text.c

2、List.c

3、List.h

一.双链表的定义






由图这就是一个双链表，可以看出它是一个由尾和头双向指向的环，且每个结点之间都是双向指向的。


二.要实现的功能


双链表是一种数据结构，所谓数据结构就是用来储存数据的工具，功能大致就和基本储存数据的

			
		

	





	

		

			

				
					
单链表补充-基本操作

				
			

			

				

					netmonky的博客
				

				

					01-30
					
					83
					
				

			

		

		

			
				
结构体定义：
**typedef int ElemType;
typedef struct LNode{
ElemType data;         //数据域
struct LNode next;   //指针域
}LinkList;
1.初始化
功能：构造一个空表
算法：
int Init_List(LinkList &L){
	L=new LNode;
	L->next=NULL;    //不带头结点链表初始化：L=NULL；
	return 1;
}

2.销毁
功能：销毁单链表，

			
		

	





	

		

			

				
					
单链表的操作和合并

				
			

			

				

					From now on...的Blogs
				

				

					10-07
					
					426
					
				

			

		

		

			
				
带有头结点的单链表的操作

包含的操作有：

对一条链表进行操作


1、初始化，建立头节点
    LinkList init(LinkList L)
2、头插法插入链表节点
    Status insert_head(LinkList L)
3、尾插法插入链表节点
    Status insert_tail(LinkList L)
4、返回第一个值为e的节点的地址
    LNod...

			
		

	





	

		

			

				
					
assert()函数用法总结

				
			

			

				

					Mr_sunp的博客
				

				

					08-09
					
					1302
					
				

			

		

		

			
				
程序一般分为Debug版本和Release版本，Debug版本用于内部调试，Release版本发行给用户使用。 
断言assert是仅在Debug版本起作用的宏，它用于检查“不应该”发生的情况。以下是一个内存复制程序，在运行过程中，如果assert的参数为假，那么程序就会中止（一般地还会出现提示对话，说明在什么地方引发了assert）。 



assert不是一个仓促拼凑起来的宏，为了

			
		

	





	

		

			

				
					
LC53最大子数组和、lc5最长回文子串、lc283移动零

					
最新发布

				
			

			

				

					m0_47536537的博客
				

				

					07-14
					
					224
					
				

			

		

		

			
				
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。

			
		

	





	

		

			

				
					
计算机软件技术基础：单链表删除操作解析

				
			

			

				

					
				

			

		

		

			
				
"单链表的删除操作-软件技术基础学习课件"  本文将深入探讨在软件技术基础中，特别是数据结构与算法部分的一个关键概念——单链表的删除操作。单链表是一种线性数据结构，其中每个元素（节点）包含数据和一个指向下...

			
		

	



              



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

  

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

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值