链表面试题总汇

最新推荐文章于 2024-01-08 19:16:19 发布

时光若止-Dale

最新推荐文章于 2024-01-08 19:16:19 发布

阅读量227

点赞数

分类专栏：楠

本文链接：https://blog.csdn.net/qq_36782456/article/details/73611218

版权

楠专栏收录该内容

65 篇文章 0 订阅

订阅专栏

1.比较顺序表和链表的优缺点，说说它们分别在什么场景下使用？

1.首先我们从2种结构的结构上来进行分析：
        （1）对于顺序表。不论是静态的还是动态的，他们都是连续的存储空间，在读取上时间效率比较快，可以通过地址之间的运算来进行访问，但是在插入和删除操作会出现比较麻烦的负载操作，尾插时比较方便。
        （2）对于链表，因为他是链式存储。在我们需要的时候才在堆上开辟空间，对于插入查找的方式比较便携。但是对于遍历的话需要多次的空间跳转。
    2.从2种结构的空间申请方式来看：
        （1）顺序表的空间开辟是在满的时候进行多空间的申请开辟。往往存在着2^n的开辟原则。在开辟次数比较多的时候，会出现比较大的空间浪费。
        （2）链表的空间开辟是针对于单个节点的空间开辟访问，不存在多余的空间浪费。并且在碎片内存池的机制下。可以有效地利用空间。
        通过上面的总结，可以分析出顺序表往往用于查找遍历操作比较频繁的情况下使用。链表则针对于数据删除修改的多操作性上的情况下使用。
    分别是空间上和时间上的优势与缺陷的不同。

2.从尾到头打印单链表

//递归遍历,带头结点
void PrintList_rever(ListNode* Head)
{
    if(Head != NULL || Head->next == NULL)
    {
       ListNode* plist = Head->next;
       if(plist->next != NULL)
       {
          PrintList_rever(plist->next);
       }
       printf("%d ",plist->data);
    }
    return;
   
}
//从头到尾遍历，从尾到头打印，可以利用栈的性质  先进后出

void PrintList_rever(ListNode* Head)
{
    stack<ListNode*> s;//建立一个栈对象
  if(Head != NULL || Head->next == NULL)
  return;
  ListNode* plist = Head->next;
  while(plist != NULL)
  {
    s.push(plist);//入栈操作
    plist=plist->next;
  }
   while(! s.empty()) //出栈操作
   {
       plist = s.top();
       printf("%d ",plist->data);
       s.pop();
   }
 }

3.删除一个无头单链表的非尾节点

void DeleteNotTailNode(PNode pos)
{
	assert(pos);
	//我们可以删除给定节点的后一个节点（可以交换当前节点与后一个节点的data，然后删除后一个节点）
	PNode ppos = pos->_next;
	pos->data = ppos->data;
	pos->_next = ppos->_next;
	delete ppos;

}

4.在无头单链表的一个节点前插入一个节点

void InsertNotHeadNode(PNode pos, DataType data)
{
	//创建一个新的节点(用pos->data)，连接到pos后面，然后把data 赋值给pos
	assret(pos);
	PNode newnode = BuyNode(pos->data);
	PNode ppos = pos->_next;
	newnode->_next = ppos;
	pos->_next = newnode;
	pos->data = data;
}

5.单链表实现约瑟夫环

PNode JosephCircle(PNode pHead, size_t M)
{
	//约瑟夫环：利用cur定位
	//首先使环循环
	PNode  cur = pHead;
	while (cur)
		cur = cur->_next;
	pHead = cur->_next;   
	cur = pHead;
	while (cur->_next != cur){
		for (int i = 1; i<M; i++){
			cur = cur->_next;
		}
		PNode temp = cur->_next;
		cur->_next = cur->_next->_next;
		printf("%d ", temp->data);
		free(temp);
		temp = NULL;
		cur= cur->_next;
	}
	printf("\n最后留下的人是：%d\n", cur->data);
}

6.逆置/反转单链表

// 逆置单链表--三个指针
PNode ReverseList(PNode pHead)
{
	if (pHead == NULL || pHead->_next == NULL)
		return pHead;
	PNode prev = pHead;
	PNode pcur = pHead->_next;
	PNode pnext = pcur->_next;


	while (pnext != NULL)
	{
		pcur->_next = prev;//核心，回指
		prev = pcur;
		pcur = pnext;                  //prev（尾指针）   没有指向空
		pnext = pnext->_next;
	}
	pcur->_next = prev;
	pHead->_next = NULL;
	return pcur;

}
// 逆置单链表--头插法
PNode ReverseList_P(PNode pHead)
{
	if (pHead == NULL || pHead->_next == NULL)
		return pHead;
	PNode prev = pHead;
	PNode pcur = pHead->_next;
	PNode pnext = pcur->_next;
	PNode newhead = pHead;
	while (pnext != NULL)
	{
		prev->_next = pnext;
		pcur->_next = newhead;
		newhead = pcur;
		pcur = pnext;
		pnext = pnext->_next;
	}
	prev->_next = NULL;
	pcur->_next = newhead;
	return pcur;
}

