Concatenation of two Linked Lists in O(1) time

In this tutorial, we will explore about the concatenation of two Linked lists in O(1) time.

What exactly is a Linked List?

A linked list is a form of linear data structure wherein members will not be kept in sequential memory locations. A linked list's elements are linked via pointers, as demonstrated in the graphic below:

Concatenation of two Linked Lists in O(1) time

Singly Linked List:

It is the most popular type of linked list.
In a singly linked list, each node holds some data and a pointer pointing to the next node.
We must move in one way, from head to tail.

Doubly Linked List:

It is a type of linked list which can move in both ways, head to tail and tail to head.
A Doubly Linked List (DLL) has an additional pointer, sometimes referred to as the previous pointer, as well as the next pointer and data.

Circularly Linked List:

Circularly Linked List is a kind of linked list in where all nodes are linked to create a circular form.
The initial and last nodes in a circular linked list are connected to each other, forming a circle.
So, at the end, there is no NULL.

1. For Singly and Doubly Linked List:

Concatenation of two lists in O(1) time with a doubly linked list or a singly linked list , given that at least each of the lists has a pointer to the last node. (There also exists some links which connects to the list head.)

Let's examine how it works in the example of Singly LL, but it also works in doubly.

C++ Program:

#include <iostream>
using namespace std;

class Node{

public:
	int data;
	Node* next;

	Node(int data)
	{
		this -> data = data;
		this -> next = NULL;
	}
	~Node()
	{
		int value = this -> data;

		if (this -> next != NULL){
			delete next;
			this -> next = NULL;
		}
	}
};

void insertAtTail(Node*& tail, int d)
{
	Node* temp = new Node(d);
	tail -> next = temp;
	tail = temp;
}

void print(Node*& head)
{
	Node* temp = head;

	while (temp != NULL){
		cout << temp -> data << " ";
		temp = temp -> next;
	}
	cout << endl;
}
void concat(Node*& head1, Node*& head2, Node*& tail)
{

	tail -> next = head2;
}
int main()
{
	Node* node1 = new Node(1);

	Node* head1 = node1;
	Node* tail1 = node1;

	insertAtTail(tail1, 2);
	insertAtTail(tail1, 3);
	insertAtTail(tail1, 4);
	insertAtTail(tail1, 5);

	cout << "First Linked List: " << endl;

	print(head1);

	Node* node2 = new Node(6);

	Node* head2 = node2;
	Node* tail2 = node2;

	insertAtTail(tail2, 7);
	insertAtTail(tail2, 8);
	insertAtTail(tail2, 9);
	insertAtTail(tail2, 10);

	cout << "Second Linked List: " << endl;

	print(head2);
	concat(head1, head2, tail1);

	cout << "First Linked List after concatenation: "
		<< endl;
	print(head1);

	return 0;
}

Output:

First Linked List: 
1 2 3 4 5 
Second Linked List: 
6 7 8 9 10 
First Linked List after concatenation: 
1 2 3 4 5 6 7 8 9 10

Java Program:

import java.io.*;

class Node{
	int data;
	Node next;
	public Node(int data)
	{
		this.data = data;
		this.next = null;
	}
}

class JTP{

	public static Node insertAtTail(Node head1, Node tail1,
									int data)
	{
		Node temp = new Node(data);
		tail1.next = temp;
		tail1 = temp;
		return tail1;
	}

	public static void print(Node head)
	{
		Node temp = head;
		while (temp != null){
			System.out.print(temp.data + " ");
			temp = temp.next;
		}
		System.out.println();
	}

	public static void concat(Node head1, Node head2,
							Node tail1)
	{
		tail1.next = head2;
	}

	public static void main(String[] args)
	{
		Node node1 = new Node(1);
		Node head1 = node1;
		Node tail1 = node1;

		tail1 = insertAtTail(head1, tail1, 2);
		tail1 = insertAtTail(head1, tail1, 3);
		tail1 = insertAtTail(head1, tail1, 4);
		tail1 = insertAtTail(head1, tail1, 5);

		System.out.println("First Linked List: ");
		print(head1);

		Node node2 = new Node(6);
		Node head2 = node2;
		Node tail2 = node2;

		tail2 = insertAtTail(head2, tail2, 7);
		tail2 = insertAtTail(head2, tail2, 8);
		tail2 = insertAtTail(head2, tail2, 9);
		tail2 = insertAtTail(head2, tail2, 10);

		System.out.println("Second Linked List: ");
		print(head2);

		concat(head1, head2, tail1);

		System.out.println(
			"First Linked List after concatenation: ");
		print(head1);
	}
}

Output:

First Linked List: 
1 2 3 4 5 
Second Linked List: 
6 7 8 9 10 
First Linked List after concatenation: 
1 2 3 4 5 6 7 8 9 10

