LinkedList, memory overflow for vector constructor? - c++

Question

This code add Two sum integer using linkedList.
I have added to the struct ListNode a new constructor in order to give him as input two vectore A and B.
ListNode(vector<int> array)
{
vector<int>::iterator itr = array.begin();
ListNode *t = nullptr;
for (; itr < array.end(); itr++) {
t->val = *itr;
t = t->next;
}
}
This is a strange overflow ??
#include <iostream>
#include <vector>
using namespace std;
/*
Definition for singly-linked list.
*/
struct ListNode {
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}
ListNode(int x) : val(x), next(nullptr) {}
ListNode(int x, ListNode *next) : val(x), next(next) {}
ListNode(vector<int> array)
{
vector<int>::iterator itr = array.begin();
ListNode *t = nullptr;
for (; itr < array.end(); itr++) {
t->val = *itr;
t = t->next;
}
}
};
class Solution {
public:
Solution(){};
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode *p = l1;
ListNode *q = l2;
ListNode *dummyHead = new ListNode(0);
ListNode *current = dummyHead;
int carry = 0;
while (p != NULL || q != NULL) {
int x = (p != NULL) ? p->val : 0;
int y = (q != NULL) ? q->val : 0;
int sum = carry + x + y;
carry = sum / 10;
current->next = new ListNode(sum % 10);
current = current -> next;
if (p != NULL) {
p = p -> next;
}
if (q != NULL) {
q = q -> next;
}
}
if (carry > 0) {
current -> next = new ListNode(carry);
}
return dummyHead->next;
}
};
int main(int argc, const char * argv[]) {
Solution *sol = nullptr;
vector<int> A = {2,4,3};
vector<int> B = {5,6,4};
ListNode *list1= new ListNode(A);
ListNode *list2= new ListNode(B);
sol->addTwoNumbers(list1,list2);
return 0;
}
Use case for test:
Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807.

Answer 1

Your ListNode constructor is not creating a new ListNode for t to point at before you access t->val. It is also not even attempting to initialize the members of this.
Try something more like this instead:
struct ListNode {
int val = 0;
ListNode *next = nullptr;
ListNode(int x = 0, ListNode *next = nullptr) : val(x), next(next) {}
ListNode(const vector<int> &array)
{
if (!array.empty()) {
auto itr = array.begin();
val = *itr++;
ListNode **t = &next;
while (itr != array.end()) {
*t = new ListNode(*itr++);
t = &((*t)->next);
}
}
}
};
That being said, having such a constructor in ListNode really makes no sense. A list node should only care about its own data, not about the data of the nodes around it. This kind of list construction really belongs in a separate List class that wraps a chain of ListNodes, eg:
#include <iostream>
#include <vector>
#include <utility>
/*
Definition for singly-linked list.
*/
struct ListNode {
int val = 0;
ListNode *next = nullptr;
ListNode(int x = 0, ListNode *next = nullptr) : val(x), next(next) {}
};
class List {
private:
ListNode *head = nullptr;
public:
List() = default;
List(const vector<int> &vec)
{
ListNode **t = &head;
for (int val : vec) {
*t = new ListNode(val);
t = &((*t)->next);
}
}
List addNumber(const List &l) const {
ListNode *p = head;
ListNode *q = l.head;
List dummyList;
ListNode** current = &(dummyList.head);
int carry = 0;
while (p || q) {
int x = (p) ? p->val : 0;
int y = (q) ? q->val : 0;
int sum = carry + x + y;
carry = sum / 10;
*current = new ListNode(sum % 10);
current = &((*current)->next);
if (p) {
p = p->next;
}
if (q) {
q = q->next;
}
}
if (carry > 0) {
*current = new ListNode(carry);
}
return dummyList;
}
// what follows is stuff needed for compliance with the "Rule of 3/5/0":
// https://en.cppreference.com/w/cpp/language/rule_of_three
List(const List &list)
{
ListNode **t = &head;
for(ListNode *n = list.head; n; n = n->next) {
*t = new ListNode(n->val);
t = &((*t)->next);
}
}
List(List &&list)
{
std::swap(head, list.head);
}
~List()
{
ListNode *n;
for (ListNode *t = head; t; t = n) {
n = t->next;
delete t;
}
}
List& operator=(List rhs) {
List temp(std::move(rhs));
std::swap(head, temp.head);
return *this;
}
};
class Solution {
public:
List addTwoNumbers(const List &l1, const List &l2) {
return l1.addNumber(l2);
}
};
int main(int argc, const char * argv[]) {
Solution sol;
vector<int> A = {2,4,3};
vector<int> B = {5,6,4};
List list1(A);
List list2(B);
List result = sol.addTwoNumbers(list1, list2);
return 0;
}

Answer 2

