线性表练习之Example038-编写一个函数将链表 h2 链接到链表 h1 之后，要求链接后的链表仍然保持循环链表形式

最新推荐文章于 2022-06-20 16:47:23 发布
最新推荐文章于 2022-06-20 16:47:23 发布
阅读量427 收藏 7
点赞数 1
分类专栏： 数据结构 文章标签： java c 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnds123321/article/details/123806359
版权

Example038

原文链接：Example038

题目

有两个循环单链表，链表头指针分别为 h1 和 h2，编写一个函数将链表 h2 链接到链表 h1 之后，要求链接后的链表仍然保持循环链表形式。

分析

本题考查的知识点：

  • 循环单链表

算法思想：将循环单链表 h1 的尾节点的 next 指针指向链表 h2 的第一个节点，然后再将链表 h2 的尾节点的 next 指针指向链表 h1 的头结点。

图解

请添加图片描述

C实现

核心代码：

/**
 * 将循环单链表 h2 链接到循环单链表 h1 的后面，并仍然保持循环
 * @param h1 第一个循环单链表，链接完成后，变成拥有 h1 和 h2 的循环单链表
 * @param h2 第二个循环单链表
 */
void concatList(CLNode *h1, CLNode *h2) {
    // 1.将链表 h2 尾节点的 next 指针指向链表 h1 的头节点
    // 变量，记录链表 h2 的每一个节点，初始为链表 h2 的第一个节点
    CLNode *h2Node = h2->next;
    // 1.1 通过遍历链表找到链表 h2 的最后一个节点
    while (h2Node->next != h2) {// 注意，循环结束条件的是 h2Node->next!=h2，循环结束后 h2Node 就是链表 h2 的尾节点
        h2Node = h2Node->next;
    }
    // 1.2 将链表 h2 尾节点的 next 指针指向链表 h1 的头节点
    h2Node->next = h1;

    // 2.将链表 h1 尾节点的 next 指针指向链表 h2 的第一个节点
    // 变量，记录链表 h1 的每一个节点，初始为链表 h1 的第一个节点
    CLNode *h1Node = h1->next;
    // 2.1 通过遍历链表找到链表 h1 的最后一个节点
    while (h1Node->next != h1) {// 注意，循环结束条件的是 h1Node->next!=h1，循环结束后 h1Node 就是链表 h1 的尾节点
        h1Node = h1Node->next;
    }
    // 2.2 将链表 h1 尾节点的 next 指针指向链表 h2 的第一个节点
    h1Node->next = h2->next;
}

完整代码：

#include <stdio.h>
#include <stdlib.h>

/**
 * 循环单链表的节点
 */
typedef struct CLNode {
    /**
     * 链表节点的数据域
     */
    int data;
    /**
     * 链表节点的指针域，指向后继节点
     */
    struct CLNode *next;
} CLNode;

/**
 * 通过尾插法创建循环单链表
 * @param list  循环单链表
 * @param nums 待插入到单链表中的数据数组
 * @param n 数组长度
 * @return 创建成功的循环单链表
 */
CLNode *createByTail(CLNode **list, int nums[], int n) {
    // 1.初始化循环单链表，即创建循环单链表的头结点。也可以直接调用 init 函数来初始化
    // 1.1 为头结点分配空间
    *list = (CLNode *) malloc(sizeof(CLNode));
    // 1.2 修改头结点的 next 指针，将其指向自己，而普通单链表是指向 null
    (*list)->next = *list;// 注意，指向头结点本身

    // 保存链表的尾节点，初始为链表的头节点，即空链表的尾节点就是链表的头节点
    CLNode *tailNode = *list;

    // 2.循环数组 nums 中所有数据，插入到单链表中
    for (int i = 0; i < n; i++) {
        // 2.1 创建新节点
        // 2.1.1 给新节点分配空间
        CLNode *newNode = (CLNode *) malloc(sizeof(CLNode));
        // 2.1.2 指定新节点的数据域
        newNode->data = nums[i];
        // 2.1.3 将新节点的指针域置为 null，指向空
        newNode->next = NULL;

        // 2.2 将新节点追加到链表的尾部
        // 2.2.1 将链表原尾节点的 next 指针指向新节点，即让新节点成为链表的尾节点
        tailNode->next = newNode;
        // 2.2.2 然后将新节点（即链表新的尾节点）指向链表的头节点
        newNode->next = *list;
        // 2.2.3 然后将 tailNode 指向新节点（即新的尾节点）
        tailNode = newNode;
    }

    // 3.返回创建成功的链表
    return *list;
}