7.单链表排序（冒泡排序&快速排序）

void BubbleSort(PNode pHead)
{
	assert(pHead);
	if (pHead->_next == NULL)
		return ;
	PNode cur = pHead;
	while (cur != NULL)
	{
		for (PNode temp = pHead; temp->_next != NULL; temp = temp->_next)
		{
			if (temp->data > temp->_next->data)
			{
				swap(temp->data, temp->_next->data);
			}
		}
		cur = cur->_next;
	}
}

8.合并两个有序链表,合并后依然有序

PNode MergeList(PNode pHead1, PNode pHead2)   //递归实现
{
	if (pHead1 == NULL)
		return pHead2;
	else if (pHead2 == NULL)
		return pHead1;
	PNode newhead = NULL;
	if (pHead1->data < pHead2->data)
	{
		newhead = pHead1;
		newhead->_next = MergeList(pHead1->_next, pHead2);
	}
	else
	{
		newhead = pHead2;
		newhead->_next = MergeList(pHead1, pHead2->_next);
	}
	return newhead;
}

9.查找单链表的中间节点，要求只能遍历一次链表

PNode FindMidNode(PNode pHead)
{
	//两个指针，一快一慢，慢的走一步，快的走两步
	if (pHead == NULL || pHead->_next == NULL)
		return pHead;
	PNode pslow = pHead;
	PNode pfast = pHead;
	while (pfast != NULL && pfast->_next != NULL)
	{
		pslow = pslow->_next;
		pfast = pfast->_next->_next;
	}
	return pslow;

}

10.查找单链表的倒数第k个节点，要求只能遍历一次链表

PNode FindLastKNode(PNode pHead, size_t K)
{
	if (pHead == NULL || K == 0)
		return  NULL;
	PNode pfast = pHead;
	PNode pslow = pHead;
	while (--K)
	{
		pfast = pfast->_next;
		if (pfast == NULL)
			return pHead;
	}
	while (pfast->_next != NULL)
	{
		pfast = pfast->_next;
		pslow = pslow->_next;

	}
	return pslow;
}

11、判断链表是否存在环，一快一慢两个指针，如果相遇，一定在环上,返回环上任意节点，不满足返回空

PNode MeetingNode(PNode pHead)
{
	assert(pHead);
	PNode pSlow = pHead->_next;
	if (pSlow == NULL)
		return NULL;
	PNode pFast = pSlow->_next;
	while (pFast && pSlow)
	{
		if (pFast == pSlow)
			return pFast;
		pSlow = pSlow->_next;
		pFast = pFast->_next;
		if (pFast != NULL)
			pFast = pFast->_next;
	}
	return NULL;
}

12、若存在环，得到环中节点数目，并找到环的入口点

PNode EntryNodeOfLoop(PNode pHead)
{

	PNode meetingNode = MeetingNode(pHead);  //找到环上节点
	PNode cur = meetingNode->_next;
	int nodenumLoop = 1;
	while (cur != meetingNode)   //计算环上节点个数
	{
		nodenumLoop++;
		cur = cur->_next;
	}
	                //定义两个指针，一个走环上节点个数步，再一起走，相遇的地方便是节点入口
	cur = pHead;
	while (--nodenumLoop)
	{
		cur = cur->_next;
	}
	PNode pnext = pHead;
	while (cur != pnext)
	{
		cur = cur->_next;
		pnext = pnext->_next;
	}
	return cur;

}

13、复杂链表的复制（有任意指向的_sibling指针）

PNode CopyComplexofList(PNode pHead)
{
	assret(pHead);
	PNode cur = pHead;
	//链表节点的复制与链接
	while (cur)
	{
		PNode newcur = new Node;   
		newcur->data = cur->data;
		newcur->_next = cur->_next;
		newcur->_sibling = NULL;
		cur->_next = newcur;
		cur = cur->_next->_next;
	}
	//PNode _sibling  任意指向的指针（sibling节点的链接）
	cur = pHead;
	PNode newcur = pHead;
	while (cur)             //任意节点的复制
	{
	    newcur = cur->_next;
		if (cur->_sibling)
		newcur->_sibling = cur->_sibling->_next;
		cur = cur->_next->_next;
	}
     //    链表分离
	PNode NewHead = pHead->_next;
	PNode pnewcur = NewHead;
	cur = pHead;
	pnext = pHead->next->next;
	while (pnext)
	{
		cur->next = pnext;
		pnext = pnext->next;
		pnewcur->next = pnext;
		pnext = pnext->next;

		cur = cur->next;
		pnewcur = pnewcur->next;

	}
	return NewHead;
}

