输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然按照递增排序

最新推荐文章于 2023-05-20 22:14:47 发布
最新推荐文章于 2023-05-20 22:14:47 发布
阅读量1.5k 收藏 1
点赞数 1
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiluohan0307/article/details/51443710
版权

算法描述：

输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然按照递增排序

算法实现：

/*************************************************************************
	> File Name: main.c
	> Author: cyf
	> Mail: XXX@qq.com
	> Created Time: 2016年05月18日 星期三 14时01分15秒
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mergeList.h"
#include "List.h"
struct ListNode* Test(char* testName, struct ListNode* pHead1, struct ListNode* pHead2)
{
    if(testName != NULL)
        printf("%s begins:\n", testName);

    printf("The first list is:\n");
    PrintList(pHead1);

    printf("\nThe second list is:\n");
    PrintList(pHead2);

    printf("\nThe merged list is:\n");
    struct ListNode* pMergedHead = mergeList(pHead1, pHead2);
    PrintList(pMergedHead);
    
    printf("\n\n");

    return pMergedHead;
}

// list1: 1->3->5
// list2: 2->4->6
void Test1()
{
    struct ListNode* pNode1 = CreateListNode(1);
    struct ListNode* pNode3 = CreateListNode(3);
    struct ListNode* pNode5 = CreateListNode(5);

    ConnectListNodes(pNode1, pNode3);
    ConnectListNodes(pNode3, pNode5);

    struct ListNode* pNode2 = CreateListNode(2);
    struct ListNode* pNode4 = CreateListNode(4);
    struct ListNode* pNode6 = CreateListNode(6);

    ConnectListNodes(pNode2, pNode4);
    ConnectListNodes(pNode4, pNode6);

    struct ListNode* pMergedHead = Test("Test1", pNode1, pNode2);

    DestroyList(pMergedHead);
}
int main()
{
	Test1();
	return 0;
}
/*************************************************************************
	> File Name: mergeList.h
	> Author: cyf
	> Mail: XXX@qq.com
	> Created Time: 2016年05月18日 星期三 13时45分25秒
 ************************************************************************/

#ifndef _MERGELIST_H
#define _MERGELIST_H
#include "List.h"
/*
 * 输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然按照递增排序
 * */
struct ListNode *mergeList(struct ListNode * pHead1, struct ListNode *pHead2);


#endif
/*************************************************************************
	> File Name: mergeList.c
	> Author: cyf
	> Mail: XXX@qq.com
	> Created Time: 2016年05月18日 星期三 13时55分40秒
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mergeList.h"

struct ListNode *mergeList(struct ListNode *pHead1, struct ListNode *pHead2)
{
	if (pHead1 == NULL)
		return pHead2;
	else if (pHead2 == NULL)
		return pHead1;

	struct ListNode *pRet = NULL;
	if (pHead1->data < pHead2->data)
	{
		pRet = pHead1;
		pRet->next = mergeList(pHead1->next, pHead2);
	}
	else if (pHead1->data >= pHead2->data)
	{
		pRet = pHead2;
		pRet->next = mergeList(pHead1, pHead2->next);
	}
	return pRet;
	
}

/************************************************************************
	> File Name: List.h
	> Author: cyf
	> Mail: 1097189275@qq.com 
	> Created Time: 2016年03月23日 星期三 17时27分15秒
 ************************************************************************/

#ifndef ALGRITHMN_LIST_H
#define ALGRITHMN_LIST_H


struct ListNode
{
	int data;
	struct ListNode *next;
};
struct ListNode *CreateListNode(int value);
void ConnectListNodes(struct ListNode *pCurrent, struct ListNode *pNext);
void PrintListNode(struct ListNode *pNode);
void PrintList(struct ListNode *pHead);
void AddToTail(struct ListNode **pHead, int value);
void RemoveNode(struct ListNode **pHead,int value);
unsigned int GetListLength(struct ListNode *pHead);
void DestroyNode(struct ListNode *pNode);
void DestroyList(struct ListNode *pHead);

#endif

</pre><pre name="code" class="cpp">/*************************************************************************
	> File Name: List.c
	> Author: cyf
	> Mail: 1097189275@qq.com 
	> Created Time: 2016年03月23日 星期三 17时32分11秒
 ************************************************************************/

#include "List.h"
#include <stdio.h>
#include <stdlib.h>
/*
 * 创建一个链表的结点
 * */
struct ListNode *CreateListNode(int value)
{
	struct ListNode *pNode =(struct ListNode *)malloc(sizeof(struct ListNode));
	pNode->data = value;
	pNode->next = NULL;

	return pNode;
}
/*
 * 将两个结点连接起来
 * */
void ConnectListNodes(struct ListNode *pCurrent, struct ListNode *pNext)
{
	if(!pCurrent)
	{
		printf("ERROR!connect two ListNode.\n");
		exit(1);
	}
	pCurrent->next = pNext;
}
/*
 * 打印结点
 * */
