【数据结构】链表入门基础题

---

前言

最近笔者正在准备实验室的考核，用一些时间简单刷了一些leetcode中的简单链表题，其中遇到了些许问题并通过自己的思考加以解决，现以此博客写下自己的题解并记录自己刷题的心得。如有错误，请不吝指出。

一、本博客的链表声明

为了方便读者写博客，也为了方便读者读博客，现在下方放出笔者定义的链表存储结构与用尾插法创建链表的代码

链表存储结构

typedef struct Node
{
	int data;
	struct Node* pNext;
}NODE, * PNODE;

尾插法创建链表

PNODE CreateList()
{
	PNODE pHead = (PNODE)malloc(sizeof(NODE));
	PNODE pTail = pHead;
	pTail->pNext = NULL;
	int val;
	int len;
	printf("请输入链表长度");
	scanf_s("%d", &len);
	for (int i = 0; i < len; ++i)
	{
		printf("请输入第%d个元素", i + 1);
		scanf_s("%d", &val);

		PNODE pNew = (PNODE)malloc(sizeof(NODE));
		pTail->pNext = pNew;
		pNew->data = val;
		pTail = pNew;
		pNew->pNext = NULL;
	}
	return pHead;
}

二、链表的基础操作

首先在做题之前，希望读者能够仔细阅读以下的基础操作，后续笔者的例题与以下的操作息息相关

1、单链表的读取（获得链表中的第i个结点的元素）

思路：
①声明一个指针指向链表第一个有效节点，也就是头结点后面的第一个结点。初始化从1开始；
②当j<i时，就遍历链表（这里我们可以理解一下，我们在j<i时遍历，那么就意味着当j=i时停止），此时链表也刚好指向第i个元素
③若到链表末尾p为空，则说明第i个结点不存在
④若查找成功，返回结点p的数据

//如果要获得要删除元素的前一个节点只需让指针初始指向头指针，而非指向第一个有效节点
int GetElem(PNODE Head, int i)//要控制第几个元素要让p从head开始才能找到
{
	int j = 1;
	PNODE p = Head->pNext;
	while (p && j < i)//p不为空且计数器还没有等于i时，循环继续。也就是说当循环结束时，指针p刚好指向要查找的第i个元素。
	{
		p = p->pNext;//先移动后加
		j++;
	}
	printf("%d", p->val);

	return 1;
}

2、单链表的删除（删除链表中的第i个结点的元素）

链表的删除是一种特殊的删除，我们无法通过第i个结点对其进行删除，因为如果我们仅仅对第i个结点进行free，那么第i-1个结点与第i+1个结点就无法连接。

所以对于第i个结点，我们需要通过第i-1个结点对其进行删除

PNODE DeleteList(PNODE Head, int i)//删除第i个节点后面的元素
{
	int j = 1;
	PNODE p = Head;
	while (p && j < i)//p不为空且计数器还没有等于i时，循环继续。也就是说当循环结束时，指针p刚好指向要查找的第i个元素。
	{
		p = p->pNext;
		j++;
	}
	PNODE q = p->pNext;
	p->pNext = q->pNext;//或者也可以写为p->pNext = p->pNext->pNext;
	free(q);

	return Head;
}

在这里我们可以看到单链表的删除与单链表的读取相似度极高，唯一不同的便是我们的指针此时并不指向链表的第一个有效结点，而是指向了头结点，这是为什么呢？

其实这是一个很简单的道理，以我们的单链表的读取为例，当我们需要读取第i个元素时，我们的指针p指向链表的第一个有效结点。那么此时我们需要删除第i个结点，我们需要得到的时第i-1个结点，那么我们就需要在刚开始时让指针p指向第一个有效结点的前一个结点，也就是头结点。这么一讲解是不是就容易理解多了呢？

3、计算链表的长度

int listlength(PNODE head)//计算链表长度
{
	PNODE p = head->pNext;
	int len = 0;//计算链表长度从0开始
	while (p)
	{
		++len;
		p = p->pNext;
	}
	return len;
}//计算链表长度前判断下一个节点是否为空，所以需要从0开始

对于计算链表长度，我们也可以与单链表的读取对比，例如我们需要得到第i个结点，那么我们就需要使p指向第i个结点。
但计算链表长度时，我们就需要从0开始计算，判断下一个链表是否为空，来判断是否增加链表元素的个数。

三、链表入门基础题

