单链表之连接两个链表

最新推荐文章于 2022-11-21 12:31:30 发布
最新推荐文章于 2022-11-21 12:31:30 发布
阅读量1.2w 收藏 54
点赞数 16
CC 4.0 BY-SA版权
分类专栏： C++ 数据结构 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_29567701/article/details/79934929

1：要求
单链表L1： 1–>3–>5–>7
单链表L2： 2–>4–>6–>8
连接后： 1–>3–>5–>7–>2–>4–>6–>8
2：连接代码
单链表的结构定义如下：

struct ListNode
{
    int m_nValue;//链表结点值
    ListNode* m_pNext;
};

连接代码 方法一：
连接后生成新的链表：

ListNode *MyUnion(ListNode *pHead1, ListNode *pHead2)
{
    ListNode *pNode = pHead1;
    while (pNode->m_pNext)
        pNode = pNode->m_pNext;
    pNode->m_pNext = pHead2;
    return pHead1;
}

连接代码 方法二：
不生成新链表，将链表L2 直接链在 链表L1的尾巴上，改变链表L1，使用 引用&，
代码如下：

void ConnectedLists2(ListNode * &pHead1, ListNode *pHead2)
{
    ListNode *pNode = pHead1;
    while (pNode->m_pNext)//while (pNode)错误  特别注意：是pNode->m_pNext
        pNode = pNode->m_pNext;
    pNode->m_pNext = pHead2;
}

两种方法经测试均可用。

3、测试代码

#include<iostream>
using namespace std;
struct ListNode
{
    int m_nValue;
    ListNode* m_pNext;
};

//---------------------MyUnion()---------------------------------------------
ListNode *MyUnion(ListNode *pHead1, ListNode *pHead2)
{
    if (pHead1 == NULL)//考虑两个链表有一个为空
        return pHead2;
    if (pHead2 == NULL)
        return pHead1;
    ListNode *pNode = pHead1;
    while (pNode->m_pNext)
        pNode = pNode->m_pNext;
    pNode->m_pNext = pHead2;
    return pHead1;
}
//------------------------------------------------------------------
ListNode* CreateNode(int value)
{
    ListNode *pNode = new ListNode();
    pNode->m_nValue = value;
    pNode->m_pNext = NULL;
    return pNode;
}

void ConnectedNodes(ListNode* pnode1, ListNode* pnode2)
{
    if (pnode1 == NULL)
        exit(1);
    pnode1->m_pNext = pnode2;
}

void DestroyNodes(ListNode* &pHead)
{
    ListNode *pNode = pHead;
    while (pNode)
    {
        pHead = pHead->m_pNext;
        delete pNode;
        pNode = pHead;
    }
}

void DispLisNode(ListNode* pHead)
{
    ListNode *pNode = pHead;
    while (pNode)
    {
        cout << pNode->m_nValue;
        if (pNode->m_pNext)
            cout << "-->";
        pNode = pNode->m_pNext;
    }
    cout << endl;
}
//--------------------------------------------------------------------
int main()
{
    ListNode* pNode1 = CreateNode(1);
    ListNode* pNode2 = CreateNode(2);
    ListNode* pNode3 = CreateNode(3);
    ListNode* pNode4 = CreateNode(4);

    ListNode* pNode5 = CreateNode(5);
    ListNode* pNode6 = CreateNode(6);
    ListNode* pNode7 = CreateNode(7);
    ListNode* pNode8 = CreateNode(8);

    ConnectedNodes(pNode1, pNode3);
    ConnectedNodes(pNode3, pNode5);
    ConnectedNodes(pNode5, pNode7);
    DispLisNode(pNode1);

    ConnectedNodes(pNode2, pNode4);
    ConnectedNodes(pNode4, pNode6);
    ConnectedNodes(pNode6, pNode8);
    DispLisNode(pNode2);

    ListNode* node1 = MyUnion(pNode1, pNode2);//连接两个链表
    DispLisNode(node1);

    DestroyNodes(node1);

    return 0;
}

测试结果：