void PrintListNode(struct ListNode *pNode)
{
	if(!pNode)
	{
		printf("the node is null!\n");
		exit(1);
	}
	printf("The value of the node is %d\n",pNode->data);
}
/*
 * 打印链表
 * */
void PrintList(struct ListNode *pHead)
{
	printf("print the list:\n");
	struct ListNode *pNode = pHead;
	if(!pNode)
	{
		printf("the list is null\n");
		exit(1);
	}
	while(pNode != NULL)
	{
		printf("%d ",pNode->data);
		pNode = pNode->next;
	}
}
/*
 * 在链表结尾添加结点
 * */
void AddToTail(struct ListNode **pHead, int value)
{
	struct ListNode *pNew = (struct ListNode*)malloc(sizeof(struct ListNode));
	pNew->data = value;
	pNew->next = NULL;

	if(!pHead)
		*pHead = pNew;
	else
	{
		struct ListNode *pNode = *pHead;
		while(pNode != NULL)
		{
			pNode = pNode->next;
		}
		pNode->next = pNew;
	}
	
}
/*
 * 删除链表中结点值为value的结点
 * */
void RemoveNode(struct ListNode **pHead, int value)
{
	if(pHead == NULL||*pHead == NULL)
	{
		printf("the list is null");
		return;
	}
	struct ListNode *ToBeDel = NULL;

	if((*pHead)->data == value)
	{
		ToBeDel = *pHead;
		*pHead = (*pHead)->next;
	}
	else
	{
		struct ListNode *pNode = *pHead;

		while(pNode->next != NULL && pNode->next->data != value)
			pNode = pNode->next;
		if(pNode->next != NULL && pNode->next->data == value)
		{
			ToBeDel = pNode->next;
			pNode->next = pNode->next->next;
		}
	}

	if(ToBeDel != NULL)
	{
		free(ToBeDel);
		ToBeDel = NULL;
	}
}
/*
 * 计算链表的长度
 * */
unsigned int GetListLength(struct ListNode *pHead)
{
	unsigned int length = 0;
	struct ListNode *pNode = pHead;

	while(pNode != NULL)
	{
		++length;
		pNode = pNode->next;
	}

	return length;
}
/*
 * 销毁一个结点
 * */
void DestroyNode(struct ListNode *pNode)
{
	free(pNode);
	pNode = NULL;
}
void DestroyList(struct ListNode* pHead)
{
	struct ListNode *pNode = pHead;
	while (pNode != NULL)
	{
		pHead = pHead->next;
		free(pNode);
		pNode = pHead;
	}
}
.SUFFIXEX:.c.o

CC = gcc
CFLAGS = -g -O2 -Wall
SRCS = main.c\
	   List.c\
	   mergeList.c
OBJS = $(SRCS:.c=.o)
EXE = main

all:$(OBJS)
	$(CC) $(OBJS) -o $(EXE) $(CFLAGS)

.c.o:
	$(CC) -o $@ -c $(CFLAGS) $<

clean:
	rm -rf $(OBJS) $(EXE)






