版权声明：所有文章版权归属博主个人 https://blog.csdn.net/weixin_41143631/article/details/88373893
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。
如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。
您可以假设除了数字 0 之外，这两个数都不会以 0 开头。
示例：
输入：(2 -> 4 -> 3) + (5 -> 6 -> 4) 输出：7 -> 0 -> 8 原因：342 + 465 = 807
以上引用自LeetCode ，这个题目感觉有点意思，我自己顺便把list的插入写了一遍，然后做了一下。先贴solution类。
算法注释里有解释，mylist是我自己写的不带头结点的单链表，放下面，就只有构造，析构，pushback（尾插）popback（尾删）和一个打印函数。大家自己做链表小代码的demo可以用一下。我的命名为了方便而已，大家写代码还是规范点，普通的还是驼峰命名，
class Solutionlist {
public:
PNode listAdd( mylist& const list1, mylist& const list2)
{
PNode l1 = list1.getPhead();//是list one的缩写，不要看错
PNode l2 = list2.getPhead();
listNode* dummy = new listNode(-1);//利用哑结点，避免list传入空的情况
listNode* cur = dummy;
int carry=0;//进位
int sum = 0;// 对应位数
while (l1 || l2)//l1或者l2不为空就一直循环，（不为空表示还有数字）
{
int data1 = (l1 ? l1->data : 0);
int data2 = (l2 ? l2->data : 0);
sum = data1 + data2 + carry;
carry = sum / 10;
cur->next = new listNode(sum % 10);//sum取值在0-18之间（0+0---9+9）
cur = cur->next;
if (l1 != nullptr)
{
l1 = l1->next;
}
if(l2!=nullptr)
{
l2 = l2->next;
}
}
if (carry)
{
cur->next = new listNode(1);
}
return dummy->next;
}
};listNode是个结构体，构造list结点，mylist是单链表，功能有forward_list的基本功能，当然省时间就没有泛型（模板）和迭代器之类的。
class listNode{
public :
listNode(int data):data(data),next(nullptr){}
listNode(const listNode& l) = delete;
listNode& operator=(const listNode& l) = delete;
int data;
listNode* next;
};
typedef listNode* PNode;
class mylist {
public:
mylist():phead(nullptr)
{
//cout << "开始构造" << endl;
}
mylist(mylist & l) = delete;
mylist& operator = (const mylist& l) = delete;
void push_back(int data)
{
listNode* newnode = new listNode(data);
if (phead == nullptr)
{
phead = newnode;
return;
}
PNode pcur = phead;
while (pcur->next != nullptr)
pcur = pcur->next;
pcur->next = newnode;
}
void pop_back()
{
if (nullptr == phead)
return;
if (nullptr == phead->next)
{
delete(phead->next);//
return;
}
auto pcur = phead;
while (pcur->next->next != nullptr)
pcur = pcur->next;
delete(pcur->next);
pcur->next = nullptr;
}
void push_front(int data)
{
PNode newnode = new listNode(data);
if (phead == nullptr)
{
phead = newnode;
return;
}
else
{
newnode->next = phead;
phead = newnode;
}
}
void pop_front()
{
if (phead == nullptr)
return;
if (phead->next == nullptr)
{
delete phead;
phead = nullptr;
return;
}
PNode pcur = phead->next;
PNode pdel = phead;
delete(pdel);
pdel = nullptr;
phead = pcur;
}
void print()
{
PNode pcur = phead;
while (pcur != nullptr)
{
printf("%d--->",pcur->data);
pcur = pcur->next;
}
cout << "nullptr";
}
~mylist()
{//析构
_destroy();
}
PNode getPhead()
{
return this->phead;
}
void setPhead(PNode& p)
{
phead = p;
}
private:
void _destroy()
{
while ((phead)!=nullptr)
{
PNode pcur = phead;
phead = pcur->next;
delete(pcur);
}
}
private:
PNode phead;
};
然后我们的test函数做单元测试。
void print(PNode& phead)
{
PNode pcur = phead;
while (pcur != nullptr)
{
printf("%d--->", pcur->data);
pcur = pcur->next;
}
cout << "nullptr";
}
/*省时间，我把打印链表设置为全局的，当然不用全局就得用get和set来配
置打印，比较麻烦，我的test下面的注释代码就是那种方式打印链表的
*/
void testListAdd()
{
mylist listOne,listTwo;
listOne.push_back(1);
listOne.push_back(2);
listOne.push_back(2);
listOne.push_back(3);
listTwo.push_back(2);
listTwo.push_back(1);
listTwo.push_back(3);
listTwo.push_back(8);
Solutionlist solution;
auto result=solution.listAdd(listOne,listTwo);
print(result);
//mylist printflist;
//printflist.setPhead(result);
//printflist.print();
}
int main()
{
testListAdd();
return 0;
}
结果就这样了, 1-2-2-3 + 2-1-3-8 = 3-3-5-1-1(3221+8312=11533)
感觉这个可以做大数加减运算，貌似可以解决int只能存储2^31的问题。