You are dereferencing a null pointer that's why you get the memory error. You have to initialize it and allocate memory. Here you initialize ListNode *t = nullptr;. So t is referencing as NULL pointer. Next, you here dereferencing t->val = *itr; but t is pointing to NULL.
Try something like this for singly-linked list.
struct ListNode {
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}
ListNode(int x) : val(x), next(nullptr) {}
};
Then your main task is to create a link list from a vector, for this you can use a class that holds the vector link list. And another requirement is to add to the vector link list. So we can create a vector link list in reverse order. And for this, you can use this code snippet.
class VectorList {
public:
ListNode *root;
VectorList() : root(nullptr){}
VectorList(vector<int> &array){
root = new ListNode();
ListNode *curr;
curr = root;
int _size = array.size();
for(int i = _size - 1; i >= 0; i--){
ListNode *t = new ListNode(array[i]);
curr->next = t;
curr = curr->next;
}
root = root->next;
}
};
So now we can create two vector lists and then add the vector lists and print the desired answer. And for this, you can use this code snippet.
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode* curr, *root = NULL;
int carry = 0;
while(l1 || l2){
if(l1 != NULL && l2 != NULL){
ListNode* t = new ListNode;
t->val = (l1->val + l2->val + carry) % 10;
t->next = NULL;
carry = (l1->val + l2->val + carry) / 10;
if(root == NULL){
curr = root = t;
}
else{
curr->next = t;
curr = curr->next;
}
l1 = l1->next;
l2 = l2->next;
}
else if(l1 == NULL){
ListNode* t = new ListNode;
t->val = (l2->val + carry) % 10;
t->next = NULL;
carry = (l2->val + carry) / 10;
if(root == NULL){
curr = root = t;
}
else{
curr->next = t;
curr = curr->next;
}
l2 = l2->next;
}
else if(l2 == NULL){
ListNode* t = new ListNode;
t->val = (l1->val + carry) % 10;
t->next = NULL;
carry = (l1->val + carry) / 10;
if(root == NULL){
curr = root = t;
}
else{
curr->next = t;
curr = curr->next;
}
l1 = l1->next;
}
}
if(carry){
ListNode* t = new ListNode;
t->val = carry;
t->next = NULL;
curr->next = t;
}
return root;
}
void print(ListNode *root){
ListNode *curr = root;
while(curr){
cout << curr->val << " ";
curr = curr->next;
}
cout << endl;
}
};
So overall, here is the main code with the desired output.
#include <iostream>
#include <vector>
using namespace std;
/*
Definition for singly-linked list.
*/
struct ListNode {
int val;
ListNode *next;
ListNode() : val(0), next(nullptr) {}
ListNode(int x) : val(x), next(nullptr) {}
};
class VectorList {
public:
ListNode *root;
VectorList() : root(nullptr){}
VectorList(vector<int> &array){
root = new ListNode();
ListNode *curr;
curr = root;
int _size = array.size();
for(int i = _size - 1; i >= 0; i--){
ListNode *t = new ListNode(array[i]);
curr->next = t;
curr = curr->next;
}
root = root->next;
}
};
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode* curr, *root = NULL;
int carry = 0;
while(l1 || l2){
if(l1 != NULL && l2 != NULL){
ListNode* t = new ListNode;
t->val = (l1->val + l2->val + carry) % 10;
t->next = NULL;
carry = (l1->val + l2->val + carry) / 10;
if(root == NULL){
curr = root = t;
}
else{
curr->next = t;
curr = curr->next;
}
l1 = l1->next;
l2 = l2->next;
}
else if(l1 == NULL){
ListNode* t = new ListNode;
t->val = (l2->val + carry) % 10;
t->next = NULL;
carry = (l2->val + carry) / 10;
if(root == NULL){
curr = root = t;
}
else{
curr->next = t;
curr = curr->next;
}
l2 = l2->next;
}
else if(l2 == NULL){
ListNode* t = new ListNode;
t->val = (l1->val + carry) % 10;
t->next = NULL;
carry = (l1->val + carry) / 10;
if(root == NULL){
curr = root = t;
}
else{
curr->next = t;
curr = curr->next;
}
l1 = l1->next;
}
}
if(carry){
ListNode* t = new ListNode;
t->val = carry;
t->next = NULL;
curr->next = t;
}
return root;
}
void print(ListNode *root){
ListNode *curr = root;
while(curr){
cout << curr->val << " ";
curr = curr->next;
}
cout << endl;
}
};
int main(int argc, const char * argv[]) {
Solution *sol = nullptr;
vector<int> A = {2,4,3};
vector<int> B = {5,6,4};
VectorList list1 = VectorList(A);
VectorList list2 = VectorList(B);
ListNode *root = sol->addTwoNumbers(list1.root, list2.root);
sol->print(root);
return 0;
}
Sample Input:
l1 = [2,4,3], l2 = [5,6,4]
Sample Output:
[7 0 8]