合并两个递增单链表（单链表）
m0_49844997的博客
12-10 840
合并两个递增单链表 给定两个递增有序的单链表LA和LB，目标是合并它们成为一个新的递增有序的单链表LC。合并后的链表LC将包含LA和LB中的所有元素，并且保持递增有序。
链表详解（单链表、双向链表、链表逆序）
别呀的博客
04-07 2131
单链表 想了解单链表的一些概念可以看我另一篇博客： 链表基础 单链表结构体定义 //单链表的结构定义 typedef struct LNode { int data; //data存放结点数据域 struct LNode *next; //指向后继结点的指针 }LNode; 单链表的建立 （1）定义单链表的数据结构； （2）读取数据； （3）生成新结点； （4）将数据存入结点的成员变量中； （5）将新结点连接到表头或表尾。 重复（2）~（5）直到输入结束。 //头插法建立单链表 void c
实现两个链表类的链接
10-20
实现两个链表类的链接，实现加法“+”对链表的实现
两个单链表的链接
菜鸟的飞行日记
08-05 416
#include <stdio.h> #include <stdlib.h> #include<iostream> using namespace std; #define maxsize 1010 typedef struct lnode{ char data; struct lnode *next; }lnode,*linklist; linklist creatlink(linklist &l,int n,char a[]){
连接两个链表
htzld523的专栏
05-08 778
程序源代码： #include "stdlib.h" #include "stdio.h" struct list { int data; struct list *next; }; typedef struct list node; typedef node *link; link delete_node(link pointer,link tmp) {if (tmp==NU
连接两个排序的单链表
weixin_30654583的博客
03-31 192
牛客中的代码是这样的： struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } }; ListNode* Merge(ListNode* pHead1, ListNode* pHead2) { if (pHead1 == NULL &...
两个单链表连接
Jack20010808的博客
11-21 1451
链表这一块最复杂的就是换指方面，尾插难度不大，中间插入的话插入结点的步骤理清就好办了。
基于Java实现的单链表基本操作之链表合并.zip
04-26
当其中一个链表为空时，返回另一个链表即可。 这个项目提供了一种具体实现单链表合并的Java代码，可以帮助学习者深入理解链表操作，并能应用于实际问题解决。通过对这个项目的实践，可以提升对数据结构的理解，增强...
基于Java实现的单链表基本操作之链表分割.zip
04-26
链表分割通常是指将一个链表分为两个部分，根据特定条件（如长度、值等）。这里，我们讨论一种常见的分割方法：将链表按中间节点分割成两半。首先，我们需要计算链表的长度，然后找到中间节点并创建一个新的头节点，...
snake_eggs2.rar_Windows编程_snake_单链表_贪吃蛇_贪吃蛇 链表
09-22
在贪吃蛇游戏中，蛇的身体可以被视为一个链表，头部是链表的头节点，每次移动，蛇的尾部会被更新为新的位置，而头部则向新方向移动，这就需要对链表进行插入和删除操作。 **贪吃蛇的实现**利用了链表的特性。蛇的每...
连接两个链表c语言
07-19
#include "stdlib.h"#include "stdio.h"struct list{ int data;struct list *next;};typedef struct list node;typedef node *link;link delete_node(link pointer,link tmp){if (tmp==NULL) /*delete first node*/　 return pointer->next;else{ if(tmp->next->next==NULL)/*delete last node*/　　 tmp->next=NULL;　 else /*delete the other node*/　　 tmp->next=tmp->next->next;　 return pointer;}}void selection_sort(link pointer,int num){ link tmp,btmp;　 int i,min;　 for(i=0;i<num;i++)　 {　 tmp=pointer;　 min=tmp->data;　 btmp=NULL;　 while(tmp->next)　 { if(min>tmp->next->data)　 {min=tmp->next->data;　　 btmp=tmp;　 }　 tmp=tmp->next;　 }printf("\40: %d\n",min);pointer=delete_node(pointer,btmp);}}link create_list(int array[],int num){ link tmp1,tmp2,pointer;int i;pointer=(link)malloc(sizeof(node));pointer->data=array[0];tmp1=pointer;for(i=1;i<num;i++){ tmp2=(link)malloc(sizeof(node));　 tmp2->next=NULL;　 tmp2->data=array[i];　 tmp1->next=tmp2;　 tmp1=tmp1->next;}return pointer;}link concatenate(link pointer1,link pointer2){ link tmp;tmp=pointer1;while(tmp->next)　 tmp=tmp->next;tmp->next=pointer2;return pointer1;}void main(void){ int arr1[]={3,12,8,9,11};　 link ptr;　 ptr=create_list(arr1,5);　 selection_sort(ptr,5);}
链表中插入数据并将两个链表相互连接起来
06-26
在链表中插入数据并将两个链表连接起来，本代码是在大学阶段我自己手写的，比较适合正在学习数据结构的朋友，简单易懂。
链表的连接
10-15
*文件名:TEST1.C *功 能:该程序实现的功能是将两个新建的线性链表连接在一起 *说 明:该程序为了把两个已经建立的链表连接在一起，两个链表中的数据交替出现， 而且总是短的链表中的数据先出现，长的链表
连接两个单链表的一种解法
jjjstephen的博客
08-11 1273
单链表习题 该解法并非最优，时间复杂度为O(n)。 test.h #ifndef TEST_H_ #define TEST_H_ #include<malloc.h> typedef int ElemType; typedef struct Node { ElemType data; struct Node * next; }Node; typedef struct Node * Linklist; //利用尾插法创建线性表整表 Linklist createOneList(const i
题目：连接两个链表。
m0_45696196的博客
01-20 231
题目：连接两个链表。 #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct{ int data; struct LNode *next; }LNode,*LinkList; LinkList CreatList(int n); void print(LinkList s); LinkList connect(LinkList s1,LinkList s2); int main
两个单循环链表的连接
qq_924070845的博客
09-25 1995
两个单循环链表的连接 小甲鱼视屏线性表14将链表A的尾指针指向链表B的第一个节点（不是头结点哦），再将链表B的尾节点指向链表A的头结点，最后释放B的头结点，因为一个链表只需要一个头结点就好了。 typedef struct node{ /**结构体定义了一个节点data就是节点数据域，*next就是节点的指针域
链接两个有序链表
qq_48299410的博客
11-11 857
连接链表
Golang切片
ALakers的博客
08-27 391
在64位的机器上，golang切片长度24位，指针8位，长度8位，容量8位 数组切片map都是传指针 什么是切片(slice) 简单的说，数组切片就像一个指向数组的指针，实际上它拥有自己的数据结构，而不仅仅是个指针。数组切片的数据结构可以抽象为以下3个变量： 　　1>．一个指向原生数组的指针（point）：指向数组中slice指定的开始位置； 　　2>．数组切片中的元素个数（len）：即slice的长度； 　　3>．数组切片已分配的存储空间（cap）：也就是slice开始位置到数组的最
将单链表拆分成两个链表，两个链表由原链表元素交替构成
最新发布
10-31
将单链表拆分成两个链表，使得每个新链表中的节点顺序是原链表交替的，这是一个常见的链表操作，通常称为“奇偶分割”或者“交替拆分”。以下是基本步骤： 1. 首先，我们需要创建两个新的空链表，分别作为结果的“奇数链表”和“偶数链表”。 2. 初始化两个指针，一个指向原始链表的头节点（`p1`），另一个初始化为`None`，这将用于表示“偶数链表”的当前节点（`p2`）。 3. 当`p1`不为空时，执行以下操作： a. 将`p1`的值添加到相应的链表（如果`p2`尚未设置，则添加到“奇数链表”，否则添加到“偶数链表”）。 b. 更新指针，使`p1`指向下一个节点（`p1.next`），同时更新`p2`（如果`p2`已经存在，则让它指向`p1.next`；否则保持不变）。 c. 继续上述过程，直到`p1`变为`None`。 4. 最后，如果`p2`仍然有剩余的节点，那么“偶数链表”可能会比“奇数链表”长一节。在这种情况下，只需将`p2`的剩余部分移动到“偶数链表”的前面即可。 以下是一个Python的伪代码实现： ```python def split_linked_list(head): # 创建初始指针 odd_head = even_head = None current = head while current is not None: # 奇数链表添加当前节点 if odd_head is None: odd_head = current else: odd_next = odd_head.next odd_head.next = current odd_head = odd_next # 检查是否有偶数节点 if current.next is not None: current = current.next.next else: # 如果偶数链表还有剩余，移到前面 if even_head is not None: current = even_head else: current = None # 将最后的偶数链表连接到奇数链表尾部 if even_head is not None and odd_head is not None: odd_head.next = even_head return odd_head, even_head ```
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值