Breaking News: Grepper is joining You.com. Read the official announcement!

linked list implementation and functions

Defiant Donkey answered on January 31, 2022 Popularity 9/10 Helpfulness 1/10

answer linked list implementation and functions

linked list implementation and functions

Comment

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


class LinkedList:
    def __init__(self):
        self.head = None

    def print_list(self):
        cur_node = self.head
        while cur_node:
            print(cur_node.data)
            cur_node = cur_node.next

    def append(self, data):
        new_node = Node(data)

        if self.head is None:
            self.head = new_node
            return

        last_node = self.head
        while last_node.next:
            last_node = last_node.next
        last_node.next = new_node

    def prepend(self, data):
        new_node = Node(data)

        new_node.next = self.head
        self.head = new_node

    def insert_after_node(self, prev_node, data):

        if not prev_node:
            print("Previous node does not exist.")
            return 

        new_node = Node(data)

        new_node.next = prev_node.next
        prev_node.next = new_node

    def delete_node(self, key):

        cur_node = self.head

        if cur_node and cur_node.data == key:
            self.head = cur_node.next
            cur_node = None
            return

        prev = None 
        while cur_node and cur_node.data != key:
            prev = cur_node
            cur_node = cur_node.next

        if cur_node is None:
            return 

        prev.next = cur_node.next
        cur_node = None

    def delete_node_at_pos(self, pos):
        if self.head:
            cur_node = self.head

            if pos == 0:
                self.head = cur_node.next
                cur_node = None
                return

            prev = None
            count = 1
            while cur_node and count != pos:
                prev = cur_node 
                cur_node = cur_node.next
                count += 1

            if cur_node is None:
                return 

            prev.next = cur_node.next
            cur_node = None

    def len_iterative(self):

        count = 0
        cur_node = self.head

        while cur_node:
            count += 1
            cur_node = cur_node.next
        return count

    def len_recursive(self, node):
        if node is None:
            return 0
        return 1 + self.len_recursive(node.next)

    def print_helper(self, node, name):
        if node is None:
            print(name + ": None")
        else:
            print(name + ":" + node.data)

    def reverse_iterative(self):

        prev = None 
        cur = self.head
        while cur:
            nxt = cur.next
            cur.next = prev
            prev = cur 
            cur = nxt 
        self.head = prev

    def reverse_recursive(self):

        def _reverse_recursive(cur, prev):
            if not cur:
                return prev

            nxt = cur.next
            cur.next = prev
            prev = cur 
            cur = nxt 
            return _reverse_recursive(cur, prev)

        self.head = _reverse_recursive(cur=self.head, prev=None)

Popularity 9/10 Helpfulness 1/10 Language whatever

Source: Grepper

Tags: implementation linked-list whatever

Link to this answer
Share Copy Link

Contributed on Jan 31 2022

Defiant Donkey

0 Answers Avg Quality 2/10

Closely Related Answers

implementation linked list

Comment

// try to do it by your own logic ( ͡~ ͜ʖ ͡°)  don't forget to upvote the answer and search for me @mohammad alshraideh ( ͡°( ͡° ͜ʖ( ͡° ͜ʖ ͡°)ʖ ͡°) ͡°)
'use strict';'use strict';

class Node{
    constructor(data) {
        this.data =data;
        this.next =null;
    }
}
class LinkedList {
    constructor() {
        this.head = null;
        this.length =0 ;
    }

    insertFirstNode(data) {
      this.head = new Node(data, this.head);
      this.length++;
  }

  insertLastNode(data) {

    const newNode = new Node(data);

    if (!this.head) {
        this.head = newNode;
    } else {
        let currentNode = this.head;

        while (currentNode.next) {
            currentNode = currentNode.next;
        }

        currentNode.next = newNode;
    }

    this.length++;
}
insertNodeAtIndex(data, index) {
  if (this.length < index) {
      console.log("index is greater than size of list");
      return null ;
  }

  const node = new Node(data);

  // if (!this.head) {
  //     // this.head = node;
  // } else
  if (index === 0) {
      const head = this.head;
      this.head = node;
      node.next = head;
  } else {
      let previousNode;
      let currentNode = this.head;
      let indexCounter = 0;

      while (indexCounter < index) {
          previousNode = currentNode;
          currentNode = previousNode.next;

          indexCounter++;
      }

      previousNode.next = node;
      node.next = null;

      if (currentNode) {
          node.next = currentNode;
      }
  }

  this.length++;
}
getNodeAtIndex(index) {
  if (index > this.length) {
      console.log("index is greater than size of list");
      return null;
  }

  let currentNode = this.head;
  let counter = 0;

  while (counter < index) {
      currentNode = currentNode.next;
      counter++;
  }
return currentNode.data ;

}
includes(values) {
  let isIncludes = false;
  let currentNode = this.head;
  while (currentNode) {

    if (currentNode.data === values) {
      isIncludes = true;
}
      currentNode = currentNode.next;
  }
  return isIncludes;
}

removeNodeAtIndex(index) {
  if (index > this.length) {
      console.log("index is greater than size of list");
      return null;
  }

  if (!this.head) {
      console.log("List is empty");
      return null;
  }

  if (index === 0) {
      this.head = null;
  } else {
      let previousNode;
      let currentNode = this.head;
      let counter = 0;

      while (counter < index) {
          previousNode = currentNode;
          currentNode = previousNode.next;

          counter++;
      }

      if (currentNode.next) {
          previousNode.next = currentNode.next;
      }
      
  }

  this.size--;

  console.log(
      `Removed node at index(${index}) and current linked list is: })`
  );
}
clear() {
  //for each of the nodes, remove at index

  let index = 0;

  while (index < this.length) {
      console.log(`removing at index: ${index}`);
      this.removeNodeAtIndex(index);
      this.length--;
      index++;
  }
}

toString() {
  let currentNode = this.head;
  let output ='';

  while (currentNode) {
 output = ` ${output}${currentNode.data} ->  ` ;

      currentNode = currentNode.next;
  }
  console.log(`${output}null`);
}



}


module.exports=LinkedList ;

Popularity 10/10 Helpfulness 1/10 Language javascript

Source: github.com

Tags: implementation impl

Link to this answer
Share Copy Link

Contributed on Aug 13 2022

Mohammad alshraideh

0 Answers Avg Quality 2/10

linked list implementation and functions

Contents

More Related Answers

linked list implementation and functions

Closely Related Answers

implementation linked list

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.