JAVA版本： 實現簡單鏈表，並給定兩個非空鏈表用來表示兩個非負的整數。其中，它們各自的位數是按照 逆序 的方式存儲的，每個節點只能存儲 一位 數字。實現方法將這兩個數相加起來，並返回一個新的鏈

題目：實現簡單鏈表，並給定兩個非空鏈表用來表示兩個非負的整數。其中，它們各自的位數是按照 逆序 的方式存儲的，每個節點只能存儲 一位 數字。實現方法將這兩個數相加起來，並返回一個新的鏈表來表示它們的和。

import jdk.nashorn.internal.ir.IndexNode;

import java.util.LinkedList;
import java.util.List;

public class LeetCode_1 {
    public static void main(String[] args) {
        ListHo ho=new ListHo();
        ListHo ho1=new ListHo();
        //添加數據
        ho.add(2);
        ho.add(3);
        ho.add(8);
        ho1.add(9);
        ho1.add(4);
        ho1.add(6);
        //獲得相加後的結果
        ListHo ho3=sunHo(ho,ho1);
        System.out.print("823+649=");
        for (int i=ho3.size-1;i>=0;i--){
            System.out.print(ho3.subList(i));
        }
    }
    //進行和的運算
    public static ListHo sunHo(ListHo h1,ListHo h2){
        //進行計數
        int cunt=h1.size>=h2.size?h1.size:h2.size;
        ListHo sunlistho=new ListHo();
        //int [] sa =new int[h1.size+h2.size];
        for(int i=0;i<cunt;i++){
            int number1=i>=h1.size?0:h1.subList(i);
            int number2=i>=h2.size?0:h2.subList(i);
            int number=0;
            int sun =number1+number2;
            if(i==0){
                number =sun;
                sunlistho.add((number%10));
            }else {
                number=sunlistho.subList(i)+sun;
                sunlistho.setDataat(i,number%10);
            }
            sunlistho.add((number/10));
        }
        return sunlistho;
    }
}




//模擬實現鏈表的類
class ListHo{
    //定義一個節點類
    class NodeHo{
        //存儲數據
        byte date;
        //存儲下一個地址
        NodeHo nextnode;
        //無參構造
        NodeHo(){}
        //輸出元素
        public byte getDate(int i,int index) {
            if (i++ == index) {
                return this.date;
            }
            return this.nextnode.getDate(i,index);
        }
        //刪除元素
        public boolean del(NodeHo ho,int dat){
            if (dat == this.date) {
                ho.nextnode=this.nextnode;
                return true;
            }
            if(this.nextnode!=null) {
                this.nextnode.del(this,dat);
            }
            return false;
        }
        //修改元素
        public void setNode(int i,int index,int dat) {
            if (i++ == index) {
                this.date=(byte) dat;
                return;
            }
            this.nextnode.setNode(i,index, dat);
        }
    }
    int size;
    private NodeHo dataat;
    private NodeHo fistdata;
    boolean havefist=false;

    //使用無參構造
    public ListHo(){
        this.size=0;
    }
    //增加元素
    public void add(int i){
        if (!havefist) {
            dataat=new NodeHo();
            this.fistdata=this.dataat;
            havefist=true;
        }
        this.dataat.date = (byte) i;
        size++;
        dataat.nextnode=new NodeHo();
        this.dataat=this.dataat.nextnode;
    }
    //下標越界錯誤
    private void isOut(int i){
        if (i<0 || i>=size){
             throw new IllegalArgumentException("Index"+i);
        }
    }
    //根據元素的值刪除元素
    public void remove(int dat){
        if (dat==fistdata.date){
            this.fistdata=this.fistdata.nextnode;
            size--;
        }else {
            boolean a=fistdata.del(fistdata,dat);
            if (a) size--;
        }
    }
    //修改元素
    public void setDataat(int index,int dat) {
        isOut(index);
        fistdata.setNode(0,index,dat);
    }
    //返回元素個數
    public int size(){
        return size;
    }
    //按下標輸出元素
    public byte subList(int index){
        isOut(index);
        return fistdata.getDate(0,index);
    }
}

輸出結果：