IronCodeMan

Linked List

A linked list is a linear data structure in programming consisting of nodes, where each node contains a data element and a reference (or pointer) to the next node in the sequence. Unlike arrays, linked lists do not require contiguous memory allocation, allowing for dynamic memory management and efficient insertion and deletion operations. Linked lists are commonly used in programming for tasks such as implementing dynamic data structures, managing memory allocation, and representing sequences with variable lengths. For example, linked lists can be used to implement stacks and queues, where elements are dynamically added and removed from the front or back of the list, respectively. Overall, linked lists provide a flexible and efficient way to manage and manipulate data in a variety of programming scenarios, particularly when dynamic memory allocation and efficient insertion and deletion operations are required.

Examples

C

// No Native Support or Implementation

C#

using System;
using System.Collections.Generic;

public class Node {
  public string value;
  public Node next;
  public Node(string Value) {
    value = Value;
  }
}

public class LinkedList {
  public Node head = null;
  
  public void addValue(string val) {
    Node newNode = new Node(val);
    if (head == null) {
      head = newNode;
    } else {
      Node current = head;
      while(current.next != null) {
        current = current.next;
      }
      current.next = newNode;
    }
  }
  public string returnHead() {
    return head.value;
  }

  public void traverse() {
    Node current = head;
    while(current != null) {
      Console.WriteLine(current.value );
      current = current.next;
    }
  }
  public static void Main(string[] args) {
    LinkedList carList = new LinkedList();
    carList.addValue("Mazda");
    carList.addValue("Toyota");
    carList.addValue("Honda");
    
    Console.WriteLine(carList.returnHead());
    carList.traverse();
  }
}

C++

#include <iostream>
using namespace std;

struct Node {
  string value;
  struct Node *next;
};

struct Node* newNode = NULL;

class LinkedList {
  public:
    struct Node *head = NULL;
    
    void addValue(string val) {
      newNode = (struct Node*)
        malloc(sizeof(struct Node));
      newNode->value = val;

      if(head == NULL) {
          head = newNode;
      } else {
        struct Node *current = head;
        while(current->next != NULL) {
          current = current->next;
        }
        current->next = newNode;
      }
    }

    string returnHead() {
      return head->value;
    }

    void traverse() {
      struct Node *current = head;
      while(current != NULL) {
        cout << current->value << endl;
        current = current->next;
      }
    }
};

LinkedList carList;
carList.addValue("Mazda");
carList.addValue("Toyota");
carList.addValue("Honda");

cout << carList.returnHead() << endl;
carList.traverse();

Go

import "fmt"

type Node struct {
  value string
  next *Node
}

type LinkedList struct {
  head *Node
}

func (node *LinkedList) addValue(value string) { 
  newNode := &Node {value, nil}
  if node.head == nil {
    node.head = newNode
  } else {
    current := node.head
    for current.next != nil {
      current = current.next
    }
    current.next = newNode
  }
}

func (node *LinkedList) returnHead()string {
  return node.head.value
}

func (node *LinkedList) traverse() {
  current := node.head
  for current != nil {
    fmt.Println(current.value)
    current = current.next
  }
}

carList := LinkedList{}

carList.addValue("Mazda")
carList.addValue("Toyota")
carList.addValue("Honda")

fmt.Println(carList.returnHead())
carList.traverse()

Java

import java.util.*; 

class Node {
  public String value;
  public Node next;
  
  public Node(String value) {
    this.value = value;
  }
}

class LinkedList {
  
  public Node head = null;
  
  public void addValue(String val) {
    Node newNode = new Node(val);
    if (this.head == null) {
      this.head = newNode;
    } else {
      Node current = this.head;
      while(current.next != null) {
        current = current.next;
      }
      current.next = newNode;
    }
  }
  
  public String returnHead() {
    return this.head.value;
  }
  
