链表面试题1

链表面试题

顺序表和链表的区别

1.顺序表存储-----是将元素放到一块连续的内存存储空间当中；
2.链表存储--------在程序运行过程中动态的分配空间（空间大小是动态变化的）所占空间一部分放的是结点的值，另一部分放到是结点关系的指针；

注意事项：
1.顺序表：顺序存储，可以随机读取
2.链表：随机存储，但要以遍历的顺序方式读取
3.顺序表适合做类似查找这些静态的操作，
4.链表适合做插入删除O(1)这些动态的操作；
使用顺序表和链表都必须满足每个元素占有相同大小的内存空间，并且大小固定

1.删除链表中等于给定值 val 的所有节点（递归实现）

输入: 1->2->6->3->4->5->6, val = 6
输出: 1->2->3->4->5

 ListNode* removeElements(ListNode* head, int val)
 {
        if(head==NULL)
        {
           return NULL; 
        }
        
        head->next = removeElements(head->next,val);
        if(head->val==val)
        {
            return head->next;
        }
        else
        {
            return head;
        }
  }

解释：

2.反转一个单链表。

方法一：定义三个指针

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

ListNode* reverseList(ListNode* head)

//输入 : 1->2->3->4->5->NULL
//输出 : 5->4->3->2->1->NULL
ListNode* reverseList(ListNode* head)//定义三个指针的方法
{
	struct ListNode* pre = NULL;
	struct ListNode* cur = head;

	while (cur != NULL)
	{
		ListNode* next = cur->next;	//记录一下cur->next
		cur->next = pre;
		pre = cur;
		cur = next;
	}
	return pre;
}

易错点： ListNode* next = cur->next;
这条语句的作用是记录一下 cur->next 这个结点，如果不记录的话；
则while循环里的代码是这样的：

cur->next =pre;
pre = cur;
cur = cur->next;

这样很难被察觉是错误的写法：第三行的语句是想把 cur 指向原来链表中的下一个，但是 cur 在第一行就已经把下一个地址指向了pre ；所以就必须对原来链表 cur 的下一个位置做一个标记，否则就一直会停留在第一个地址上无法遍历整个链表；

方法二：定义一个新的空链表（进行尾插）

ListNode* reverseList(ListNode* head)
{
	struct ListNode* newhead = NULL;
	ListNode* cur = head;

	while (cur != NULL)
	{
		ListNode* next = cur->next;//记录cur下一个地址保存到next中
		
		cur->next = newhead;
		newhead = cur;
		
		cur = next;
	}
	return newhead;
}

这条代码就是进行尾插，使 cur 的下一个地址始终指向 newhead 新链表的头结点，最后再进行赋值操作；
cur->next = newhead;
newhead = cur;

方法三：递归实现

ListNode* reverseList(ListNode* head)
{
	if (head == NULL || head->next == NULL)
	{
		return head;
	}

	struct ListNode* h = reverseList(head->next);
	head->next->next = head;
	head->next = NULL;
	return h;
}

图片是递归实现原理：首先一直连续调用4次函数，返回的是 5->NULL;
之后进行尾插操作，一直到 5->4->3->2->1->NULL;
这两条语句是尾插操作，稍微难理解~~
head->next->next = head;
head->next = NULL;

3.给定一个带有头结点 head 的非空单链表，返回链表的中间结点。

【如果有两个中间结点，则返回第二个中间结点】

方法一：快慢指针

值得注意的一点是while()里面的终止条件：
（fast != NULL） && (fast->next != NULL)
这两个缺一不可；因为不确定结点个数；

如果只有（fast != NULL）条件：1->2->3->4->5->NULL,当 fast 走到 5 的同时 low 走到了3，由于循环并没有结束，所以两个指针会再走一次，fast 就走到了内存访问不到的位置（NULL->next）出错；而 low 也超越了3

如果只有（fast->next != NULL）条件:1->2->3->4->5->6->NULL,当 fast 走到5的同时，low走到了3，此时符合要求，再循环一次，low 走到了4，fast 走到了NULL，此时也没出错，但是NULL->next 条件无法判别，就会出错；

如果把 && 改成||：道理是一样的，只要有一个条件是正确循环就会继续进行，可能导致 fast 指针走过头，所以必须两个条件同时成立；只要触发其中一个，循环停止；返回low指针；

ListNode* middleNode(ListNode* head)
{
	ListNode* fast = head;
	ListNode* low = head;

	while (fast != NULL && (fast->next != NULL))
	{
		low = low->next;
		fast = fast->next->next;
	}
	return low;
}

【不起眼的坑】

