两链表相加问题

Posted 2021-08-13 Dream_it_possible！

一、题目

两链表相加问题, 满10进1

例如: (4->2->1) +(6->3->7),

得到结果为: 0->6->8

得到结果860

假设链表的长度是相等的, 不考虑表尾溢出的情况。

二、思路一

        将链表二中的数据加到链表一上，然后返回链表一，如果链表一的除了末位的满10那么进1。

我们可以给每一个链表中的所有节点放入到一个 Node [] table里， 然后通过fo循环遍历两个table。

        此方式利用牺牲空间的方式初始化2个数组，只用一个for循环就能实现两个链表相加。

    private static SumOfTwoLinkedList addLinkedList(SumOfTwoLinkedList one, SumOfTwoLinkedList two) {
        for (int i = 0; i < one.table.length; i++) {
            if (one.table[i] != null) {
                // 两条链表中对应位置值相加
                Integer sum = (Integer) one.table[i].data + (Integer) two.table[i].data;
                boolean overflow = false;
                if (sum >= 10 && i + 1 <= one.table.length) {
                    // 是否进位
                    overflow = true;
                    // 最后一位不支持进位
                    if (i + 1 == one.table.length) {
                        throw new RuntimeException("illegal params! check lists");
                    }
                    //下一位+1
                    one.table[i + 1].data = (Integer) one.table[i + 1].data + 1;
                }
                if (overflow) {
                    // 当前位归0
                    one.table[i].data = 0;
                    continue;
                }
                one.table[i].data = sum;
            }
        }
        return one;
    }

完整代码

package leetcode100;


/**
 * @decription:
 * @author: zhengbing.zhang
 * @date: 2021/7/12 17:40
 * 两链表相加问题, 满10进1
 * 例如:  (4->2->1) +(6->3->7),
 * 得到结果为: 0->6->8
 * 得到结果860
 * 假设链表的长度是相等的, 不考虑表尾溢出的情况
 */
public class SumOfTwoLinkedList {


    private static SumOfTwoLinkedList addLinkedList(SumOfTwoLinkedList one, SumOfTwoLinkedList two) {
        for (int i = 0; i < one.table.length; i++) {
            if (one.table[i] != null) {
                // 两条链表中对应位置值相加
                Integer sum = (Integer) one.table[i].data + (Integer) two.table[i].data;
                boolean overflow = false;
                if (sum >= 10 && i + 1 <= one.table.length) {
                    // 是否进位
                    overflow = true;
                    // 最后一位不支持进位
                    if (i + 1 == one.table.length) {
                        throw new RuntimeException("illegal params! check lists");
                    }
                    //下一位+1
                    one.table[i + 1].data = (Integer) one.table[i + 1].data + 1;
                }
                if (overflow) {
                    // 当前位归0
                    one.table[i].data = 0;
                    continue;
                }
                one.table[i].data = sum;
            }
        }
        return one;
    }

    public static void main(String[] args) {

        SumOfTwoLinkedList l1 = new SumOfTwoLinkedList();
        SumOfTwoLinkedList l2 = new SumOfTwoLinkedList();
        Node oneHead = new Node(3);
        oneHead.addNode(new Node(7)).addNode(new Node(1));
        Node twoHead = new Node(6);
        twoHead.addNode(new Node(3)).addNode(new Node(6));
//        Node one = new Node(3, new Node(7, new Node(1, null)));
//        Node two = new Node(6, new Node(3, new Node(8, null)));
        l1.initLinkList(oneHead);
        l2.initLinkList(twoHead);
        SumOfTwoLinkedList result = addLinkedList(l1, l2);
        System.out.println(result.traverseLinkList());
    }

    Node[] table;


    /**
     * 初始化链表
     *
     * @param head
     */
    public void initLinkList(SumOfTwoLinkedList.Node head) {
        int index = 0;
        this.table = new Node[head.length()];
        while (head.next != null) {
            this.table[index] = head;
            head = head.next;
            index++;
        }
        this.table[index] = head;
    }

    public String traverseLinkList() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < table.length; i++) {
            Object obj = this.table[i];
            if (obj != null) {
                sb.append(((Node) obj).getData());
                sb.append("->");
            }
        }
        sb.append("NULL");
        return sb.toString();
    }


    static class Node {

        private Object data;

        private Node next;


        public Node(Object data) {
            this.data = data;
        }


        public Node addNode(Node node) {
            this.next = node;
            return node;
        }


        public Object getData() {
            return this.data;
        }

        /**
         * 返回链表长度
         */
        public Integer length() {
            Node current = this;
            int count = 1;
            while (current.next != null) {
                count++;
                current = current.next;
            }
            return count;
        }


        public String traverse() {
            return this.data + "->" + (this.next == null ? "Null" : this.next.traverse());
        }


    }

}

输入:

3——>7——>1——>NULL

6——>3——>6——>NULL

执行结果: