热门题---链表面试题总结

最新推荐文章于 2022-01-01 22:05:06 发布
最新推荐文章于 2022-01-01 22:05:06 发布
阅读量336 收藏 1
点赞数 1
分类专栏： C语言 c++ c语言 c++基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z_xiao_xue/article/details/51748418
版权
C语言 同时被 3 个专栏收录
17 篇文章 0 订阅
订阅专栏
c++
14 篇文章 0 订阅
订阅专栏
c语言
13 篇文章 0 订阅
订阅专栏


单链表一直是面试中的重点，今天就把常见的单链表面试题总结了一下

冒泡排序：

先将tail置为空，让prev和cur不停的往前走，条件cur不等于tail 控制每一趟冒泡，找出每次的最大值，再用prev不等于tail控制每一层冒泡，每趟交换完成后将prev的值给tail，让tail 不停的往前走，

代码实现

void Bubble(pLinkList list)
{
	pLinkNode cur = NULL;
	pLinkNode prev = NULL;
	pLinkNode tail = NULL;
	int exage = 0;
	assert(list);
	cur = list->pHead;
	if (list->pHead == NULL)
	{
		return;
	}
	while (list->pHead != tail)
	{
		prev = list->pHead;
		cur = prev->next;
		while (cur != tail)
		{
			exage = 0;
			if (cur->data < prev->data)
			{
				DataType x = cur->data;
				cur->data = prev->data;
				prev->data = x;
				exage = 1;
			}
			prev = cur;
			cur = cur->next;
		}
		tail = prev;
		if (exage == 0)
		{
			return;
		}
	}
}

合并两个有序链表，合并后链表依然有序，

比较两条链表的第一个节点的大小，让新链表的头指向比较后的结果，如上图中指向第二条链表的第一个节点，则让指向cur2往后走，再与cur1进行比较，newhead的next指向下一个比较后的结果

代码实现

pLinkNode MerageSortList(pLinkList p1, pLinkList p2)//合并两个有序链表
{
	assert(p1);
	assert(p2);
	if (p1->pHead == NULL)
		return p2->pHead;
	if (p2->pHead == NULL)
		return p1->pHead;
	
	pLinkNode cur1 = p1->pHead;
	pLinkNode cur2 = p2->pHead;
	pLinkNode newHead = cur1->data < cur2->data ? p1->pHead:p2->pHead;

	pLinkNode Tail = newHead;

	while (cur1&&cur2)
	{
		if (cur1->data > cur2->data)
		{
			Tail ->next = cur1;
			cur1 = cur1->next;
		}
		else
		{
			Tail ->next = cur2;
			cur2 = cur2->next;
		}
		Tail = Tail->next;

		Tail->next = NULL;
	}

	if (cur1)
	{
		Tail->next = cur1;
	}
	if (cur2)
	{
		Tail->next = cur2;
	}
	return newHead;
}

约瑟夫环的问题

代码实现

pLinkNode JosePhCycle(pLinkList p, size_t m)//约瑟夫环
{
	pLinkNode cur = p->pHead;
	assert(p);

	while (1)
	{
		if (cur == NULL)
			return NULL;
		else if (cur == cur->next)//只剩一个节点了
			return cur;
		else
		{
			int x = m;
			
			while (--x)
			{
				cur = cur->next;
			}
			pLinkNode del = cur->next;
			cur->data = del->data;
			cur->next = del->next;
			free(del);
			del = NULL;

		}

	}

}

链表相交问题：

  1. 链表不带环相交

    （1）一旦两个链表相交，那么两个链表中的节点一定有相同地址。

（2）一旦两个链表相交，那么两个链表从相交节点开始到尾节点一定都是相同的节点。

 

