1105 链表合并(JAVA)

简介: 给定两个单链表 L1​=a1​→a2​→⋯→an−1​→an​ 和 L2​=b1​→b2​→⋯→bm−1​→bm​。如果 n≥2m,你的任务是将比较短的那个链表逆序,然后将之并入比较长的那个链表,得到一个形如 a1​→a2​→bm​→a3​→a4​→bm−1​⋯ 的结果。例如给定两个链表分别为 6→7 和 1→2→3→4→5,你应该输出 1→2→7→3→4→6→5。

 

给定两个单链表 L1=a1→a2→⋯→an−1→an 和 L2=b1→b2→⋯→bm−1→bm。如果 n≥2m,你的任务是将比较短的那个链表逆序,然后将之并入比较长的那个链表,得到一个形如 a1→a2→bm→a3→a4→bm−1⋯ 的结果。例如给定两个链表分别为 6→7 和 1→2→3→4→5,你应该输出 1→2→7→3→4→6→5。

输入格式:

输入首先在第一行中给出两个链表 L1 和 L2 的头结点的地址,以及正整数

N (≤105),即给定的结点总数。一个结点的地址是一个 5 位数的非负整数,空地址 NULL 用 -1 表示。

随后 N 行,每行按以下格式给出一个结点的信息:

Address Data Next

image.gif

其中 Address 是结点的地址,Data 是不超过 105 的正整数,Next 是下一个结点的地址。题目保证没有空链表,并且较长的链表至少是较短链表的两倍长。

输出格式:

按顺序输出结果链表,每个结点占一行,格式与输入相同。

输入样例:

00100 01000 7
02233 2 34891
00100 6 00001
34891 3 10086
01000 1 02233
00033 5 -1
10086 4 00033
00001 7 -1

image.gif

输出样例:

01000 1 02233
02233 2 00001
00001 7 34891
34891 3 10086
10086 4 00100
00100 6 00033
00033 5 -1

image.gif

代码实现:

import java.io.*;
import java.util.ArrayList;
/**
 * @author yx
 * @date 2022-07-28 22:39
 */
public class Main {
    static PrintWriter out=new PrintWriter(System.out);
    static BufferedReader ins=new BufferedReader(new InputStreamReader(System.in));
    static StreamTokenizer in=new StreamTokenizer(ins);
    static class Node{
        int Address;
        int Data;
        int Next;
        Node(int address,int data,int next){
            Address=address;
            Data=data;
            Next=next;
        }
    }
    public static void main(String[] args) throws IOException {
        in.nextToken();
        int l1_initAddress=(int) in.nval;
        in.nextToken();
        int l2_initAddress=(int) in.nval;
        in.nextToken();
        int N=(int) in.nval;
        ArrayList<Node> list1=new ArrayList<>();//L1链表
        ArrayList<Node> list2=new ArrayList<>();//L2链表
        ArrayList<Node> ans=new ArrayList<>();//存储答案的链表
        Node[] nums=new Node[100000];
        for (int i = 0; i < N; i++) {
            in.nextToken();
            int address=(int) in.nval;
            in.nextToken();
            int data=(int) in.nval;
            in.nextToken();
            int next=(int) in.nval;
            nums[address]=new Node(address,data,next);
        }
        //初始化L1
        while (l1_initAddress!=-1){
            list1.add(nums[l1_initAddress]);
            l1_initAddress=nums[l1_initAddress].Next;
        }
//        for (int i = 0; i < list1.size(); i++) {
//            System.out.println(list1.get(i).Address+" "+list1.get(i).Data+" "+list1.get(i).Next);
//        }
        //初始化L2
        while (l2_initAddress!=-1){
            list2.add(nums[l2_initAddress]);
            l2_initAddress=nums[l2_initAddress].Next;
        }
//        for (int i = 0; i < list2.size(); i++) {
//            System.out.println(list2.get(i).Address+" "+list2.get(i).Data+" "+list2.get(i).Next);
//        }
        if(list1.size()>=2*list2.size()){
            //逆序
            for (int i = 0,j=list2.size()-1; i < j; i++,j--) {
                Node temp=list2.get(j);
                list2.set(j,list2.get(i));
                list2.set(i,temp);
            }
            int flag1=0;
            int flag2=0;
            for (int i = 0; i < list1.size(); i++) {
                ans.add(list1.get(i));
                flag1++;
                if(flag1%2==0&&flag2<list2.size()){
                    ans.add(list2.get(flag2));
                    flag2++;
                }
            }
        }else {
            //逆序
            for (int i = 0,j=list1.size()-1; i < j; i++,j--) {
                Node temp=list1.get(j);
                list1.set(j,list1.get(i));
                list1.set(i,temp);
            }
//           for (int i = 0; i < list1.size(); i++) {
//            System.out.println(list1.get(i).Address+" "+list1.get(i).Data+" "+list1.get(i).Next);
//        }
            int flag1=0;
            int flag2=0;
            for (int i = 0; i < list2.size(); i++) {
                ans.add(list2.get(i));
//                System.out.println(ans.get(i).Address);
                flag1++;
                if(flag1%2==0&&flag2<list1.size()){
                    ans.add(list1.get(flag2));
                    flag2++;
                }
            }
        }
        for (int i = 0; i < ans.size()-1; i++) {
//            System.out.println(1);
            out.printf("%05d %d %05d\n",ans.get(i).Address,ans.get(i).Data,ans.get(i+1).Address);
        }
        out.printf("%05d %d -1\n",ans.get(ans.size()-1).Address,ans.get(ans.size()-1).Data);
        //这个输出流一定要记得关
        out.flush();
    }
}

