一、前言
基于牛客网中的链表在线编程题目,对链表相关的题目进行C语言解析
二、链表反转
题目:
给定一个单链表的头结点pHead(该头节点是有值的,比如在下图,它的val是1),长度为n,反转该链表后,返回新链表的表头。
数据范围: 0≤n≤1000
要求:空间复杂度 O(1) ,时间复杂度 O(n) 。
如当输入链表{1,2,3}时,
经反转后,原链表变为{3,2,1},所以对应的输出为{3,2,1}。
以上转换过程如下图所示:
相关代码:
struct ListNode* ReverseList(struct ListNode* head ) {
struct ListNode* newcode = NULL,*cur = head;
while(cur)
{
struct ListNode* next=cur->next;
cur->next=newcode;
newcode = cur;
cur=next;
}
return newcode;
}
使用三个指针newcode,cur,next来进行迭代地将链表中的节点依次反转,newcode指向已反转的部分链表的头节点,cur指向待反转的节点,next用于保存cur的下一个节点。
在迭代过程中,先用next对cur的下一个节点进行暂存,防止cur的下一个节点丢失,然后将cur的下一个节点指向newcode,再将newcode指向cur,cur再指向下一个节点next,进行下一个节点的反转。
当迭代完成后,newcode就成了新链表的头节点,将其返回即可得到反转的链表。
三、链表内指定区间反转
题目:
将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转,要求时间复杂度 O(n),空间复杂度 O(1)。
例如:
给出的链表为 1→2→3→4→5→NULL, m=2,n=4,
返回 1→4→3→2→5→NULL.
数据范围: 链表长度 0<size≤1000,0<m≤n≤size,链表中每个节点的值足 |val| ≤ 1000
要求:时间复杂度 O(n) ,空间复杂度 O(n)
进阶:时间复杂度 O(n),空间复杂度 O(1)
相关代码:
typedef struct TestList
{
int Date;
struct TestList* next;
}TestList;
TestList* reverseBetween(TestList* head, int m, int n)
{
TestList* newcode = (TestList*)malloc(sizeof(TestList));
int i = 0;
int c = n - m;
if (c <= 0 || head == NULL)
{
return head;
}
newcode->next = head;
TestList* prev = newcode;
for (i = 0; i < m - 1; i++)
{
prev = prev->next;
}
TestList* cur = prev->next;
TestList* tmp = NULL;
while (c)
{
tmp = cur->next; //对当前进行暂存
cur->next = tmp->next; //将当前的下一个指向下一个的下一个
tmp->next = prev->next; //将暂存的放到前一个的下一个上,
prev->next = tmp;//进行位置转换
c--;
}
TestList* List = (TestList*)malloc(sizeof(TestList));
List = newcode->next;
free(newcode);
return List;
}
step1:我们可以在链表前加一个哨兵位,在最后返回时对其进行释放,因为如果要从链表头的位置开始反转,在多了一个表头的情况下就能保证第一个节点永远不会反转,不会到后面去。
step2:使用两个结构体指针,一个指向当前节点,一个指向前序节点。
step3:依次遍历链表,到第m个的位置。
step4:对于从m到n这些个位置的节点,依次断掉指向后续的指针,反转指针方向。
step5:返回时释放我们添加的哨兵位。
四、合并两个排序的数组
题目:
输入两个递增的链表,单个链表的长度为n,合并这两个链表并使新链表中的节点仍然是递增排序的。
数据范围: 0≤n≤1000,−1000≤节点值≤1000
要求:空间复杂度 O(1),时间复杂度 O(n)如输入{1,3,5},{2,4,6}时,合并后的链表为{1,2,3,4,5,6},所以对应的输出为{1,2,3,4,5,6},转换过程如下图所示:
相关代码:
TestList* mergeTwoLists(TestList* list1, TestList* list2)
{
//如果其中一个链表为空,就返回另一个
if (list1 == NULL)
{
return list2;
}
if (list2 == NULL)
{
return list1;
}
//创建新链表的头和节点
TestList* head = NULL, * tail = NULL;
head = tail = (TestList*)malloc(sizeof(TestList));
while (list1 && list2)
{
if (list1->Date < list2->Date)
{
head = tail = list1;
tail = tail->next;
list1 = list1->next;
}
else
{
head = tail = list2;
tail = tail->next;
list2 = list2->next;
}
}
//如果有一个链表为空,将其连接为新链表的后面
if (list1)
{
tail->next = list1;
}
if (list2)
{
tail->next = list2;
}
TestList* List = head->next;
free(head);
return List;
}
因为是两个有序链表,所以将两个链表的第一个值进行比较,如果第一个值中 链表1 < 链表2 说明新链表中的第一个值为链表1中的第一个值,head = tail = list1
将较小值的链表tail指向下一个节点,tail = tail ->next,之后继续进行迭代
进行迭代完成之后,如果两个链表长度不相等,说明有一个链表已经为空,另一个链表的值肯定大于第一个链表,就将其链接到新链表后面
五、判断链表的中间节点
题目: 给定一个链表,返回该链表的中间节点,如果中间节点有两个,则返回第二个中间节点
1➡2➡3➡4➡5 中间节点为3
1➡2➡3➡4➡5➡6 中间节点为4
要求只能遍历链表一次
相关代码:
//判断链表的中间节点
TestList* middleNode(TestList* head)
{
TestList* slow = head, * fast = head;
while (fast && fast->next)
{
slow = slow->next;
fast = fast->next->next;
}
return slow;
}
使用快慢指针的方法进行中间节点的返回。
定义两个指针,一个叫fast,一个叫slow,在进行迭代的过程中,慢指针一次走一步,快指针一次走两步,当快指针走到尾时,慢指针恰好走到中间
当链表长度为奇数时,fast走到链表尾,当链表长度为偶数时,fast走到链表尾的下一个,所以迭代的条件为:当fast 和 fast->next 不为空时,迭代继续。
六、将链表分割,将小于x的排序到链表前,大于x的排序到链表后
题目:给出链表 2➡3➡5➡1➡6➡4 给定x=3,将小于x的排序到链表前,大于x的排序到链表后,要求不能改变原链表的数据结构,并返回新链表的头指针
返回的链表应该为:1➡2➡3➡4➡5➡6
相关代码:
//链表分割,将小于x的排序到链表前,大于x排序到链表后
TestList* partition(TestList* head, int x)
{
TestList* lesshead, * lesstail, * greaterhead, * greatertail;
//设置哨兵位
lesshead = lesstail = (TestList*)malloc(sizeof(TestList*));
lesstail->next = NULL;
greaterhead = greatertail = (TestList*)malloc(sizeof(TestList*));
greatertail->next = NULL;
//防止链表头还要使用
TestList* cur = head;
while (cur)
{
//小的就放到小链表,大的就放到新链表
if (cur->Date < x)
{
lesstail->next = cur;
lesstail = cur;
}
else
{
greatertail->next = cur;
greatertail = cur;
}
cur = cur->next;
}
lesstail->next = greaterhead->next;
greatertail->next = NULL;
TestList* List = lesshead->next;
free(lesshead);
free(greaterhead);
return List;
}
创建两个新链表并设置哨兵位和标志位,将原链表的数据与x进行比较,当比x小时,放到lesshead 所在的链表,当比x大时,放到 greaterhead 所在的链表,当迭代完成后,再将greaterhead 链表链接到 lesshead 链表后面去。