Open In App

Create linked list from a given array

Last Updated : 01 Aug, 2024
Summarize
Comments
Improve
Suggest changes
Share
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given an array arr[] of size N. The task is to create linked list from the given array.
Examples: 
 

Input : arr[] = {1,  2,  3,  4,  5}
Output : 1->2->3->4->5

Input :arr[] = {10,  11,  12,  13,  14}
Output : 10->11->12->13->14


Simple Approach: For each element of an array arr[] we create a node in a linked list and insert it at the end. 
 

C++ 
#include <iostream>
using namespace std;

struct Node {
    int data;
    Node* next;
    Node(int d)
    {
        data = d;
        next = NULL;
    }
};

// Function to insert node at the end
Node* insertEnd(Node* root, int item)
{
    Node* temp = new Node(item);
    if (root == NULL)
        return temp;
  
    Node* last = root;
    while (last->next != NULL) {
        last = last->next;
    }
  
    last->next = temp;
    return root;
}

Node* arrayToList(int arr[], int n)
{
    Node* root = NULL;
    for (int i = 0; i < n; i++) {
        root = insertEnd(root, arr[i]);
    }
    return root;
}

void display(Node* root)
{
    while (root != NULL) {
        cout << root->data << " ";
        root = root->next;
    }
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int n = sizeof(arr) / sizeof(arr[0]);
    Node* root = arrayToList(arr, n);
    display(root);
    return 0;
}
C 
#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node* next;
};

struct Node* createNode(int data) {
    struct Node* newNode = 
      (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// Function to insert node at the end
struct Node* insertEnd(struct Node* root, int item) {
  
    struct Node* temp = createNode(item);
    if (root == NULL)
        return temp;

    struct Node* last = root;
    while (last->next != NULL) 
        last = last->next;

    last->next = temp;
    return root;
}

struct Node* arrayToList(int arr[], int n) {
    struct Node* root = NULL;
    for (int i = 0; i < n; i++) {
        root = insertEnd(root, arr[i]);
    }
    return root;
}

void display(struct Node* root) {
    while (root != NULL) {
        printf("%d ", root->data);
        root = root->next;
    }
}

// Driver code
int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int n = sizeof(arr) / sizeof(arr[0]);
    struct Node* root = arrayToList(arr, n);
    display(root);
    return 0;
}
Java 
class Node {
    int data;
    Node next;
    Node(int d) {
        data = d;
        next = null;
    }
}

class GfG {
  
    public static Node insertEnd(Node root, int item) {
        Node temp = new Node(item);
        if (root == null) {
            return temp;
        }

        Node last = root;
        while (last.next != null) {
            last = last.next;
        }

        last.next = temp;
        return root;
    }

    public static Node arrayToList(int[] arr) {
        Node root = null;
        for (int i = 0; i < arr.length; i++) {
            root = insertEnd(root, arr[i]);
        }
        return root;
    }

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

    // Driver code
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        Node root = arrayToList(arr);
        display(root);
    }
}
Python 
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

def insert_end(root, item):
    temp = Node(item)
    if root is None:
        return temp
    
    last = root
    while last.next is not None:
        last = last.next
    
    last.next = temp
    return root

def array_to_list(arr):
    root = None
    for item in arr:
        root = insert_end(root, item)
    return root

def display(root):
    while root is not None:
        print(root.data, end=" ")
        root = root.next

# Driver code
if __name__ == "__main__":
    arr = [1, 2, 3, 4, 5]
    root = array_to_list(arr)
    display(root)
C# 
using System;

class Node {
    public int data;
    public Node next;

    public Node(int d) {
        data = d;
        next = null;
    }
}

class GfG {
    public static Node InsertEnd(Node root, int item) {
        Node temp = new Node(item);
        if (root == null) {
            return temp;
        }

        Node last = root;
        while (last.next != null) {
            last = last.next;
        }

        last.next = temp;
        return root;
    }

    public static Node ArrayToList(int[] arr) {
        Node root = null;
        for (int i = 0; i < arr.Length; i++) {
            root = InsertEnd(root, arr[i]);
        }
        return root;
    }

    public static void Display(Node root) {
        while (root != null) {
            Console.Write(root.data + " ");
            root = root.next;
        }
    }