Time Complexity will be O(1).

Auxiliary Space will be O(1).

2. For Circular Linked List:

We may simply concatenate these in O(1) time using a circularly linked list. It's simply a question of breaking a link in both lists and then connecting them. This, of course, presupposes that the order of the things is unimportant.

Implementation:

C++ Program:

#include <bits/stdc++.h>
using namespace std;

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

	Node(int data)
	{
		this->data = data;
		this->next = NULL;
	}
};

void insertNode(Node*& head, Node*& tail, int d)
{

	if (head == NULL){
		Node* newNode = new Node(d);
		head = newNode;
		tail = newNode;
		newNode->next = newNode;
	}
	else{

		Node* temp = new Node(d);
		temp->next = tail->next;
		tail->next = temp;
		tail = tail->next;
	}
}
void print(Node* head)
{
	Node* curr = head;
	if (head == NULL){
		cout << "List is Empty " << endl;
		return;
	}
	do{
		cout << curr->data << " ";
		curr = curr->next;
	} while (curr != head);
	cout << endl;
}

void concat(Node*& head1, Node*& head2)
{

	Node* temp = head1->next;
	head1->next = head2->next;
	head2->next = temp;
}

int main()
{

	Node* head1 = NULL;
	Node* tail1 = NULL;

	insertNode(head1, tail1, 1);
	insertNode(head1, tail1, 2);
	insertNode(head1, tail1, 3);
	insertNode(head1, tail1, 4);
	insertNode(head1, tail1, 5);

	Node* head2 = NULL;
	Node* tail2 = NULL;

	insertNode(head2, tail2, 6);
	insertNode(head2, tail2, 7);
	insertNode(head2, tail2, 8);
	insertNode(head2, tail2, 9);
	insertNode(head2, tail2, 10);

	cout << "Before Concatenation, First circular linked "
			"list: ";
	print(head1);

	cout << "Before Concatenation, Second circular linked "
			"list: ";
	print(head2);

	concat(head1, head2);

	cout << "After Concatenation, First circular linked "
			"list: ";
	print(head1);

	cout << "After Concatenation, Second circular linked "
			"list: ";
	print(head2);

	return 0;
}

Output:

Before Concatenation, First circular linked list: 1 2 3 4 5 
Before Concatenation, Second circular linked list: 6 7 8 9 10 
After Concatenation, First circular linked list: 1 7 8 9 10 6 2 3 4 5 
After Concatenation, Second circular linked list: 6 2 3 4 5 1 7 8 9 10

Python Program:

class Node:
	def __init__(self, data):
		self.data = data
		self.next = None

def insertNode(head, tail, d):
	if head is None:
		newNode = Node(d)
		head = newNode
		tail = newNode
		newNode.next = newNode
	else:
		temp = Node(d)
		temp.next = tail.next
		tail.next = temp
		tail = tail.next
	return head, tail

def printList(head):
	curr = head
	if head is None:
		print("List is Empty")
		return
	while curr.next != head:
		print(curr.data, end=' ')
		curr = curr.next
	print(curr.data)
def concat(head1, head2):
	temp = head1.next
	head1.next = head2.next
	head2.next = temp


if __name__ == '__main__':
	head1 = None
	tail1 = None

	head1, tail1 = insertNode(head1, tail1, 1)
	head1, tail1 = insertNode(head1, tail1, 2)
	head1, tail1 = insertNode(head1, tail1, 3)
	head1, tail1 = insertNode(head1, tail1, 4)
	head1, tail1 = insertNode(head1, tail1, 5)

	head2 = None
	tail2 = None

	head2, tail2 = insertNode(head2, tail2, 6)
	head2, tail2 = insertNode(head2, tail2, 7)
	head2, tail2 = insertNode(head2, tail2, 8)
	head2, tail2 = insertNode(head2, tail2, 9)
	head2, tail2 = insertNode(head2, tail2, 10)

	print("Before Concatenation, First circular linked list: ")
	printList(head1)

	print("Before Concatenation, Second circular linked list: ")
	printList(head2)

	concat(head1, head2)

	print("After Concatenation, First circular linked list: ")
	printList(head1)

	print("After Concatenation, Second circular linked list: ")
	printList(head2)

Output:

Before Concatenation, First circular linked list: 1 2 3 4 5 
Before Concatenation, Second circular linked list: 6 7 8 9 10 
After Concatenation, First circular linked list: 1 7 8 9 10 6 2 3 4 5 
After Concatenation, Second circular linked list: 6 2 3 4 5 1 7 8 9 10

Time Complexity will be O(1).

Auxiliary Space will be O(1).

Next TopicFind Minimum Area of Rectangle Formed from Given Shuffled Coordinates

← prev next →