注：笔者在下方放出的代码并不按照力扣的格式，而是实现完整的代码

1.反转链表并将其输出

题目：反转链表

首先众所周知，这是一道非常经典的面试题，它可以用许多的方法如迭代，递归法实现。接下来笔者将会在下文放出并讲解笔者对于此题的代码

①迭代法

void reverseList(PNODE pHead)
{
	PNODE cur = pHead;
	PNODE pre = NULL;
	while (cur)
	{
		PNODE t = cur->pNext;
		cur->pNext = pre;//cur->pNext是改变箭头的指向
		pre = cur;
		cur = t;
	}
	//上一步已经使cur指向空，所以要从pre开始遍历
	
	//从尾到头打印链表
	while (pre!=pHead)//pre此时再最后一个节点
	{
		printf("%d", pre->data);
		pre = pre->pNext;
	}

}

下述笔者关于此题的解决思路
①首先定义两个指针，第一个cur指向头结点或第一个有效的结点，第二个pre指向空。
②再定义临时变量保存cur指针的后一个结点，防止我们在反转结点指向时找不到原来指向的结点
③使cur指针的指向指向pre。
④先移动pre指针，再使cur指向临时变量
注意：我们这里必须要先移动pre再移动cur，如果先移动cur我们就无法使pre指向原来的cur

②递归法

假设我们要反转元素为12345的链表

PNODE reverseList(PNODE pHead)
{
	if (pHead==NULL || pHead->pNext==NULL)
	{
	/*
	直到当前结点的下一个结点为空，也就是指向5这个结点是返回pHead
	*/
		return pHead;
	}
	// //递归传入下一个节点，目的是为了到达最后一个节点
	PNODE NewpHead = reverseList(pHead->pNext);//首先要明白NewpHead是始终不变的，不管如何返回永远指向反转后的第一个有效结点
	 /*
            第一轮出栈，head为5，head.next为空，所以我们更不用理会pHead->pNext->pNext，直接返回5
            第二轮出栈，head为4，head.next为5，执行head.next.next=head也就是5.next=4，
                      把当前节点的子节点的子节点指向当前节点
                      此时链表为1->2->3->4<->5，由于4与5互相指向，所以此处要断开4.next=null
                      此时链表为1->2->3->4<-5
                      返回节点5
            第三轮出栈，head为3，head.next为4，执行head.next.next=head也就是4.next=3，
                      此时链表为1->2->3<->4<-5，由于3与4互相指向，所以此处要断开3.next=null
                      此时链表为1->2->3<-4<-5
                      返回节点5
            第四轮出栈，head为2，head.next为3，执行head.next.next=head也就是3.next=2，
                      此时链表为1->2<->3<-4<-5，由于2与3互相指向，所以此处要断开2.next=null
                      此时链表为1->2<-3<-4<-5
                      返回节点5
            第五轮出栈，head为1，head.next为2，执行head.next.next=head也就是2.next=1，
                      此时链表为1<->2<-3<-4<-5，由于1与2互相指向，所以此处要断开1.next=null
                      此时链表为1<-2<-3<-4<-5
                      返回节点5
            出栈完成，最终头节点5->4->3->2->1
         */
		//注：此处为笔者的copy，因为笔者认为此处引用的内容比笔者这个小白的讲解更加完美。引用处的head其实就是笔者代码中的pHead。
	pHead->pNext->pNext = pHead;
	pHead->pNext = NULL;
	return NewpHead;

}

void bianli(PNODE pHead, PNODE t)//对于递归法的输出，因为笔者使用的是尾插法，所以必须要保存原先头结点的值
{
	PNODE p = pHead;
	while (p != t)
	{
		printf("%d\n", p->data);
		p = p->pNext;
	}
}

int main(void)
{
	PNODE pHead = create();
	PNODE t = pHead;
	PNODE p =reverseList(pHead);
	bianli(p, t);
}

如果对上述递归有疑问的话，可以阅读读者的另一篇博客递归的学习与应用
也许看完这篇博客能对你理解反转链表的递归法有些许启发

2.移除链表元素

题目：移除链表元素

PNODE deleteNode(PNODE pHead, int target)//移除链表元素
//用力扣的方法的设立虚拟头结点
{

	PNODE cur = pHead;//以便查阅第一个元素
	while (cur->pNext)/*在这里我们需要明白为什么用cur->pNext作为判断条件，因为我们不用遍历
						到尾节点,对尾节点的删除是通过得到他的前面一个节点来进行的*/
		//记得此时遍历不到最后一个尾节点，因为没有必要，可以通过前一个节点判断是否删除尾节点
		//如果是cur，则可以遍历到尾节点
	{
		if (cur->pNext->val == target)
		{
			cur->pNext = cur->pNext->pNext;
		}
		else 
		{
			cur = cur->pNext;//再移动cur指针
		}
	}
	return pHead;

}

void traverse_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->pNext;
	}
}

int main()
{
	int target;
	PNODE pHead = CreateList();
	printf("请输入要移除的节点元素");
	scanf_s("%d", &target);
	traverse_list(deleteNode(pHead, target));
	
}

如果我们的判断条件是cur那么会报错，这个问题笔者还不能很好的理解，后面会请教学长关于这个问题，解决后再来补充我的博客
这一题与笔者上述的单链表的删除十分类似，都是通过第i-1个节点删除第i个节点。可以与其结合理解

3.移除排序链表重复元素

题目：移除排序链表重复元素

PNODE deleteDuplicates(PNODE pHead)
{
	PNODE p = pHead->pNext;
	while (p->pNext)
	{
		if (p->data == p->pNext->data)
		{
			p->pNext = p->pNext->pNext;
		}
		else
		{
			p = p->pNext;
		}
	}
	return pHead;
}

int main()
{
	PNODE pHead = CreateList();
	deleteDuplicates(pHead);
	traverse_list(pHead);

}

这里需要注意为何循环的终止条件是p->nextz，因为我们并不用将指针遍历到最后一个节点，对最后一个节点进行操作只需得到他的前一个结点

4.删除链表倒数第k个节点

题目：删除链表的倒数第 N 个结点

int length(PNODE pHead)
{
	PNODE p = pHead->pNext;
	int i = 0;
	while (p)
	{
		p = p->pNext;
		i++;
	}
	return i;
}

PNODE removeNthFromEnd(PNODE pHead, int n)
{
	PNODE p = pHead;
	int i = 1;//为什么此时i=1  p = head呢
	//因为例如当i=2时，此时的p指向第一个节点。
	//例如我们要删除第i个节点，我们就要得到第i-1个节点的位置
	while (p->pNext && i < length(pHead) - n + 1)//倒数第k个节点其实就是正序链表第length(pHead) - n + 1个节点。
	{
		p = p->pNext;
		++i;
	}
	p->pNext = p->pNext->pNext;
	return pHead;
}

void bianli(PNODE pHead)
{
	PNODE p = pHead->pNext;
	
	while (p)
	{
		printf("%d\n", p->data);
		p = p->pNext;
	}
}

int main()
{
	PNODE pHead = create();
	int n;
	printf("输入要删除的倒数第k个节点: ");
	scanf_s("%d", &n);
	removeNthFromEnd(pHead, n);
	bianli(pHead);
}

此题其实便是上文链表基础操作单链表的删除与计算链表的长度的结合，可以与上文结合理解。

5.合并两个排序的链表

①递归法

题目：合并两个排序的链表

PNODE MergeTwoList(PNODE p1, PNODE p2)
{
	if (p1 == NULL)
		return p2;
	else if (p2 == NULL)
		return p1;
	else if (p1->data < p2->data)
	{
		p1->pNext = MergeTwoList(p1->pNext, p2);
		return p1;
	}
	else
	{
		p2->pNext = MergeTwoList(p1, p2->pNext);
		return p2;
	}

}

void bianli(PNODE pHead)
{
	PNODE p = pHead->pNext;
	while (p)
	{
		printf("%d ", p->data);
		p = p->pNext;
	}
}

int main(void)
{	
	PNODE Head_1 = CreateList();
	PNODE Head_2 = CreateList();
	MergeTwoList(Head_1,Head_2);
	bianli(Head_1);

	return 0;
}

思路：
①将两排序链表纵向对比，对当前元素较小的链表进行移动（用p->next实现）
②而后返回移动的链表
③直至某一链表为空返回链表

本题的代码与力扣上的题解有些许不同，力扣传入实现功能的函数的参数是第一个有效节点，而在此笔者传入的是头节点。若在笔者的代码中传入第一个有效代码便会与结果不符，这样的情况还需请教一下学长，会在后续继续更改博客。

②蠢方法

