java创建两个链表

在Java中，我们可以使用`LinkedList`类来创建链表。这里是一个简单的例子展示如何创建和操作两个链表：

首先，需要导入`java.util.LinkedList`包：

import java.util.LinkedList;

1. 创建空链表：

// 创建单向链表
LinkedList<String> list1 = new LinkedList<>();
LinkedList<Integer> list2 = new LinkedList<>();

2. 添加元素到链表：

list1.add("Element1");
list1.add("Element2");

list2.add(1);
list2.add(2);

3. 链表之间没有直接关联，所以你可以独立地对它们进行操作，比如获取元素、删除元素等：

System.out.println(list1); // 输出: [Element1, Element2]
System.out.println(list2); // 输出: [1, 2]

// 删除元素
list1.removeFirst(); // 只能删除第一个元素
list2.removeLast(); // 删除最后一个元素

相关问题

利用java根据输入的链表将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的

在Java中，可以通过以下步骤将两个升序链表合并为一个新的升序链表：

1. 创建一个新的链表头节点。
2. 遍历两个链表，比较当前节点的值，将较小的节点添加到新链表中。
3. 重复步骤2，直到其中一个链表遍历完。
4. 将剩余的链表节点添加到新链表的末尾。
5. 返回新链表的头节点。

以下是一个示例代码：

class ListNode {
    int val;
    ListNode next;
    ListNode(int val) { this.val = val; }
}

public class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(0);
        ListNode current = dummy;

        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                current.next = l1;
                l1 = l1.next;
            } else {
                current.next = l2;
                l2 = l2.next;
            }
            current = current.next;
        }

        if (l1 != null) {
            current.next = l1;
        }
        if (l2 != null) {
            current.next = l2;
        }

        return dummy.next;
    }

    // 辅助方法：打印链表
    public void printList(ListNode node) {
        while (node != null) {
            System.out.print(node.val + " ");
            node = node.next;
        }
    }

    // 测试方法
    public static void main(String[] args) {
        Solution solution = new Solution();
        
        // 创建第一个升序链表: 1->3->5
        ListNode l1 = new ListNode(1);
        l1.next = new ListNode(3);
        l1.next.next = new ListNode(5);

        // 创建第二个升序链表: 2->4->6
        ListNode l2 = new ListNode(2);
        l2.next = new ListNode(4);
        l2.next.next = new ListNode(6);

        // 合并链表
        ListNode mergedList = solution.mergeTwoLists(l1, l2);

        // 打印合并后的链表
        solution.printList(mergedList);
    }
}

这个代码定义了一个`ListNode`类来表示链表节点，并实现了一个`mergeTwoLists`方法来合并两个升序链表。`main`方法中创建了两个升序链表并调用`mergeTwoLists`方法进行合并，最后打印合并后的链表。

Java两个有序链表的合并pta

在Java中，合并两个已排序的链表通常是通过递归或者迭代的方式实现的，目的是创建一个新的链表，其中包含原始两个链表的所有元素，并保持原有的升序顺序。这里我将简述一种常见的递归法：

**递归方法：**
假设你有两个链表`list1`和`list2`，它们分别代表两个已排序的列表。首先检查两个链表是否都为空，如果其中一个为空，直接返回另一个；若两者都不空，则比较当前节点值，将较小的那个节点作为结果的新头节点，然后递归地对剩余部分做同样的操作。

public class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}

ListNode mergeTwoLists(ListNode l1, ListNode l2) {
    if (l1 == null) return l2;
    if (l2 == null) return l1;

    if (l1.val < l2.val) {
        l1.next = mergeTwoLists(l1.next, l2);
        return l1;
    } else {
        l2.next = mergeTwoLists(l1, l2.next);
        return l2;
    }
}