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=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);
    }
}

输出结果：