/**
 * 将循环单链表 h2 链接到循环单链表 h1 的后面，并仍然保持循环
 * @param h1 第一个循环单链表，链接完成后，变成拥有 h1 和 h2 的循环单链表
 * @param h2 第二个循环单链表
 */
void concatList(CLNode *h1, CLNode *h2) {
    // 1.将链表 h2 尾节点的 next 指针指向链表 h1 的头节点
    // 变量，记录链表 h2 的每一个节点，初始为链表 h2 的第一个节点
    CLNode *h2Node = h2->next;
    // 1.1 通过遍历链表找到链表 h2 的最后一个节点
    while (h2Node->next != h2) {// 注意，循环结束条件的是 h2Node->next!=h2，循环结束后 h2Node 就是链表 h2 的尾节点
        h2Node = h2Node->next;
    }
    // 1.2 将链表 h2 尾节点的 next 指针指向链表 h1 的头节点
    h2Node->next = h1;

    // 2.将链表 h1 尾节点的 next 指针指向链表 h2 的第一个节点
    // 变量，记录链表 h1 的每一个节点，初始为链表 h1 的第一个节点
    CLNode *h1Node = h1->next;
    // 2.1 通过遍历链表找到链表 h1 的最后一个节点
    while (h1Node->next != h1) {// 注意，循环结束条件的是 h1Node->next!=h1，循环结束后 h1Node 就是链表 h1 的尾节点
        h1Node = h1Node->next;
    }
    // 2.2 将链表 h1 尾节点的 next 指针指向链表 h2 的第一个节点
    h1Node->next = h2->next;
}

/**
 * 打印循环单链表
 * @param list 待打印的循环单链表
 */
void print(CLNode *list) {
    printf("[");
    CLNode *node = list->next;
    while (node != list) {
        printf("%d", node->data);
        if (node->next != list) {
            printf(", ");
        }
        node = node->next;
    }
    printf("]\n");
}

int main() {
    // 声明循环单链表 h1
    CLNode *h1;
    int nums1[] = {111, 222, 333, 444, 555};
    int n1 = 5;
    createByTail(&h1, nums1, n1);
    print(h1);

    // 声明循环单链表 h2
    CLNode *h2;
    int nums2[] = {5, 4, 3, 2, 1};
    int n2 = 5;
    createByTail(&h2, nums2, n2);
    print(h2);

    // 调用函数，链接两个循环单链表
    concatList(h1, h2);
    print(h1);
}

执行结果：

[111, 222, 333, 444, 555]
[5, 4, 3, 2, 1]
[111, 222, 333, 444, 555, 5, 4, 3, 2, 1]

Java实现

核心代码：

    /**
     * 将循环单链表 h2 链接到循环单链表 h1 的后面，并仍然保持循环
     *
     * @param h1 第一个循环单链表，链接完成后，变成拥有 h1 和 h2 的循环单链表
     * @param h2 第二个循环单链表
     */
    public void concatList(CircularLinkedList h1, CircularLinkedList h2) {
        // h1.list 和 h2.list 分别表示循环单链表 h1 和 h2 的头节点
        // h1.list.next 和 h2.list.next 分别表示循环单链表 h1 和 h2 的第一个节点
        // 链表 h1 和 h2 的头节点
        CLNode head1 = h1.list;
        CLNode head2 = h2.list;

        // 链表 h2 的第一个节点
        CLNode h2Node = head2.next;
        // 找到链表 h2 的最后一个节点
        while (h2Node.next != head2) {
            h2Node = h2Node.next;
        }
        // 将链表 h2 尾节点的 next 指针指向链表 h1 的头节点
        h2Node.next = head1;

        // 链表 h1 的第一个节点
        CLNode h1Node = head1.next;
        // 找到链表 h1 的最后一个节点
        while (h1Node.next != head1) {
            h1Node = h1Node.next;
        }
        // 将链表 h1 尾节点的 next 指针指向链表 h2 的第一个节点
        h1Node.next = head2.next;
    }

完整代码：

public class CircularLinkedList {
    private CLNode list;

