Question

Hello,

Give a Θ(n)-time nonrecursive procedure that reverses a singly linked list of n elements. The procedure should use no more than constant storage beyond that needed for the list itself.

Answer 1

The idea to reverse the linked list is the following. Keep an empty linked list as the reverse linked list. Iterate over the original list, and for each node, add it to the front of the reverse linked list. This way the order of the elements in the original linked list gets reversed, hence the linked list gets reversed.

Note that each element in the linked list is accessed once, hence the time complexity will be . The only additional storage used is to iterate over the original linked list, which will take the space of one node. Hence, it is a constant amount.

Here is the code with additional code for testing.

# include <iostream>

class Node{
public:
int data;
Node* next;

Node() {
next = NULL;
}

Node(int a, Node* n) {
data = a;
next = n;
}
  
~Node() {
delete(next);
}

void print() {
std::cout << data;

if (next == NULL) {
std::cout << std::endl;
} else {
std::cout << " ";
next->print();
}
}
};

Node* reverse(Node* list) {
Node* rev = NULL;
Node* cur = list;

while (cur != NULL) {
//create a new node
Node* head = new Node(cur->data, rev);

//add it to front of reverse list
rev = head;

//move forward on the original list
cur = cur->next;
}

return rev;
}

int main() {
Node* list = NULL;

for (int i=9; i>=0; i--) {
Node* head = new Node(i, list);
list = head;
}

std::cout << "the original list is ";
list->print();

Node* rev = reverse(list);
std::cout << "the reversed list is ";
rev->print();

delete(rev);
delete(list);

return 0;
}

Here is a sample output:

the original list is 0 1 2 3 4 5 6 7 8 9
the reversed list is 9 8 7 6 5 4 3 2 1 0