两数相加

两数相加

问题描述：

给你两个非空链表，表示两个非负整数。他们的每位数字都是按照逆序方式储存，且每个节点只能储存一位数。

请你将两个数相加，并以相同形式返回一个表示和的链表。


输入：L1 = [2,4,3]，L2 = [5.6.4]

输出：[7,0,8]

解释：342 + 465 = 807

代码实现（C++）

#include<iostream>
#include<list>
#include<iterator>
using namespace std;


class solution
{
public:
	void input();//输入数字，存入链表
	void polishing();//补齐链表
	void count();//求和
	void output();//输出结果

private:
	int size1;//链表L1的节点
	int size2;//链表L2的节点
	list<int> L1;//L1存放的数据类型是int型
	list<int> L2;
	list<int> result;//结果链表存放的数据类型是int
};

//输入
void solution::input()
{
	int input1;
	int input2;

	cin>>size1;
	for(int i = 0;i < size1;i++)
	{
		cin>>input1;
		L1.push_back(input1);//push_back:将input1加到L1当前最后一个元素的下一个元素
	}

	cin>>size2;
	for(int i = 0;i < size2;i++)
	{
		cin>>input2;
		L2.push_back(input2);
	}
}

//补齐链表
void solution::polishing()
{
	int temp;

	//L1比L2长，在L2后面补0
	if(L1.size() > L2.size())
	{
		temp = L1.size() - L2.size();

		for(int i = 0;i < temp;i++)
		{
			L2.push_back(0);
		}
	}
	

	//L2比L1长，在L1后面补0
	if(L1.size() < L2.size())
	{
		temp = L2.size() - L1.size();
		for(int i = 0;i < temp;i++)
		{
			L1.push_back(0);
		}
	}
}

//求和
void solution::count()
{
	int temp2;
	int add=0;//进位

	////iterator:检查容器内元素并遍历元素的数据类型
	list<int>::iterator  iter1 = L1.begin();//.begin();返回指向容器 最开始位置数据的指针
	list<int>::iterator  iter2 = L2.begin();

	for(; iter1 != L1.end(); iter1++)//.end();返回指向容器最后一个数据单元+1的指针
	{
		//进位
		if( (*iter1) + (*iter2) + add >= 10)
		{
			temp2 = (*iter1) + (*iter2) + add;
			result.push_back(temp2);
			add = 1;		
		}

		//没有进位
		if( (*iter1) + (*iter2) + add < 10)
		{
			temp2 = (*iter1) + (*iter2) + add;
			result.push_back(temp2);
			add = 0;
		}
		iter2++;
	}
}

//输出结果
void solution::output()
{
	for(list<int>::iterator  iter = result.begin(); iter != result.end(); iter++)
	{
		cout<<*iter;
	}

}

int main()
{
	solution s;
	s.input();//输入数字，存入链表
	s.polishing();//补齐链表
	s.count();//求和
	s.output();//输出结果

	return 0;
}

Java （1）

  //链表初始化
    public node addTwoNumbers(node l1, node l2) {
        node node1 = l1;
        node node2 = l2;

        //node1、node2不为空时进入循坏
        while (node1 != null)
        {
            if (node2 != null){
                node1.data += node2.data;//node1.data=node1.data+node2.data
                node2 = node2.next;//node2移到下一结点
            }

            //如果node1的下一结点为空且node2的下一结点不为空
            if (node1.next == null && node2!=null){
                node1.next = node2;//node1的下一结点等于node2
            }
            node1 = node1.next;//node1移到下一结点
        }
        return node1;//返回node1
    }

    public void marge(node node)
    {
        //node不为空时
        while (node != null){
            //node的数据大于10
            if (node.data >= 10){
                //进位
                node.data = node.data%10;
                if (node.next == null)//如果node的下一结点为空
                {
                    //node的下一结点等于0
                    node.next = new node(0);
                }
                node.next.data +=1;//node的下一结点等于0+1
            }
        }
    }

    public node addTwoNumbers2(node l1, node l2) {
        //声明
        node pre = new node(0);
        node cur = pre;
        int carry = 0;

        //L1、L2不为空时进入循坏
        while(l1 != null || l2 != null) {
            int x = l1 == null ? 0 : l1.data;//L1为空则返回0赋给x，否则返回L1的数据
            int y = l2 == null ? 0 : l2.data;//L2为空则返回0赋给y，否则返回L2的数据
            int sum = x + y + carry;

            carry = sum / 10;//进位数等于0或1
            sum = sum % 10;
            cur.next = new node(sum);//cur的下一结点等于sum

            cur = cur.next;
            if(l1 != null) //如果L1为空
                l1 = l1.next;//指向下一结点
            if(l2 != null)//如果L2为空
                l2 = l2.next;//指向下一结点
        }
        //进位了
        if(carry == 1) {
            cur.next = new node(carry);
        }
        return pre.next;
    }

Java（2）

  //static是一个修饰符，用于修饰类的成员方法、类的成员变量,它修饰的方法称为静态方法
    static node head = null;//节点指针域
    static node tem = null;//节点指针域

    class node {
        int data;           //节点数据域
        node next = null;  //节点指针域

        public node(int data) {
            this.data = data;   //当构造一个新的节点的时候，顺便给节点进行初始化
        }
    }

    public void addNode(int d){
        node N = new node(d);
        //如果头结点为空
        if(head==null){
            head = N;//把N赋给头结点
            return;  /*由于每次是增加一个节点，所以对头结点进行初始化之后就要退出函数*/
        }
        tem = head;  /*一般一个链表的头结点是不能动的，因此需要把头结点赋值给一个临时变量
		这样在对链表进行访问的时候，就可以用这个临时变量进行逐个的访问，不对头结点产生影响*/
        //如果tem的下一结点不为空
        while(tem.next!=null){
            tem = tem.next;//移到下一结点
        }
        tem.next = N;//N赋给tem的下一结点
    }