对两个链表连接后进行排序

void traverse_list(PNODE pHead)
{
	PNODE p = pHead->pNext;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->pNext;
	}
}

PNODE linklist(PNODE head1, PNODE head2)
{
	PNODE p = head1;
	while (p->pNext)
	{
		p = p->pNext;
	}
	p->pNext = head2->pNext;
	return head1;//返回连接后的头结点
}

int main()
{
	PNODE head1 = CreateList();
	PNODE head2 = CreateList();
	traverse_list(linklist(head1, head2));

}

6.回文链表

题目：回文链表

①数组法

核心思想：将链表中的元素存入数组，然后使用首尾指针判断回文

bool isPalindrome(PNODE pHead)
{
	int* num = (int*)malloc(sizeof(int) * length(pHead));
	int i = 0;
	PNODE p = pHead->pNext;
	while (p)
	{
		num[i++] = p->data;
		p = p->pNext;
	}
	int left = 0;
	int right = length(pHead) - 1;
	while (left < right)
	{
		if (num[left] != num[right])
		{
			return false;
		}
		left++;
		right--;
	}
	return true;
}

int main()
{
	PNODE pHead = CreateList();
	if (isPalindrome(pHead))
	{
		printf("true");
	}
	else
		printf("false");
	
}

②栈法

我们除了将元素存入数组，我们还可以使用栈的方法判断是否回文。在此笔者就不放出代码，简单讲述一下用栈实现判断回文链表的思想

①首先获得链表的长度，进而判断链表长度为奇数还是偶数。
②设置两个变量front与hind。front = length/2。如果链表长度为奇数hind = front+2，如果链表长度为偶数hind = front+1。
③将小标小于等于front的链表元素全部入栈。
④再将指针移到hind的位置，依次遍历，如果链表的下标为hind的元素等于栈顶元素，就将hind加1，并将栈顶指针出栈直至栈空判断为true，否则返回false。

7.二进制链表转整数

题目：二进制链表转整数

int length(PNODE head)
{
	PNODE p = head->pNext;
	int i = 0;
	while (p)
	{
		++i;
		p = p->pNext;
	}
	return i;
}
int twoconvertten(PNODE pHead)
{
	PNODE p = pHead->pNext;
	int sum = 0;
	for (int i = length(pHead)-1; i >= 0; --i)
	{
		int t = pow(2, i);
		sum += p->data * t;
		p = p->pNext;
	}
	return sum;
}

int main()
{
	PNODE pHead = CreateList();
	printf("%d", twoconvertten(pHead));
}

思路：首先要获取链表长度，再各位二进制乘上其对应的二次方

8.两数相加

核心：创建一个新链表存储两个链表相加的数。与大数相加的原理类似。如果两链表长度不一在末尾补零。 记得不要忘记最后判断进位。

PNODE PlusTwoSums(PNODE Head_1, PNODE Head_2)
{
	PNODE Head = NULL;
	PNODE Tail = NULL;//创建存放两数相加的数据的链表的头尾节点
	int carry = 0;
	while (Head_1 || Head_2)//只循环了一次
	{	
		
		int n1 = Head_1 ? Head_1->data : 0;
		int n2 = Head_2 ? Head_2->data : 0;
		int sum = n1 + n2 + carry;
		if (!Head)
		{
			
			Head = Tail = (PNODE)malloc(sizeof(NODE));
			Tail->data = sum % 10;
			Tail->pNext = NULL;
			
		}
		else
		{
			
			Tail->pNext = (PNODE)malloc(sizeof(NODE));
			Tail->pNext->data = sum % 10;
			Tail = Tail->pNext;
			Tail->pNext = NULL;
		}
		
		carry = sum / 10;
		if (Head_1)
		{
			Head_1 = Head_1->pNext;
		}
		if (Head_2)
		{
			Head_2 = Head_2->pNext;
		}
	}
	if (carry > 0)
	{
		Tail->pNext = (PNODE)malloc(sizeof(NODE));
		Tail->pNext->data = carry;
		Tail = Tail->pNext;
		Tail->pNext = NULL;
	}
	return Head;
}

int main(void)
{
	PNODE Head_1 = CreateList();
	PNODE Head_2 = CreateList();
	bianli(PlusTwoSums(Head_1->pNext, Head_2->pNext));
}

总结

以上便是我对链表入门基础题的总结，如有不足，请不吝啬指出。