14、判断两个链表(不带环)是否相交

bool IntersectNode(PNode pHead1,PNode pHead2)
{
	//方法一：判断第一个链表的每个节点是否在第二个链表中，时间复杂度为lengthL*lengthH
	//方法二：利用计数方法，给第一个链表节点地址进行哈夫曼编码存档，第二个链表节点地址进行hash表的查看，时间复杂度L+H
	//方法三：判断两个链表相交，可以把第二个链表的头结点接在第一个链表的尾节点
	          //遍历第一个链表，如果的带环，则两个链表一定相交
	//方法四：如果两个链表不带环，相交，则最后一个节点一定是链表所共有的
	         //遍历第一个链表，记住尾节点，在遍历第二个链表，尾节点相比较
	assert(pHead1 && pHead2);
	PNode pcur1 = pHead1;
	PNode pcur2 = pHead2;
	while (pcur1->_next)
	{
		pcur1 = pcur1->_next;
	}
	while (pcur2->_next)
	{
		pcur2 = pcur2->_next;
	}
	if (pcur1 == pcur2)
	{
		return true;
	}
	return false;
	//求交点就要把第二个头结点连载第一个尾节点的后面，然后求环的个数，再求交点
}

15、两个不带环链表相交的第一个公共节点

PNode FindFirstCommonNode(PNode pHead1, PNode pHead2)
{
	assert(pHead1 && pHead2);
	PNode pcur1 = pHead1;
	PNode pcur2 = pHead2;
	int count1, count2, k;
	//利用栈的性质，分别把两个链表的节点放入两个栈中，然后取出节点进行比较
	//求交点就要把第二个头结点连载第一个尾节点的后面，然后求环的个数，再求交点
	//分别遍历两个链表，求出节点个数，让长的链表先走n步，再一起走，边走边比较，
	while (pcur1)
	{
		++count1;
		pcur1 = pcur1->_next;
	}
	while (pcur2)
	{
		++count2;
		pcur2 = pcur2->_next;
	}
	if (count1 >= count2)
	{
		k = count1 - count2;
		while (k--)
		{
			pcur1 = pcur1->_next;
		}
	}
	else
	{
		k = count2 - count1;
		while (k--)
		{
			pcur2 = pcur2->_next;
		}
	}
	while (pcur1 != pcur2 && pcur1 != NULL && pcur2 != NULL)
	{
		pcur1 = pcur1->_next;
		pcur2 = pcur2->_next;
	}
	return pcur1;
}

16、判断两个链表(可能带环)是否相交，求交点

PNode IsListCroseWithCycle(PNode pHead1, PNode pHead2)//带环链表是否相交
                       //第一种：两个都不带
                       //第二种：两个都带环                                       
                       //第三种：一个带，一个不带，不可能相交
{
	
	PNode meetingnode1 = MeetingNode(pHead1);//判断链表是否带环
	PNode meetingnode2 = MeetingNode(pHead2);
	PNode pcur1 = pHead1;
	PNode pcur2 = pHead2;
	PNode meetingnode = NULL;
	if (meetingnode1 == NULL && meetingnode2 == NULL)//不带环，判断是否相交，若相交，求环的交点
	{
		while (pcur1->_next)
			pcur1 = pcur1->_next;
		pcur1->_next = pcur2;//第二个头连载第一个尾后面
		pcur1 = pHead1;
		PNode Ajust = MeetingNode(pcur1);//判断是否存在环
		if (Ajust == NULL)
			return  NULL;
		else //连上之后存在环
		{
			 meetingnode = EntryNodeOfLoop(pcur1);//找到相交点
			 while (pcur1)          //复原两个链表
			 {
				 if (pcur1->_next == pcur2)
				 {
					 pcur1->_next == NULL;
				 }
				 pcur1 = pcur1->_next;
			 }
			 return meetingnode;
		}
	}
		
	else if(meetingnode1 != NULL && meetingnode2 != NULL) //两个都带环（公用一个环）
	{

		PNode meetingnode = EntryNodeOfLoop(pcur1);
		return meetingnode;
	}
	else //一个链表带环，一个链表不带环

    return NULL;
}