image.gif

image.gif编辑

相关文章
|
6月前
|
存储 Java
Java数据结构:链表
Java数据结构:链表
45 2
|
5月前
|
Java
环形数组链表(java)
环形数组链表(java)
|
3月前
|
存储 Java 开发者
揭秘!HashMap底层结构大起底:从数组到链表,再到红黑树,Java性能优化的秘密武器!
【8月更文挑战第24天】HashMap是Java集合框架中的核心组件,以其高效的键值对存储和快速访问能力广受开发者欢迎。在JDK 1.8及以后版本中,HashMap采用了数组+链表+红黑树的混合结构,实现了高性能的同时解决了哈希冲突问题。数组作为基石确保了快速定位;链表则用于处理哈希冲突;而当链表长度达到一定阈值时,通过转换为红黑树进一步提升性能。此外,HashMap还具备动态扩容机制,当负载因子超过预设值时自动扩大容量并重新哈希,确保整体性能。通过对HashMap底层结构的深入了解,我们可以更好地利用其优势解决实际开发中的问题。
101 0
|
3月前
|
算法 Java
LeetCode初级算法题:环形链表+排列硬币+合并两个有序数组java解法
LeetCode初级算法题:环形链表+排列硬币+合并两个有序数组java解法
54 0
|
3月前
|
存储 算法 Java
LeetCode初级算法题:反转链表+统计N以内的素数+删除排序数组中的重复项Java详解
LeetCode初级算法题:反转链表+统计N以内的素数+删除排序数组中的重复项Java详解
44 0
|
6月前
|
数据采集 Java 数据处理
Java流与链表:探索java.util.stream与LinkedList的交汇点
本文探讨了Java中流(Streams)与链表(LinkedList)的结合使用,展示了如何通过流处理LinkedList以实现高效数据操作。示例代码包括LinkedList的基本操作、使用Stream进行过滤和映射,以及结合HttpClient和代理IP实现网络爬虫。代理IP有助于绕过反爬机制,提高爬取效率。通过结合这些技术,开发者能编写出更简洁、高效的代码。
Java流与链表:探索java.util.stream与LinkedList的交汇点
|
5月前
|
存储 算法 Java
【经典算法】Leetcode 141. 环形链表(Java/C/Python3实现含注释说明,Easy)
【经典算法】Leetcode 141. 环形链表(Java/C/Python3实现含注释说明,Easy)
49 2
|
5月前
|
算法 Java C语言
【经典算法】LeetCode25:K 个一组翻转链表(Java/C/Python3,Hard)
【经典算法】LeetCode25:K 个一组翻转链表(Java/C/Python3,Hard)
33 1
|
5月前
|
算法 安全 Java
【经典算法】LeetCode 21:合并两个有序链表Java/C/Python3实现含注释说明,Easy)
【经典算法】LeetCode 21:合并两个有序链表Java/C/Python3实现含注释说明,Easy)
36 1
|
6月前
|
存储 算法 Java
手撕Java集合——链表
手撕Java集合——链表