yiluohan0307
关注
专栏目录
合并两个递增排序的链表，合并后仍递增有序。
qq_43824618的博客
03-18 1224
这是面试中经常被提到的问题。下图表示链表1和链表2合并成链表3： 1.用递归算法更加简单好理解，即链表1的头结点值小于链表2头结点的值，我们就将链表1作为合并后链表的头结点，在剩余结点中，链表2的头结点值小于链表1头结点的值，我们将链表二的头结点作为合并链表的后续结点，且剩余结点依然是有序的，合并的步骤和之前一样，如下图： 递归代码如下： ListNode* Merge(ListN...
链表之合并两个排序的链表
qq_37115648的博客
04-05 459
输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。我们每一次需要去比对当前两个链表的第一个结点的大小关系，然后将小的节点放入新的链表中即可。注：此处的遍历一次链表是指将两个链表的节点重新组合成一个新的链表。已知两个链表已经是有序链表，因此只需要遍历一次链表即可完成排序。数据范围： 0≤n≤1000，−1000≤节点值≤1000。要求：空间复杂度 O(1)，时间复杂度 O(n)
【LeetCode21】输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
weixin_47402684的博客
11-05 645
【LeetCode21】输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 思路：设计一个哨兵节点，遍历两个链表，将较小的元素接到哨兵节点尾部，最后将较长链表剩余的元素接到哨兵节点尾部即可 【代码】 /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; }
Java实现两个排序列表的合并输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
想找我?: 【编程张无忌的个人空间-哔哩哔哩】 https://b23.tv/0yjNTt2
09-20 704
示例1： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 思路非常简单: 1 定义个伪头结点,然后 定义个cur当前节点等于伪头结点 2 来个循环判断最小值 ,然后让cur .next指向他,不断更新 cur 3 然后判断是否一个为空另一个不是空,然后cur.next指向 非空的那个 4 返回伪头结点的 next class Solution { public ListNode ...
输入两个递增排序的链表，合并这两个链表并使新链表中的结点按照递减排序
Xiami2019的博客
02-24 1463
同学问到的简单的设计单链表的问题，就当温习C语言语法了，希望面试可以用的上。 Sample: list1: 1->3->6->9; list2: 2->4->5->12->19; result: 19->12->9->6->5->4->3->2->1; 使用C语言实现，因为最近练C++比较多，C语言...
链表：合并两个排序的链表
aishenla的博客
10-23 146
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 示例1： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 代码实现如下： class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode dum=new ListNode(0); ListNode
将两个递增的链表合并为一个非递减的链表
04-12
3. **链表合并算法**：这是本题目实现的关键部分，涉及到如何正确比较两个链表中的元素，并按照递增顺序进行合并。 #### 三、代码实现解析 ##### 1. 链表的创建与初始化 ```c struct List *InitList() { struct ...
2.（1）将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来的两个链表的存储空间，不另外占用其他的存储空间。表中不允许有重复的数据
最新发布
qq_53938756的博客
05-20 3803
因为要将两个有序单链表合并为一个递增的有序单链表，所以我们建立了三个单链表La，Lb，Lc，但是要求结果链表仍然使用原来两个链表的存储空间，所以我们用La的头结点作为Lc的头结点，这样直接操作单链表后，输出La单链表和Lc单链表结果是一样的。然后我们算法实现的思路是用三个工作结点pa，pb，pc指向此结点，然后进行比较，pa指向的此结点依次与pb的结点比较，直到比此时pb结点小，然后pa向下一个结点进行移动，然后重复刚刚的比较，直到其中一个单链表已经到尾结点。
【数据结构笔记】将两个递增的有序链表合并为一个递增的有序链表
热门推荐
oldpigfat的博客
01-19 1万+
将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中不允许有重复的数据。 [题目分析] 合并后的新表用头指针Lc指向，pa和pb分别是链表La和Lb的工作指针，初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，依次摘取其中较小者重新链接在Lc表的最后。如果两个表中的元素相等，只摘取La表中的元素，删除Lb表中的元素，这样确保合并后表中无重复的元素。当一个表到达表尾结点为空时，将非空表的剩余元素直
python 合并两个排序的链表
田亚辉的博客
11-14 853
合并两个排序的链表 输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 示例1： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 ｜ 题解 # Definition for singly-linked list. # class ListNode: # def __init__(self, x): # self.val = x # self.next = No
剑指 Offer 25. 合并两个排序的链表
虚心若愚
02-08 108
题目：剑指 Offer 25. 合并两个排序的链表 输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 示例1： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 限制：0 <= 链表长度 <= 1000 链接：https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof 解题： /** * Defi
C语言——合并两个递增排序链表
Eleanor_12的博客
12-13 1163
struct node { int num; struct node *next; }; typedef struct node Node; typedef Node * Link; Link Merge(Link head1, Link head2) { If(head1 == NULL) return head2; If(head2 == NULL) return head1; Link m
【LeetCode 力扣 剑指Offer 25】 合并两个排序的链表，输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
zhangxxin的博客
03-07 527
学习目标： 目标：熟练运用Java所学知识 学习内容： 本文内容：使用Java实现：合并两个排序的链表 文章目录学习目标：学习内容：题目描述：解题思路：实现代码 题目描述： 输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 示例1： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 解题思路： 将两个排序的链表合并成一个新的排序的链表，由于原链表是有序的，所以我们只需要按顺序遍历，比较两个
两个有序链表的整合
weixin_42738495的博客
03-07 92
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 示例1： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 限制： 0 <= 链表长度 <= 1000 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/he-bing-li...
剑指Offer LeetCode 面试题25. 合并两个排序的链表
TrueDei
06-01 1260
面试题25. 合并两个排序的链表 输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 示例1： 输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4 限制： 0 <= 链表长度 <= 1000 解题 package 链表; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; i
合并两个排序的链表
weixin_43327597的博客
04-07 375
合并两个排序的链表 输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 这个题目看似简单，但是反而花费了我比那些中等难度的题目更多的时间，这个题目的难点在于，可能会发生很多野指针判断出问题的情况，所以我们需要做很多的防护。 先给出代码： /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struc
合并两个递增有序链表的算法描述
这样，经过以上算法的处理，我们就可以将两个递增有序链表合并为一个递增有序链表，并且保证结果链表仍然使用原来两个链表的存储空间，不占用其他的存储空间，并且结果链表中没有重复的元素。 这个算法的时间复杂度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yiluohan0307

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值