将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中不允许有重复的数据。C语言版
时间: 2024-06-15 13:08:12 浏览: 7
在C语言中,可以通过指针操作来将两个递增的有序链表合并为一个递增的有序链表。具体步骤如下:
1. 定义一个新的指针变量,用于指向合并后的链表的头节点。
2. 比较两个链表的头节点的值,将较小的节点作为合并后链表的头节点,并将指针指向该节点。
3. 分别定义两个指针变量,分别指向两个链表的当前节点。
4. 通过循环比较两个链表的当前节点的值,将较小的节点连接到合并后链表的尾部,并更新指针。
5. 当其中一个链表遍历完毕后,将另一个链表剩余的节点直接连接到合并后链表的尾部。
6. 返回合并后链表的头节点。
下面是C语言实现的代码示例:
```c
#include <stdio.h>
#include <stdlib.h>
// 定义链表节点结构体
typedef struct ListNode {
int val;
struct ListNode* next;
} ListNode;
// 合并两个递增有序链表
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
// 定义一个新的指针变量,用于指向合并后的链表的头节点
ListNode* mergedHead = NULL;
// 比较两个链表的头节点的值,将较小的节点作为合并后链表的头节点,并将指针指向该节点
if (l1 == NULL) {
return l2;
} else if (l2 == NULL) {
return l1;
} else {
if (l1->val <= l2->val) {
mergedHead = l1;
l1 = l1->next;
} else {
mergedHead = l2;
l2 = l2->next;
}
}
// 分别定义两个指针变量,分别指向两个链表的当前节点
ListNode* p1 = l1;
ListNode* p2 = l2;
ListNode* p = mergedHead;
// 通过循环比较两个链表的当前节点的值,将较小的节点连接到合并后链表的尾部,并更新指针
while (p1 != NULL && p2 != NULL) {
if (p1->val <= p2->val) {
p->next = p1;
p1 = p1->next;
} else {
p->next = p2;
p2 = p2->next;
}
p = p->next;
}
// 当其中一个链表遍历完毕后,将另一个链表剩余的节点直接连接到合并后链表的尾部
if (p1 != NULL) {
p->next = p1;
}
if (p2 != NULL) {
p->next = p2;
}
// 返回合并后链表的头节点
return mergedHead;
}
// 创建链表节点
ListNode* createNode(int val) {
ListNode* node = (ListNode*)malloc(sizeof(ListNode));
node->val = val;
node->next = NULL;
return node;
}
// 打印链表
void printList(ListNode* head) {
ListNode* p = head;
while (p != NULL) {
printf("%d ", p->val);
p = p->next;
}
printf("\n");
}
int main() {
// 创建两个递增有序链表
ListNode* l1 = createNode(1);
l1->next = createNode(3);
l1->next->next = createNode(5);
ListNode* l2 = createNode(2);
l2->next = createNode(4);
l2->next->next = createNode(6);
// 合并两个链表
ListNode* mergedList = mergeTwoLists(l1, l2);
// 打印合并后的链表
printList(mergedList);
// 释放链表内存
ListNode* p = mergedList;
while (p != NULL) {
ListNode* temp = p;
p = p->next;
free(temp);
}
return 0;
}
```