只有这一种情况，一共有四种解决方法

  1. 直接将两个链表中的节点进行比较，如果节点相同就说明链表相交，如果直到其中一个链表遍历完都没有找到相同节点，说明链表不相交。但效率很低

  2. 如果两个链表相交，则链表最后一个节点肯定相同，则只需判断链表的最后一个节点是否相同，相同则说明两链表相交

  3. 将链表一的尾节点指针指向链表二的头节点，判断链表是否有环，如果链表有环则两链表相交，如果链表无环，则证明两链表不相交，优化想法：因为链表二的头节点肯定在环中，所以可以直接从链表二的头节点开始判断

  4. 将链表一建立hash表，用链表二中的节点在hash表中进行查询，看是否有相同节点，缺点：增加了内存消耗

代码实现

pLinkNode IslistCricle1(pLinkList plist1, pLinkList plist2)
{
	assert(plist1);
	assert(plist2);
	pLinkNode cur1 = plist1->pHead;
	pLinkNode cur2 = plist2->pHead;
	if (plist1->pHead == NULL)
	{
		printf("链表不相交\n");
		return NULL;
	}
	if (plist2->pHead == NULL)
	{
		printf("链表不相交\n");
		return NULL;
	}

	while (cur1 && cur2)
	{
		cur1 = plist1->pHead;
		while (cur1&&cur2)
		{
			if (cur1 == cur2)
			{
				printf("链表相交于%d结点\n", cur1->data);
				return cur1;
			}
			cur1 = cur1->next;
			//cur2 = cur2->next;
		}
		cur2 = cur2->next;
	}

	return NULL;
}

void IslistCricle2(pLinkList plist1, pLinkList plist2)
{
	assert(plist1);
	assert(plist2);
	pLinkNode cur1 = plist1->pHead;
	pLinkNode cur2 = plist2->pHead;
	
	if (plist1->pHead == NULL)
	{
		printf("链表不相交\n");
		return;
	}
	if (plist2->pHead == NULL)
	{
		printf("链表不相交\n");
		return;
	}

	while (cur1->next)
	{
		cur1 = cur1->next;
	}
	while (cur2->next)
	{
		cur2 = cur2->next;
	}

	if (cur1 == cur2)
	{
		printf("链表相交\n");
	}
	return;
}

pLinkNode IslistCricle3(pLinkList plist1, pLinkList plist2)
{
	assert(plist1);
	assert(plist2);
	pLinkNode cur1 = plist1->pHead;
	pLinkNode cur2 = plist2->pHead;

	if (plist1->pHead == NULL)
	{
		printf("链表不相交\n");
		return NULL;
	}
	if (plist2->pHead == NULL)
	{
		printf("链表不相交\n");
		return NULL;
	}
	while (cur2->next)
	{
		cur2 = cur2->next;
	}
	cur2->next = cur1;
	cur2 = plist2->pHead;
	cur1 = plist1->pHead;
	while (cur2&&cur2->next)
	{
		cur1 = cur1->next;
		cur2 = cur2->next->next;
		if (cur1 == cur2)
		{
			printf("链表相交\n");
			return cur1;
		}
	}

}

复杂链表的拷贝

代码实现

#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int  Datatype;

typedef struct Complex
{
	Datatype data;
	Complex* next;
	Complex* redom;
}Complex, *pComplex;

pComplex BuyNode(Datatype x)
{
	pComplex tmp = (pComplex)malloc(sizeof(Complex));
	if (tmp)
	{
		tmp->data = x;
		tmp->next = NULL;
		tmp->redom = NULL;
	}
	return tmp;
}

void Printf(pComplex head)
{
	while (head)
	{
		printf("head:%d,redom->%d\n", head->data, head->redom->data);
		head = head->next;
	}
}


pComplex CopyComplexLinkList(pComplex head)
{
	pComplex newhead = head;
	pComplex tail = head;
	pComplex cur = head;

	while (cur)
	{
		pComplex tmp = BuyNode(cur->data);
		tmp->next = cur->next;
		cur->next = tmp;
		cur = cur->next->next;
	}
	cur = head;
	while (cur)
	{
		cur->next->redom = cur->redom;
		cur = cur->next->next;
	}

	cur = head;
	newhead = cur->next;
	while (cur && cur->next)
	{
		tail = cur->next;
		tail = tail->next;
		cur->next = cur->next->next;
		cur = cur->next;
	}
	return newhead;
}