如果你以为到这就结束了，那你就大错特错了，这个while（）循环最吊轨的地方来了 ：就是while ((fast->next != NULL) && fast != NULL ) 会出错吗？
【都是坑呀！~~[哭泣] .[哭泣]】
答案是：出错！因为&&这个家伙，它判别的时候先判定前面的，如果前面的不符合就不考虑后面了，但是这个题在判定前面的时候指针越界（fast = NULL->next）直接就报错了！所以只能把这个条件(fast->next != NULL)写在&&的后面；

方法二：计数 循环

首先计算的是链表有多少结点（flag），然后把flag/2作为终止，不过这个方法容易出错，特别是在边界的时候，容易多计算一个或少计算一个结点；

ListNode* middleNode(ListNode* head) 
{
	int i = 1;
	ListNode* flag = head;
	while (flag->next != NULL) 
	{
		i++;
		flag = flag->next;
	}
	i >>= 1;
	for (int j = 0; j < i; j++)
	{
		head = head->next;
	}
	return head;
}

4.输入链表，输出该链表倒数第k个结点

解题的方法有很多种
思路1：可以先计算出链表共有几个结点，然后再减去k就是要循环的次数
思路2：定义两个指针，先让一个指针走 k-1 步，然后两个一起走，走在前面的指针到达结点末尾的时候，后面的指针恰好走到了倒数第 k 个结点的位置；
下面是思路二的代码：

ListNode* FindKthToTail(ListNode* pListHead, unsigned int k)
{
	if (pListHead == NULL || k == 0)
	{
		return NULL;
	}

	ListNode* pTail = pListHead;
	ListNode* pHead = pListHead;

	for (int i = 1; i < k; ++i)
	{
		if (pHead->next != NULL)
		{
			pHead = pHead->next;
		}
		else
		{
			return NULL;
		}
	}

	while (pHead->next != NULL)
	{
		pHead = pHead->next; 
		pTail = pTail->next;
	}   
	return pTail;
}

找错误

下面是这个是思路 1 的代码，没有调试过，大家帮我看一下

ListNode* FindKthToTail(ListNode* pListHead, unsigned int k)
{
	if (pListHead == NULL)
	{
		return NULL;
	}
	if (k == 0)
	{
		return NULL;
	}

	ListNode* p1 = pListHead;
	ListNode* p2 = pListHead;
	int count = 0;

	while (p1!= NULL)
	{
		++count;
		p1 = p1->next;
	}

	for (int i = 0; i < count - k; ++i)
	{
		p2 = p2->next;
	}
	return p2;
}

5.将两个有序链表合并为一个新的有序链表

返回新的有序链表,新链表是通过拼接给定的两个链表的所有节点组成的。
输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

方法1：循环

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
{
	if (l1 == NULL) { return l2; }
	if (l2 == NULL) { return l1; }

	ListNode *n1 = l1, *n2 = l2;
	ListNode *first = NULL;	// 合并完后，链表的第一个结点
	ListNode *last = NULL;	// 合并完后，链表的最后一个结点
	while (n1 != NULL && n2 != NULL)
	{
		if (n1->val <= n2->val)
		{
			if (last == NULL)
			{
				// 如果现在链表中没有结点，则尾插的这个结点
				// 就是最后一个结点
				first = last = n1;
			}
			else
			{
				// 让原来最后一个结点的 next = n1
				last->next = n1;
				// n1 变成新的最后一个结点
				last = n1;
			}

			n1 = n1->next;
		}
		else
		{
			if (last == NULL)
			{
				// 如果现在链表中没有结点，则尾插的这个结点
				// 就是最后一个结点
				first = last = n2;
			}
			else
			{
				// 让原来最后一个结点的 next = n2
				last->next = n2;
				// n1 变成新的最后一个结点
				last = n2;
			}

			n2 = n2->next;
		}
	}

	// n1 或者 n2 有一个为 NULL
	// 一个链表的所有结点都被处理了
	// 把剩余的链表结点跟在 last 后边就可以了
	if (n1 != NULL) {
		last->next = n1;
	}

	if (n2 != NULL) {
		last->next = n2;
	}

	return first;
}

方法2:递归思想

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
{
	if (l1 == NULL)
	{
		return l2;
	}
	if (l2 == NULL)
	{
		return l1;
	}
	ListNode* mergeHead = NULL;
	if (l1->val <= l2->val)
	{
		mergeHead = l1;
		mergeHead->next = mergeTwoLists(l1->next, l2);
	}
	else 
	{
		mergeHead = l2;
		mergeHead->next = mergeTwoLists(l2->next, l1);
	}
	return mergeHead;
}

一般情况下使用递归可以把代码进行简化，看起来很精干清爽！
未完待续~~·
https://blog.csdn.net/qq_43763344/article/details/89049217