java 两个链表相减

原创

mob64ca12f3bbc7 2024-10-16 06:36:00 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12f3bbc7的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 两个链表相减的实现指南

在这篇文章中，我们将逐步学习如何在Java中实现两个链表的相减操作。这个过程可以分为几个关键步骤，我们将使用表格和代码示例来帮助你理解。

整体流程

下面是实现两个链表相减的流程图：

flowchart TD
    A[开始] --> B[定义链表结构]
    B --> C[创建链表节点]
    C --> D[遍历链表进行相减]
    D --> E[输出结果]
    E --> F[结束]

流程步骤

步骤	描述
A	开始程序
B	定义链表的节点结构
C	创建两个链表并初始化
D	遍历两个链表，进行节点相减
E	输出相减后的链表
F	结束程序

每一步的详细实现

步骤 A: 开始程序

在这一部分，我们通过创建一个Java类来开始程序。

public class LinkedListSubtraction {
    public static void main(String[] args) {
        // 程序入口点
    }
}

步骤 B: 定义链表结构

我们需要定义链表节点的结构。一般来说，链表节点应该有两个属性：值和指向下一个节点的引用。

class ListNode {
    int value;          // 节点的值
    ListNode next;     // 下一个节点的引用

    ListNode(int value) {
        this.value = value; // 初始化节点值
        this.next = null;   // 初始化下一个节点为null
    }
}

步骤 C: 创建链表节点

接下来，我们需要创建两个链表并初始化它们。这里我们可以手动添加节点来创建链表。

ListNode createList1() {
    ListNode head = new ListNode(7); // 创建头节点
    head.next = new ListNode(3);      // 添加下一个节点
    head.next.next = new ListNode(2);  // 再添加一个节点
    return head;                        // 返回链表头指针
}

ListNode createList2() {
    ListNode head = new ListNode(5);   // 创建头节点
    head.next = new ListNode(1);       // 添加下一个节点
    head.next.next = new ListNode(4);  // 再添加一个节点
    return head;                        // 返回链表头指针
}

步骤 D: 遍历链表进行相减

在这一部分，我们需要实现一个方法来遍历两个链表并进行数值相减。我们需要处理每个节点，如果链表的长度不同，我们需要保证能够正确处理。

ListNode subtractLists(ListNode list1, ListNode list2) {
    // 创建一个哨兵节点以便于返回结果
    ListNode dummyHead = new ListNode(0);
    ListNode current = dummyHead; // 指向当前结果链表的节点

    while (list1 != null || list2 != null) {
        int val1 = (list1 != null) ? list1.value : 0; // 获取第一个链表的值
        int val2 = (list2 != null) ? list2.value : 0; // 获取第二个链表的值

        // 进行相减操作
        int sub = val1 - val2; 

        // 创建新的节点并连接到结果链表
        current.next = new ListNode(sub);
        current = current.next; // 移动到下一个节点

        // 移动到下一个节点
        if (list1 != null) list1 = list1.next; 
        if (list2 != null) list2 = list2.next; 
    }

    return dummyHead.next; // 返回去掉哨兵节点后的结果链表
}

步骤 E: 输出结果

最后，我们需要将相减的结果输出。我们可以通过遍历链表来打印每个节点的值。

void printList(ListNode head) {
    while (head != null) {
        System.out.print(head.value + " -> "); // 打印当前节点的值
        head = head.next; // 移动到下一个节点
    }
    System.out.println("null"); // 打印链表结束标志
}

整合代码

下面是整合了所有步骤的完整代码：

public class LinkedListSubtraction {
    static class ListNode {
        int value;
        ListNode next;

        ListNode(int value) {
            this.value = value;
            this.next = null;
        }
    }

    public static void main(String[] args) {
        ListNode list1 = createList1();
        ListNode list2 = createList2();
        
        ListNode result = subtractLists(list1, list2);

        printList(result); // 输出减法结果
    }
    
    static ListNode createList1() {
        ListNode head = new ListNode(7);
        head.next = new ListNode(3);
        head.next.next = new ListNode(2);
        return head;
    }

    static ListNode createList2() {
        ListNode head = new ListNode(5);
        head.next = new ListNode(1);
        head.next.next = new ListNode(4);
        return head;
    }

    static ListNode subtractLists(ListNode list1, ListNode list2) {
        ListNode dummyHead = new ListNode(0);
        ListNode current = dummyHead;

        while (list1 != null || list2 != null) {
            int val1 = (list1 != null) ? list1.value : 0;
            int val2 = (list2 != null) ? list2.value : 0;

            int sub = val1 - val2;

            current.next = new ListNode(sub);
            current = current.next;

            if (list1 != null) list1 = list1.next; 
            if (list2 != null) list2 = list2.next;
        }

        return dummyHead.next;
    }

    static void printList(ListNode head) {
        while (head != null) {
            System.out.print(head.value + " -> ");
            head = head.next;
        }
        System.out.println("null");
    }
}