单链表的补充操作

最新推荐文章于 2023-05-21 16:50:49 发布
原创 最新推荐文章于 2023-05-21 16:50:49 发布 · 331 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#单链表 #算法 #数学 #应用 #c语言

约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知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;}


























                

        

    

    
  



    



                



	

		

			

				
					
6-4 带头结点的单链表插入操作 (10 分）

				
			

			

				

					qq_hua_xia的博客
				

				

					05-05
					
					6493
					
				

			

		

		

			
				
6-4 带头结点的单链表插入操作 (10 分)

本题要求实现带头结点的单链表插入操作，插入成功返回1，否则返回0。

函数接口定义：


int insert_link ( LinkList L,int i,ElemType e);

L是单链表的头指针，i为插入位置，e是插入的数据元素，插入成功返回1，否则返回0。

裁判测试程序样例：

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

typedef int ElemType;
typede...

			
		

	



                

            
              



	

		

			

				
					
单链表基本操作的实现——前插法与后插法创建单链表

				
			

			

				

					qq_57867712的博客
				

				

					11-07
					
					7123
					
				

			

		

		

			
				
一、前插法创建单链表

算法步骤：

（1）创建一个只有头结点的空链表。

（2）根据创建链表包括的元素n，循环n次以下操作：

     生成新结点；——>输入元素值赋给新结点数据域；——>将新结点插入到头结点之后。




//前插法创建单链表
void CreateList_H(LinkList &L,int n)
{
    //逆位序输入n个元素的值，建立带头结点的单链表L
    L=new LNode;//先建立一个带头结点的单链表
    L->next...

			
		

	



              


  
              

                


	

		

			

				
					
单链表补充-基本操作

				
			

			

				

					netmonky的博客
				

				

					01-30
					
					131
					
				

			

		

		

			
				
结构体定义：
**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.销毁
功能：销毁单链表，

			
		

	





	

		

			

				
					
数据结构（补）——单链表

				
			

			

				

					初叙
				

				

					11-17
					
					150
					
				

			

		

		

			
				
一、基本实现


class Link<T> {
    class Entry<T> {
        private T data;
        private Entry<T> next;

        //头结点
        public Entry() {
            this.data = null;
           ...

			
		

	



		

			
		



	

		

			

				
					
带表头结点的单链表ADT_HeaderList

				
			

			

				

					GKHack's Blog
				

				

					09-27
					
					3135
					
				

			

		

		

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


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

			
		

	





	

		

			

				
					
assert()函数使用

				
			

			

				

					P_royal的博客
				

				

					11-19
					
					634
					
				

			

		

		

			
				
assert()函数使用

			
		

	





	

		

			

				
					
assert()函数用法总结

				
			

			

				

					Mr_sunp的博客
				

				

					08-09
					
					1385
					
				

			

		

		

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



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

			
		

	





	

		

			

				
					
单链表的基本操作-查找

				
			

			

				

					w_nxsxs的博客
				

				

					11-03
					
					3607
					
				

			

		

		

			
				
【问题描述】

实现有头结点单链表查找算法：根据关键字值查找其在单链表中的位置(第一次出现的位置)。

【输入形式】

第一行输入整数n（n不大于1000），表示单链表长度；

第二行输入若干个整数（以非法整数或文件末尾作为结束），表示欲查找的关键字值；

【输出形式】

输出每个关键字值在单链表中的位置。若未找到，输出“no”。

【样例输入】

5

10 56 -34 -2 90

90

-100

34

56

e

【样例输出】

5

no

no

2

单链表的查找算法

链表的访问均从

			
		

	





	

		

			

				
					
单链表（带头结点）的基本操作

				
			

			

				

					H643511的博客
				

				

					09-27
					
					6373
					
				

			

		

		

			
				
带头结点的单链表的基本操作基本概念单链表的定义初始化单链表单链表表长头插法建立单链表的操作尾插法建立单链表的操作按元素查找按位置查找单链表插入数据删除数据判空操作输出清空表
基本概念
线性表的链式存储又称单链表，它是通过一组任意的存储单元来存储线性表中的数据元素。为了建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息外，还需要存放一个指向其后继的指针。
单链表的定义
定义该结点的数据和后继的指针的地址
typedef struct LNode
{
	LNode* next;
	ElemType

			
		

	





	

		

			

				
					
单链表插入操作。

					
最新发布

				
			

			

				

					03-24
				

			

		

		

			
				
好的，用户想了解如何在单链表中实现插入操作。我需要根据提供的引用内容来整理回答。首先，单链表的结构是由节点组成，每个节点包含数据域和指向下一个节点的指针。插入操作有三种情况：头部、中间和尾部插入。  ...

			
		

	





	

		

			

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

				
			

			

				

					qq_53010164的博客
				

				

					04-06
					
					3228
					
				

			

		

		

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



代码：


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

			
		

	





	

		

			

				
					
数据结构初阶——进阶链表

				
			

			

				

					m0_64607843的博客
				

				

					05-12
					
					780
					
				

			

		

		

			
				
来体验双向带头循环链表的魅力吧，内含链表代码，跟我一起实现5分钟手搓链表吧！！！






































































...

			
		

	





	

		

			

				
					
数据结构——双向链表

				
			

			

				

					dongxue727504的博客
				

				

					03-14
					
					1400
					
				

			

		

		

			
				
5000字带头双向链表内容，以及尾插尾删等操作讲解。

			
		

	





	

		

			

				
					
[数据结构] 双向链表

				
			

			

				

					weixin_74461263的博客
				

				

					05-21
					
					106
					
				

			

		

		

			
				
相较于单链表，有一种更优的链表，下面我来介绍一下双向链表的相关知识。一、双向循环链表的实现双向链表在创建时会建立两个指针，可以向前链接，也可以向后链接；如图所示：这就是对双向链表的简要介绍，更新不易，希望各位小伙伴动动小手，三连走一走，你们的三连对我真的很重要！！！！！

			
		

	





	

		

			

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

				
			

			

				

					qq_54469537的博客
				

				

					04-19
					
					3006
					
				

			

		

		

			
				
保姆级别C语言双向链表



			
		

	





	

		

			

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

				
			

			

				

					优快云博客
				

				

					03-22
					
					3632
					
				

			

		

		

			
				
目录

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类来进行理解：

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

			
		

	





	

		

			

				
					
双链表详解

				
			

			

				

					weixin_63246064的博客
				

				

					02-15
					
					6326
					
				

			

		

		

			
				
目录

一.双链表的定义

二.要实现的功能

三.功能实现

0、创建结点

1、初始化

2、打印

3、尾插

4、尾删

5、头插

6、头删

7、任意插入

8、任意删除

9、查找

四.全部代码的实现

1、text.c

2、List.c

3、List.h

一.双链表的定义






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


二.要实现的功能


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

			
		

	





	

		

			

				
					
数据结构（初阶）—— C语言实现双向带头循环链表

				
			

			

				

					M的博客
				

				

					04-07
					
					2173
					
				

			

		

		

			
				
双向循环链表

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值