    /**
     * 通过尾插法创建循环单链表
     *
     * @param nums 待插入到单链表中的数据数组
     * @return 创建成功的循环单链表
     */
    public CLNode createByTail(int... nums) {
        // 1.初始化循环单链表，即创建循环单链表的头结点。也可以直接调用 init 函数来初始化
        // 1.1 为头结点分配空间
        list = new CLNode();
        // 1.2 修改头结点的 next 指针，将其指向自己，而普通单链表是指向 null
        list.next = list;// 注意，这里同单链表不同的是，指向了自己

        // 保存链表的尾节点，初始为链表的头节点，即空链表的尾节点就是链表的头节点
        CLNode tailNode = list;

        // 2.循环数组 nums 中所有数据，插入到单链表中
        for (int i = 0; i < nums.length; i++) {
            // 2.1 创建新节点
            // 2.1.1 给新节点分配空间
            CLNode newNode = new CLNode();
            // 2.1.2 指定新节点的数据域
            newNode.data = nums[i];
            // 2.1.3 将新节点的指针域置为 null，指向空
            newNode.next = null;

            // 2.2 将新节点追加到链表的尾部
            // 2.2.1 将链表原尾节点的 next 指针指向新节点，即让新节点成为链表的尾节点
            tailNode.next = newNode;
            // 2.2.2 然后将新节点（即链表新的尾节点）指向链表的头节点
            newNode.next = list;
            // 2.2.3 然后将 tailNode 指向新节点（即新的尾节点）
            tailNode = newNode;
        }

        // 3.返回创建成功的链表
        return list;
    }

    /**
     * 将循环单链表 h2 链接到循环单链表 h1 的后面，并仍然保持循环
     *
     * @param h1 第一个循环单链表，链接完成后，变成拥有 h1 和 h2 的循环单链表
     * @param h2 第二个循环单链表
     */
    public void concatList(CircularLinkedList h1, CircularLinkedList h2) {
        // h1.list 和 h2.list 分别表示循环单链表 h1 和 h2 的头节点
        // h1.list.next 和 h2.list.next 分别表示循环单链表 h1 和 h2 的第一个节点
        // 链表 h1 和 h2 的头节点
        CLNode head1 = h1.list;
        CLNode head2 = h2.list;

        // 链表 h2 的第一个节点
        CLNode h2Node = head2.next;
        // 找到链表 h2 的最后一个节点
        while (h2Node.next != head2) {
            h2Node = h2Node.next;
        }
        // 将链表 h2 尾节点的 next 指针指向链表 h1 的头节点
        h2Node.next = head1;

        // 链表 h1 的第一个节点
        CLNode h1Node = head1.next;
        // 找到链表 h1 的最后一个节点
        while (h1Node.next != head1) {
            h1Node = h1Node.next;
        }
        // 将链表 h1 尾节点的 next 指针指向链表 h2 的第一个节点
        h1Node.next = head2.next;
    }

    /**
     * 打印循环单链表
     */
    public void print() {
        // 链表的第一个节点
        CLNode node = list.next;
        // 循环单链表，打印单链表的每个节点的数据值
        String str = "[";
        while (node != list) {
            str += node.data;
            if (node.next != list) {
                str += ", ";
            }
            node = node.next;
        }
        str += "]";
        // 打印结果
        System.out.println(str);
    }
}

/**
 * 循环单链表节点
 */
class CLNode {
    /**
     * 节点的数据域
     */
    int data;
    /**
     * 节点的指针域，指向后继节点
     */
    CLNode next;
}

测试代码：

public class CircularLinkedListTest {
    public static void main(String[] args) throws Exception {
        // 创建循环单链表 A
        CircularLinkedList A = new CircularLinkedList();
        A.createByTail(111, 222, 333, 444, 555);
        A.print();

        // 创建循环单链表 B
        CircularLinkedList B = new CircularLinkedList();
        B.createByTail(5, 4, 3, 2, 1);
        B.print();

        // 调用函数连接链表
        CircularLinkedList list = new CircularLinkedList();
        list.concatList(A, B);
        A.print();
    }
}

执行结果：