  public void traverse() {
    Node current = this.head;
    while(current != null) {
      System.out.println(current.value );
      current = current.next;
    }
  }
  public static void main(String[] args) {
    LinkedList carList = new LinkedList();
    carList.addValue("Mazda");
    carList.addValue("Toyota");
    carList.addValue("Honda");
    
    System.out.println(carList.returnHead() );
    carList.traverse();
  }
}

JavaScript

class Node {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {

  constructor() {
    this.head = null;
  }

  add(value) {
    const newNode = new Node(value);
    if (this.head === null) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  returnHead() {
    return this.head?.value;
  }

  traverse() {
    let current = this.head;
    while(current) {
      console.log(current.value);
      current = current.next;
    }
  }
}

const carList = new LinkedList();
carList.add("Mazda");
carList.add("Toyota");
carList.add("Honda");

console.log(carList.returnHead());
carList.traverse();

Kotlin

class Node(Value: String) {
  var value = Value;
  var next:Node? = null;
}

class LinkedList {
  
  var head:Node ? = null;
  
  fun addValue(newVal:String) {
    var newNode = Node(newVal);
    if (head == null) {
      head = newNode;
    } else {
      var current = head;
      while(current?.next != null) {
        current = current.next;
      }
      current?.next = newNode;
    }
  }
  
  fun returnHead():String? {
    return head?.value;
  }
  
  fun traverse() {
    var current = this.head;
    while(current != null) {
      println(current.value);
      current = current.next;
    }
  }
}

val carList = LinkedList();
carList.addValue("Mazda");
carList.addValue("Toyota");
carList.addValue("Honda");
    
println(carList.returnHead());
carList.traverse();

MatLab

% keep classes in its own files

classdef Node < handle
  properties 
    value 
    next 
  end
  methods
    function obj = Node(Value)
      obj.value = Value;
      obj.next = {};
    end
  end
end

classdef LinkedList < handle
  properties
    head = {}
  end
  methods
    function obj = add(obj, value)
      newNode = Node(value);
      if isempty(obj.head)
         obj.head = newNode;
      else          
        current = obj.head;
        while isempty(current.next) == 0
          current = current.next;
        end
        current.next = newNode;
      end
    end

    function head = returnHead(obj)
      head = obj.head.value;
    end

    function traverse(obj)
      current = obj.head;
      while isempty(current) == 0
        disp(current.value);
        current = current.next;
      end
    end
  end
end

carList = LinkedList();
obj = carList.add("Mazda");
obj = carList.add("Toyota");
obj = carList.add("Honda");

head = carList.returnHead();
disp(head);
carList.traverse();

PHP

class Node {
  public $value;
  public $next;
 
  public function set_value($value) {
    $this->value = $value;
  }
}

class LinkedList {
  public $head = null;

  public function add($value) {
    $newNode = new Node();
    $newNode->set_value($value);
    if ($this->head === null) {
      $this->head = $newNode;
    } else {
      $current = $this->head;
      while ($current->next) {
        $current = $current->next;
      }
      $current->next = $newNode;
    }
  }

  public function returnHead() {
    return $this->head->value;
  }

  public function traverse() {
    $current = $this->head;
    while($current) {
      echo $current->value ."\n";
      $current = $current->next;
    }
  }
}

$carList = new LinkedList();
$carList->add("Mazda");
$carList->add("Toyota");
$carList->add("Honda");

echo $carList->returnHead() ."\n";
$carList->traverse();

Python

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

class LinkedList:
  def __init__(self):
    self.head = None
    
  def add(self, value):
    newNode = Node(value)
    if self.head == None:
      self.head = newNode
    else:
      current = self.head
      while(current.next):
        current = current.next
      current.next = newNode
      
  def returnHead(self):
    return self.head.value
    
  def traverse(self):
    current = self.head
    while(current):
      print(current.value)
      current = current.next

carList = LinkedList()
carList.add('Mazda')
carList.add('Toyota')
carList.add('Honda')

print(carList.returnHead())
carList.traverse()

R

Node <- setRefClass("Node",
  field = c(
    value = "character",
    "next" = "ANY"
  )
)

LinkedList = setRefClass("LinkedList",
  # allows for assigning values by reference
  field = c(
    head = "ANY"
  ),
  
  methods = list(
    add = function(value) {
      newNode <- Node(
        value = value,
        "next" = NULL
      )
      if (is.null(head)) {
        head <<- newNode
      } else {
        current = head
        
        while (!is.null(current[["next"]])) {
          current = current[["next"]]
        }
        
        current[["next"]] = newNode
      }
    },
    
    traverse = function() {
      current = head
      
      while (!is.null(current)) {
        print(current$value)
        current = current[["next"]]
      }
    }
  )
)

carList = LinkedList(
  head = NULL
)

carList$add("Mazda")
carList$add("Toyota")
carList$add("Honda")
carList$traverse()

Ruby

class Node
  # full access to class properties
  attr_accessor :value,:next
  def initialize(value, nextVal = nil)
    @value = value
    @next = nextVal
  end
end

class LinkedList
  attr_accessor :head
  def initialize
    @head = nil
  end
  
  def add(value)
    newNode = Node.new(value)
    
    if @head == nil
      @head = newNode
      
    else
      current = @head
      while current.next != nil
        current = current.next
      end
      current.next = newNode
      
    end
  end
  
  def returnHead()
    return head.value
  end
   
  def traverse()
    current = head
    
    while current != nil
      print(current.value + "\n")
      current = current.next
    end
  end
end

carList = LinkedList.new()
carList.add("Mazda")
carList.add("Toyota")
carList.add("Honda")

puts carList.returnHead()
carList.traverse()

Rust

// No Native Support or Implementation

Scala

class Node(Value:String, Next:Node = null) {
  var value = Value;
  var next = Next;
};

class LinkedList {
  var head:Node = _
  
  def add(value:String) {
    var newNode = new Node(value);
    
    if (head == null) {
      head = newNode;
    } else {
      var current = head;
      
      while(current.next != null) {
        current = current.next;
      }
      current.next = newNode;
    }
  }
  
  def traverse() {
    var current = head;
    while(current != null) {
      print(current.value + "\n");
      current = current.next;
    }
  }
}

var carList = new LinkedList();
carList.add("Mazda");
carList.add("Toyota");
carList.add("Honda");

print(carList.head.value + "\n");
carList.traverse();

Swift

class Node {
  var value: String;
  var next: Node? = nil;
  
  init(value:String) {
    self.value = value;
  }
}

class LinkedList {
  var head:Node? = nil;
  
  func add(Value:String) {
    let newNode = Node(value:Value)
    
    if (self.head == nil) {
      self.head = newNode;
    } else {
      var current:Node? = self.head;
      while(current?.next != nil) {
        current = current?.next;
      }
      current?.next = newNode;
    }
  }
  
  func returnHead() -> String {
    return self.head?.value ?? "";
  }
  
  func traverse() {
    var current:Node? = self.head;
     
    while(current != nil) {
      print(current?.value ?? "");
      current = current?.next;
    }
  }
}

var carList = LinkedList();
carList.add(Value: "Mazda");
carList.add(Value: "Toyota");
carList.add(Value: "Honda");

print(carList.returnHead());
carList.traverse();

TypeScript

class NodeTest {
  value: string;
  next: NodeTest | null;
  constructor(value:string) {
    this.value = value;
    this.next = null;
  }
}

class LinkedList {
  head: NodeTest | null;
  constructor() {
    this.head = null;
  }

  add(value: string) {
    const newNode = new NodeTest(value);
    if (this.head === null) {
      this.head = newNode;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  returnHead():string {
    return this.head? this.head.value: "";
  }

  traverse() {
    let current = this.head;
    while(current) {
      console.log(current.value);
      current = current.next;
    }
  }
}

const carList = new LinkedList();
carList.add("Mazda");
carList.add("Toyota");
carList.add("Honda");

console.log(carList.returnHead());
carList.traverse();

Basics

Data Structure

Iterables

Classes

Regex