void Test()
{
	pComplex c1 = BuyNode(1);
	pComplex c2 = BuyNode(2);
	pComplex c3 = BuyNode(3);
	pComplex c4 = BuyNode(4);
	pComplex c5 = BuyNode(5);

	c1->next = c2;
	c2->next = c3;
	c3->next = c4;
	c4->next = c5;

	c1->redom = c3;
	c2->redom = c4;
	c3->redom = c5;
	c4->redom = c1;
	c5->redom = c2;

	c1 = CopyComplexLinkList(c1);

	Printf(c1);


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

下面是用c++的引用实现的一份功能相同的代码

代码实现

//冒泡排序
void Bubble(SListNode* pHead)
{
	int exange = 0;
	if (pHead == NULL || pHead->next == NULL)
	{
		return;
	}
	SListNode* prev = pHead;
	SListNode* cur = pHead->next;
	SListNode* Tail = NULL;
	while (Tail != pHead)
	{
		cur = pHead->next;
		prev = pHead;
		while (cur != Tail)
		{
			if (prev->data > cur->data)
			{
				DataType x;
				x = cur->data;
				cur->data = prev->data;
				prev->data = x;
			}
			prev = cur;
			cur = cur->next;
		}
		Tail = prev;
	}
}

//删除一个无头单链表的非尾节点
void DelNonTailNode(SListNode* pos)
{
	assert(pos);
	assert(pos->next);

	SListNode* del = pos->next;
	pos->data = del->data;
	pos->next = del->next;
	free(del);
	del = NULL;
}


//在无头单链表的非头节点插入一个节点
void InsertNonTailNode(SListNode* pos,DataType x)
{
	assert(pos);
	SListNode* cur = Buynode(pos->data);
	SListNode* temp = pos->next;
	cur->next = temp;
	pos->next = cur;
	pos->data = x;
}


//查找单链表的中间节点并只能遍历一次链表(快慢指针)

SListNode* FindMidNode(SListNode* pHead)
{
	assert(pHead);
	
	if (pHead->next == NULL)
	{
		return pHead;
	}
	else
	{
		SListNode* slow = pHead;
		SListNode* fast = pHead;
	/*	while (fast)
		{
			if (fast->next)
			{
				fast = fast->next->next;
			}
			else
			{
				break;
			}
			slow = slow->next;
		}*/
		while (fast && fast->next)
		{
			slow = slow->next;
			fast = fast->next->next;
		}
		return slow;
	}
	return NULL;
}

//查找链表的倒数第k个节点，且只能遍历链表一次

SListNode* FindNode(SListNode* pHead, int k)
{
	assert(pHead);
	assert(k >= 0);

	SListNode* slow = pHead;
	SListNode* fast = pHead;
	//有问题
	/*while (fast && fast->next)
	{
		while (k--)
		{
			fast = fast->next;
		}
		fast = fast->next;
		slow = slow->next;
	}*/
	while (fast && --k)
	{
		fast = fast->next;
		if (fast == NULL)
		{
			return NULL;
		}
	}

	while (fast->next)
	{
		fast = fast->next;
		slow = slow->next;
	}
	return slow;
}

//从尾到头打印单链表

void PrintTailToHead(SListNode* pHead)
{
	if (pHead == NULL)
	{
		return;
	}
	else
	{
		PrintTailToHead(pHead->next);
		printf("%d ", pHead->data);
	}
}


//逆置单链表   很重要
SListNode*  Reverse(SListNode* pHead)
{
	SListNode* cur = pHead;
	SListNode* newHead = NULL;
	
	while (cur)
	{
		SListNode* temp = cur;
		cur = cur->next;

		temp->next = newHead;
		newHead = temp;
	}
	return newHead;
}


//单链表实现约瑟夫环
//运行时先构造环，注意在代码结尾解环

SListNode* JosePhCycle(SListNode* pHead, int m)
{
	SListNode* cur = pHead;
	while (1)
	{
		if (cur == NULL)
		{
			return NULL;
		}
		else if (cur == cur->next)//只剩一个节点
		{
			return cur;
		}
		else
		{
			int x = m;
			while (--x)
			{
				cur = cur->next;
			}
			SListNode* del = cur->next;
			cur->data = del->data;
			cur->next = del->next;
			free(del);
			del = NULL;
		}
	}
	
}

//合并两个有序链表，合并后依然有序

SListNode* Meragelist(SListNode* pHead1, SListNode* pHead2)
{
	if (pHead1 == NULL)
	{
		return pHead2;
	}
	if (pHead2 == NULL)
	{
		return pHead1;
	}
	/*SListNode* newHead = pHead1->data < pHead2->data ? pHead1:pHead2;

	while (pHead1 == NULL || pHead2 == NULL)
	{
		if (pHead1->data < pHead2->data)
		{
			newHead = pHead1;
			pHead1 = pHead1->next;
		}
		else if (pHead1->data == pHead2->data)
		{
			newHead = pHead1;
			newHead->next = pHead2;
			pHead1 = pHead1->next;
			pHead2 = pHead2->next;
		}
		else
		{
			newHead = pHead2;
			pHead2 = pHead2->next;
		}
		newHead = newHead->next;
		newHead->next = NULL;
	}
	while (pHead1)
	{
		newHead->next = pHead1;
		pHead1 = pHead1->next;
	}
	while (pHead2)*/

	SListNode* newHead = NULL;
	SListNode* cur1 = pHead1;
	SListNode* cur2 = pHead2;
	if (cur1->data < cur2->data)
	{
		newHead = cur1;
		cur1 = cur1->next;
	}
	SListNode* Tail = newHead;
	while (cur1 && cur2)
	{
		if (cur1->data < cur2->data)
		{
			Tail->next = cur1;
			cur1 = cur1->next;
		}
		else
		{
			Tail->next = cur2;
			cur2 = cur2->next;
		}
		Tail = Tail->next;
		Tail->next = NULL;
	}
	if (cur1 != NULL)
	{
		Tail->next = cur1;
	}
	if (cur2 != NULL)
	{
		Tail->next = cur2;
	}
	return newHead;
}

//判断链表是否带环(可以用快慢指针解决)
bool IsSListCycle(SListNode* pHead)
{
	if (pHead == NULL)
	{
		printf("The SList is empty\n");
		return false;
	}
	SListNode* slow = pHead;
	SListNode* fast = pHead;

	while (fast && fast->next)
	{
		fast = fast->next->next;
		slow = slow->next;
		if (fast == slow)
		{
			SListNode* cur = slow;
			int length = 0;       //环的长度
			do
			{
				slow = slow->next;
				length++;

			} while (cur != slow);
			
			printf("%d\n", length);
			printf("The SList have cycle\n");
			return true;
		}
	}
	printf("The SList NO cycle\n");
	return false;
}

//环的入口点

SListNode* CycleEntry(SListNode* pHead)
{
	if (pHead == NULL)
	{
		printf("The SList is empty\n");
		return NULL;
	}
	SListNode* slow = pHead;
	SListNode* fast = pHead;

	while (fast && fast->next)
	{
		fast = fast->next->next;
		slow = slow->next;
		if (fast == slow)
		{
			return slow;
		}
	}
}

//链表是否相交，若相交，求交点（不带环）

SListNode* IsItersect(SListNode* pHead1,SListNode* pHead2)
{
	if (pHead1 == NULL)
	{
		printf("链表不相交\n");
		return pHead2;
	}
	if (pHead2 == NULL)
	{
		printf("链表不相交\n");
		return pHead1;
	}
	SListNode* cur1 = pHead1;
	SListNode* cur2 = pHead2;

	while (cur1 && cur2)
	{
		if (cur1 == cur2)
		{
			printf("链表相交，交点为：%d\n", cur1->data);
			return cur1;
		}
		cur1 = cur1->next;
		cur2 = cur2 ->next;
	}
	return NULL;
}



z_xiao_xue
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
服务器面试必备-redis面试题总结
网易搬砖选手
03-07 3万+
Redis 本质上是一个 Key-Value 类型的内存数据库，很像 memcached，整个数据库统统加载在内存当中进行操作，定期通过异步操作把数据库数据 flush 到硬盘上进行保存。因为是纯内存操作，Redis 的性能非常出色，每秒可以处理超过 10 万次读写操作，是已知性能最快的 Key-Value DB。
三种I/O复用函数的比较总结
z_xiao_xue的博客
03-30 1277
下列情况下可以用到I/O多路转接技术： 1.客户端程序要同时处理多个socket。(比如非阻塞的connect技术) 2.客户端程序要同时处理用户输入和网络连接。 3.TCP服务器要同时处理监听socket和连接socket。(I/O复用使用最多的场合) 4.服务器要同时处理TCP请求和UDP请求。 5.服务器要同时监听多个端口，或者处理多种服务。(xinetd服务) I/O复用虽然可
【java】遇到错误constructor ListNode in class ListNode cannot be applied to given types;
renxingzhadan的专栏
12-26 5912
如何解决
查找链表的中点if(fast!= NULL && fast->next != NULL) { //要用并运算，1->2中slow不能跳，所以要并运算fast->next != NULL
share
06-04 1608
找链表的中点。 样例 链表 1->2->3 的中点是 2。 链表 1->2 的中点是 1。 思路： 2个指针从链表的头开始。一个指针每步+1，一个指针每步+2然后跑的快的指针到链表尾部的时候，那个慢一点的指针就是中点了 /** * Definition of ListNode * class ListNode { * public: * in
JAVA-高频面试题汇总:链表
热门推荐
Apollo的博客
02-01 1万+
前言 为了让小伙伴们更好地刷题,我将所有leetcode常考题按照知识点进行了归纳。 高频题汇总: JAVA-高频面试题汇总:动态规划 JAVA-高频面试题汇总:字符串 JAVA-高频面试题汇总:二叉树(上) JAVA-高频面试题汇总:二叉树(下) JAVA-高频面试题汇总:回溯 JAVA-高频面试题汇总:链表 接下来还会进行其他模块的总结,有一起在准备暑期实习的JAVA后端的伙伴可以一起交流! 小编微信: Apollo___quan 目录 反转链表（剑指） 反转链表 II 两个链表的第一个公共节点（剑
经典面试题-环形链表 II
CltCj的博客
01-01 1006
经典面试题-环形链表 II前言142. 环形链表 II问题描述方法一方法二总结 前言 这是一道经典的面试题来源于力扣142. 环形链表 II 142. 环形链表 II 问题描述   给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。   如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：p
面试题总结：数组和链表的区别 数组和链表.pdf
04-18
面试题总结：数组和链表的区别 数组和链表.pdf
链表面试题总结
10-22
数据结构，链表所有综合面试题型汇总，有大神漏缺的给我留言
fe-interview-handwrite:前端面试常见手写题整理
04-27
前端面试手写题整理前端面试常见的手写题，面试出现概率极高，建议每个都过自己过一遍。你也可以提交 PR，提供你面试遇到的题目。代码汇总请参照 。高频：★★★ 中频：★★ 低频：★JavaScript 原理 ★★ ★★ ★★...
链表面试题目总结 全
09-05
链表是最基本的数据结构，凡是学计算机的必须的掌握的，在面试的时候经常被问到，关于链表的实现，百度一下就知道了。 在此总结一下与链表相关的练习题。题目很全，好好消化。
java 面试题 总结
09-16
通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。 8、EJB是基于哪些技术实现的？并说出Session...
面试热门题C与C++的区别-------指针和引用
z_xiao_xue的博客
09-11 1951
在面试过程中，C语言和C++的区别总是面试官的侧重点，而指针和引用更是容易被问到，指针和引用的区别很简单，但很少有人能有全面的，有层次有条理的回答这个问题，所以有条理的总结归纳就显得尤为重要。 先来了解什么是指针，什么是引用 指针：存储内存中某一块空间地址的变量。 引用：引用不是定义一个新变量，而是给一个已经定义的变量起一个新的别名。 定义的格式： 指针：类型 *变量名 = 已有变量地址
多种方法实现费波纳契数列
z_xiao_xue的博客
07-23 1073
费波纳契数描述的问题： 兔子的生长情况：1.第一个月有一对刚诞生的兔子                              2.第二个月之后（第三个月初）就可以生育                              3.每月每对可生育的兔子都会诞生下一对新的兔子                              4.兔子不会死去
简单的小游戏---代码实现三子棋
z_xiao_xue的博客
07-22 738
大家都玩过五子棋吧，在这里，我就来实现一个比五子棋低版本的小游戏，三子棋，仅供娱乐哦！！
I/O复用(三)---epoll机制
z_xiao_xue的博客
03-21 726
epoll实现机制分析： epoll是Linux特有的I/O复用函数。它在实现和使用上与select和poll有很大的差异。首先，epoll使用一组函数来完成任务，而不是单个的函数。其次，epoll把用户关心的文件描述符上的事件放在内核的一个时间表中，从而无需像select和epoll那样每次调用都要重复传入文件描述符和集或事件集。但epoll需要使用一个额外的文件描述符，来唯一标识内核中的这个
套接字socket实现UDP
z_xiao_xue的博客
03-11 691
TCP/UDP都是运输层协议，他们之间的最大区别就是TCP是面向连接的可靠传输协议，而UDP是不可靠的。 UDP的主要特点： 1.UDP是无连接的，发送数据不需要建立连接，因此，减少了开销和发送数据之前的时延。 2.UDP使用最大努力交付，不保证可靠交付。 3.UDP是面向报文的，而TCP是面向字节流的。 4.UDP没有拥塞控制。 5.UDP支持一对一，一对多，多对一和多对多的交互通信
字符数组的翻转
z_xiao_xue的博客
07-21 682
 eg:将“student a am i”翻转变为"i am a student" 思路：将整个数组翻转，再把每个单词都翻转过来就可以了 #define _CRT_SECURE_NO_WARNINGS 1 #include #include //student a am i --> i am a student void MyReverse(char* start, ch
排序算法(二)：选择排序
z_xiao_xue的博客
06-02 619
之前给大家分享了排序算法里面比较简单的冒泡排序，今天来分享一下选择排序的算法 选择排序的思想：（以升序为例）在一组数中选出最大的数放到第一个位置，或者选出最小的数放到最后一个位置，在选取剩余元素的最大数放到第二个位置，或选出剩余元素中的最小值放到倒数第二哥位置，依次往下选取，直到遍历完数组为止。具体如图所示： 代码实现： void SelectSort(int *a, size_t size
单链表的简单操作
z_xiao_xue的博客
06-12 613
单链表是C语言，c++和数据结构中的很重要的一个部分，也有很多实现它的方法，这些算法代码的实现都大同小异，我在这里就用c语言和c++两种不同的方法实现一下链表的基本操作。下面是c++和C语言的两种链表结构的定义 c++方式#include #include #include typedef int DataType; typedef struct SListNode { DataT
hashmap的面试题
最新发布
08-23
HashMap的面试题主要涉及以下几个方面： 1. HashMap的底层数据结构是什么？ HashMap的底层数据结构是数组。当进行put()操作时，会进行hash计算，确定对象在数组中的位置。如果多个对象的值在同一个数组位置上，就...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值