[111, 222, 333, 444, 555]
[5, 4, 3, 2, 1]
[111, 222, 333, 444, 555, 5, 4, 3, 2, 1]
二木成林
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
将循环单链表h2链接到循环单链表h1之后
打字员blog
07-24 440
题目： 有两个循环单链表，链表头指针分别为h1和h2，编写一函数，将链表h2链接到链表h1之后，要求链接后的链表仍保持循环链表的形式。 分析：把链表h1的尾指针，改为指向h2即可；将h2的尾指针指向h1的第一个结点； LinkList Link(LinkList &h1,LinkList &h2){//假设两个链表都带有头结点； if(h2->next == h2) return; //链表h2为空表,不需要链接； //查找尾指针； r1 = Sear
数据结构学习--线性表及其应用--链表
06-25
单向链表是最简单的链表形式，每个节点包含一个数据域和一个指向下一个节点的指针。在本程序中，数据域被定义为字符串类型，这样可以存储各种文本信息。链表的头节点是一个特殊的节点，其指针域指向链表的第一个实际...
18,有两个循环单链表,链表头指针分别为h1和h2,编写一个函数将链表h2链接到链表 h1之后,要求链接后的链表仍保持循环链表形式。
Anthony_4926
06-30 1548
18,有两个循环单链表,链表头指针分别为h1和h2,编写一个函数将链表h2链接到链表h1之后,要求链接后的链表仍保持循环链表形式。 思路：两个链表都找到最后一个节点，然后再链接 #include<iostream> #include<algorithm> #include<cstdio> #include<cstring> #include<cmath> #include<map> #include<vector&g
有两个循环单链表,链表头指针分别为h1和h2,编写一个函数将链表h2链接到链表 h1之后,要求链接后的链表仍保持循环链表形式。
江冷易水寒
08-22 2168
代码： LinkList* connectList(LinkList* L1,LinkList* L2){ //L1尾接到L2头,L2尾接到L1头 LinkList* p1 = L1->next; LinkList* p2 = L2->next; while(p1->next!=L1) p1 = p1->next; p1->next = L2;//L1尾接到L2头节点 while(p2->next!=L2
循环链表：两个循环单链表合并成一个循环单链表
花间半盘棋
11-11 4858
题目：有两个循环单链表，链表头指针分别为h1和h2，编写一个函数将链表h2链接到链表 h1之后，要求链接后的链表仍保持循环链表的形式。 分析：题目意思就是将两个循环单链表合并成1个 算法思想：找到h1的表尾p，h2的表尾q。将p指向h2，q指向h1。这样就变成了一条循环单链表，即合并完成。 代码： void merge(Linklist &h1, Linklist &h2){ LNode *p,*q; p=h1; q=h2; while(p->next!=h1){ //p-
王道数据结构2022-线性表的链式表示-综合题(p41)-18有两个循环单链表,链表头指针分别为h1和h2,编写一个函数将链表h2链接到链表h1之后,要求链接后的链表仍保持循环链表形式
好奇独角兽
08-29 457
有两个循环单链表,链表头指针分别为h1和h2,编写一个函数将链表h2链接到链表h1之后,要求链接后的链表仍保持循环链表形式 #include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct LNode { //定义单链表结点类型 ElemType data;//数据域 struct LNode *next;//指针域 } LNode, *LinkList; /*有两个循环单链表,链表头指针分别
数据结构c版（1）-线性表之双向带头循环链表代码
最新发布
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
一算法可实现两个非递减的线性表的合并，采用链式存储结构，能够输出合并前和合并后链表的内容
09-12
3. 如果A的节点值小于或等于B的节点值，将A的节点添加到新链表head后面，然后移动A的指针到下一个节点。 4. 否则，将B的节点添加到新链表head后面，然后移动B的指针到下一个节点。 5. 重复步骤3和4，直到其中一个...
2. 线性表-链式存储-链表1
08-03
线性表是计算机科学中基础的数据结构之一，它是由相同类型元素组成的有序序列。在实际应用中，线性表可以采用两种不同的存储方式：顺序存储和链式存储。本篇主要讨论的是链式存储，特别是链表这一实现方式。 链表是...
带头结点双链循环线性表.rar_循环双链表
09-14
循环双链表是一种高效的数据结构，它在单链表的基础上扩展了双向链接的功能，并形成了一个首尾相连的环形结构。这种数据结构在程序设计中非常常见，特别是在处理线性序列的问题时，如动态内存分配、文件系统管理等...
单链表、双链表、循环链表和静态链表以及相应习题习题
热门推荐
Wlain的博客
08-26 1万+
一、单项选择题1.关于线性表的顺序存储结构和链式存储结构的描述中，正确的是（ ）。 Ⅰ.线性表的顺序存储结构优于其链式存储结构 Ⅱ.链式存储结构比顺序存储结构能更方便地表示各种逻辑结构 Ⅲ.如频繁使用插入和删除结点操作，顺序存储结构更优于链式存储结构 Ⅳ.顺序存储结构和链式存储结构都可以进行顺序存取A. Ⅰ、Ⅱ、Ⅲ B. Ⅱ、Ⅳ C. Ⅱ、Ⅲ D. Ⅲ、Ⅳ2.对于一个
将循环链表h2链接到循环链表h1之后仍保持循环链表形式
z_x_y_zxy的博客
10-11 190
注意： 循环链表的基本操作与单链表的不同 Link_L1L2函数中应该令p1->next = p2， 如果令p1->next = L2，结果会输出L2->data 错误如图所示： #include<stdio.h> #include<stdlib.h> typedef struct DuLNode { int data; struct DuLNode *prior; struct DuLNode *next; }DuLNode, *DuLinkL
将两个循环链表连接并使得连接后依然是循环链表
越过山丘
02-28 195
typedef struct node { int data; struct node *next; } LNode, *LinkList; LinkList Link(LinkList h1, LinkList h2) { LNode *p = h1->next, *q = h2->next; while (p->next != h1) { p = p->next; } while (q->next !
合并两条循环单链表
北街lhy的博客
03-18 672
题目：有两个循环单链表，链表头指针分别为h1和h2，编写一个函数将链表h2连接到h1之后，要求连接后的链表仍保持循环链表形式。 分析： 首先我们要找到h1的尾结点，找到尾结点后将尾结点的next指向h2的首节点，然后找到h2的尾结点，将其next指针指向h1， 就大功告成了。 代码： struct Link { int data; struct Link *next; }; #include <stdlib.h> #include <stdio.h...
小白算法积累——单链表18#2个循环单链表+合并
aprilzj123的博客
02-20 259
题目：有两个循环单链表，链表头指针分别为h1和h2，编写一个函数将链表h2链接到h1之后，要求链接后的链表仍保持循环链表形式。 关键字：合并两个循环链表 思路 关注：递归算法的设计重点在于找到“递归”的部分，即重复调用函数，改变部分相关变量 设f(L,x)的功能是：删除以L为首结点指针的单链表中所有值等于x的结点，显然有f(L->next,x) 1.通用逆置函数:遍历循环+头尾元素互换 需要...
第1章第2节练习题20 连接两个循环单链表
法海你懂不?
01-13 1802
有两个循环单链表，链表头指针分别为h1和h2，编写一个函数将链表h2连接到链表h1之后，要求链表后的链表仍保持循环链表的形式
【王道数据结构编程题】 - 链表代码题
m0_56051805的博客
06-20 1231
王道代码题具体实现，可运行，1.设计一个递归算法，删除不带头节点的单链表L中所有值为x的节点。2.在带头节点的单链表L中，删除所有值为x的节点，并释放其空间，假设值为x的节点不唯一，试编写算法以实现上述操作。3.设L为带头节点的单链表，编写算法实现从尾到头反向输出每个节点的值。4.试编写在带头节点的单链表L这删除一个最小值节点的高效算法(假设最小值节点是唯一的)。5.试着编写算法将带头节点的单链表就地逆置，所谓“就地”就是辅助空间复杂度为O(1)。6.有一个带头节点的单链表L，设计一个算法使其元素递增有序。
c语言将两个循环链表合并成一个循环链表(16)
Yannie's Blog
04-12 3858
这道题我是直接将l1的尾链表指针指向l2的头链表指针，然后释放l2的头链表指针，然后将l2的尾链表指针指向l1的头链表指针(merge1函数) 但是答案的话是利用头插法将长度短的链表插入到长度长的链表(merge2函数) 两个我都实现了 代码 #include<stdio.h> #include<stdlib.h> #include<assert.h> //...
leetCode第二题答案，两个链表存储形式的数据加和，最终返回一个链表（java版分析）
siying8419的博客
03-20 500
题目详情 我的开始代码解析 这个代码是简单实现版，没有追求代码的精简。 package com.ke.leetCodes; class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } //Input: (2 -> 4 -> 3) + (5 -> 6 -&g...
详解线性表与循环链表基础及其操作
5. **约瑟夫环问题**：虽然在给定的描述中没有提及，但约瑟夫环是一种与线性表相关的经典问题，涉及在一个循环链表中找到满足特定条件的元素。这个问题展示了线性表在算法设计中的应用。 总结来说，线性表是数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值