    // Driver code
    public static void Main(string[] args) {
        int[] arr = { 1, 2, 3, 4, 5 };
        Node root = ArrayToList(arr);
        Display(root);
    }
}
JavaScript 
class Node {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

function insertEnd(root, item) {
    const temp = new Node(item);
    if (root === null) {
        return temp;
    }

    let last = root;
    while (last.next !== null) {
        last = last.next;
    }

    last.next = temp;
    return root;
}

function arrayToList(arr) {
    let root = null;
    for (let i = 0; i < arr.length; i++) {
        root = insertEnd(root, arr[i]);
    }
    return root;
}

function display(root) {
    while (root !== null) {
        process.stdout.write(root.data + " ");
        root = root.next;
    }
}

// Example usage
const arr = [1, 2, 3, 4, 5];
const root = arrayToList(arr);
display(root);

Output
1 2 3 4 5

Time Complexity : O(n*n)
Efficient Approach: We traverse array from end and insert every element at the beginning of the list. 
 

C++ 
#include <iostream>
using namespace std;

// Representation of a node
struct Node {
    int data;
    Node* next;
    Node(int d){
       data = d;
       next = NULL;
    }
};

// Function to insert node
void insert(Node** root, int item)
{
    Node* temp = new Node(item);
    temp->next = *root;
    *root = temp;
}

void display(Node* root)
{
    while (root != NULL) {
        cout << root->data << " ";
        root = root->next;
    }
}

Node *arrayToList(int arr[], int n)
{
    Node *root = NULL;
    for (int i = n-1; i >= 0 ; i--)
        insert(&root, arr[i]);
    return root;
}

// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int n = sizeof(arr) / sizeof(arr[0]);
    Node* root = arrayToList(arr, n);
    display(root);
    return 0;
}
Java 
// Java program to print level order traversal
// in spiral form using one queue and one stack.
import java.util.*;
class GFG 
{ 

// Representation of a node
static class Node 
{
    int data;
    Node next;
    Node (int d) {
       data = d;
       next = null;
    }
};
static Node root; 

// Function to insert node
static Node insert(Node root, int item)
{
    Node temp = new Node(item);
    temp.next = root;
    root = temp;
    return root;
}

static void display(Node root)
{
    while (root != null) 
    {
        System.out.print(root.data + " ");
        root = root.next;
    }
}

static Node arrayToList(int arr[], int n)
{
    root = null;
    for (int i = n - 1; i >= 0 ; i--)
        root = insert(root, arr[i]);
    return root;
}

// Driver code
public static void main(String[] args)
{
    int arr[] = { 1, 2, 3, 4, 5 };
    int n = arr.length;
    Node root = arrayToList(arr, n);
    display(root);
}
}
Python 
# Python3 program to print level order traversal 
# in spiral form using one queue and one stack. 

# Representation of a Node 
class Node: 
    def __init__(self, data): 
        self.data = data 
        self.next = next

# Function to insert Node 
def insert(root, item): 
    temp = Node(0) 
    temp.data = item 
    temp.next = root 
    root = temp
    return root 

def display(root): 
    while (root != None): 
        print(root.data, end=" ") 
        root = root.next 

def arrayToList(arr, n): 
    root = None 
    for i in range(n - 1, -1, -1): 
        root = insert(root, arr[i])
    return root 

# Driver code 
if __name__ == '__main__': 
    arr = [1, 2, 3, 4, 5]; 
    n = len(arr) 
    root = arrayToList(arr, n); 
    display(root) 

# This code is contributed by 29AjayKumar
C# 
// C# program to print level order traversal
// in spiral form using one queue and one stack.
using System;
    
class GFG 
{ 

// Representation of a node
public class Node 
{
    public int data;
    public Node next;
};
static Node root; 

// Function to insert node
static Node insert(Node root, int item)
{
    Node temp = new Node();
    temp.data = item;
    temp.next = root;
    root = temp;
    return root;
}

static void display(Node root)
{
    while (root != null) 
    {
        Console.Write(root.data + " ");
        root = root.next;
    }
}

static Node arrayToList(int []arr, int n)
{
    root = null;
    for (int i = n - 1; i >= 0 ; i--)
        root = insert(root, arr[i]);
    return root;
}

// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 2, 3, 4, 5 };
    int n = arr.Length;
    Node root = arrayToList(arr, n);
    display(root);
}
}

// This code is contributed by Rajput-Ji
JavaScript 
// JavaScript program to print level order traversal
// in spiral form using one queue and one stack.
// Representation of a node
class Node {
    constructor()
    {
        this.data = 0;
        this.next = null;
    }
}
var root;

// Function to insert node
function insert(root, item)
{
    var temp = new Node();
    temp.data = item;
    temp.next = root;
    root = temp;
    return root;
}

function display(root)
{
    while (root != null) {
        console.log(root.data + " ");
        root = root.next;
    }
}

function arrayToList(arr, n)
{
    root = null;
    for (var i = n - 1; i >= 0; i--)
        root = insert(root, arr[i]);
    return root;
}

// Driver code
var arr = [ 1, 2, 3, 4, 5 ];
var n = arr.length;
var root = arrayToList(arr, n);
display(root);

Output
1 2 3 4 5

Time Complexity : O(n)


Alternate Efficient Solution is maintain tail pointer, traverse array elements from left to right, insert at tail and update tail after insertion.
 


Next Article
Create linked list from a given array

P
Premdeep Toppo
Improve
Article Tags :
Practice Tags :

Similar Reads

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox