🔥01- Linked List এবং Array
<br>

🔥02- লিঙ্কড লিস্ট এবং বিগ ও (Big O)
<br>

let myLinkedList = new LinkedList(23); // প্রথম নোডের মান 23 দিয়ে লিঙ্কড লিস্ট তৈরি করে
myLinkedList.push(7); // শেষে 7 যোগ করে  | O(1)
myLinkedList.unshift(3); // শুরুতে 3 যোগ করে
myLinkedList.insertAt(1, 11); // সূচক 1 এ 11 সন্নিবেশ করে
myLinkedList.remove(1); // সূচক 1 থেকে আইটেম অপসারণ করে (11)

class LinkedList {
  constructor(value) {
    this.head = { value: value, next: null }; // হেড নোড শুরু করা
    this.length = 1; // দৈর্ঘ্য ট্র্যাক করা
  }

  push(value) {
    // শেষের দিকে নতুন নোড যোগ করার মেথড
  }

  unshift(value) {
    // শুরুতে নতুন নোড যোগ করার মেথড
  }

  insertAt(index, value) {
    // নির্দিষ্ট সূচকে একটি নোড সন্নিবেশ করার মেথড
  }

  remove(index) {
    // নির্দিষ্ট সূচক থেকে একটি নোড অপসারণ করার মেথড
  }

  pop() {
    // শেষ নোড অপসারণ করার মেথড
  }

  shift() {
    // প্রথম নোড অপসারণ করার মেথড
  }
}

🔥03- লিঙ্কড লিস্টের অন্তর্নিহিত গঠন
<br>

{
    value: 7,
    next: 
}

node7.next = node4; // ৭ নোডটি ৪ নোডের দিকে নির্দেশ করে

class Node {
  constructor(value) {
    this.value = value;
    this.next = null; // পরবর্তী নোডের জন্য পয়েন্টার
  }
}

class LinkedList {
  constructor() {
    this.head = null; // প্রথম নোড
    this.tail = null; // শেষ নোড
  }

  add(value) {
    const newNode = new Node(value);
    if (!this.head) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode; // শেষ নোডের পরবর্তী পয়েন্টার সেট করা
      this.tail = newNode; // টেইল আপডেট করা
    }
  }
}

🔥04- লিঙ্কড লিস্টের Constructor
<br>

class LinkdList {
    constructor(value){
        // create new Node;

    }
    push(value){
        // create new Node
        add Node to end

    }
    unshift(value){
        // create new Node
        add Node to begining
    }
    insert (index, value){
        // create new Node
        add Node to begining
    }

class Node {
  constructor(value) {
    this.value = value; // নোডের মান
    this.next = null; // পরবর্তী নোডের জন্য পয়েন্টার
  }
}

// node class
class MyNode {
  constructor(value) {
    this.value = value;
    this.next = null;
  }
}

const newNode_4 = new MyNode(4); //{value:4, next:null}

class LinkedList {
  constructor(value) {
    const newNode = new Node(value); // নতুন নোড তৈরি করা
    this.head = newNode; // হেডকে নতুন নোডের দিকে নির্দেশ করা
    this.tail = newNode; // টেইলকে একই নোডের দিকে নির্দেশ করা
    this.length = 1; // দৈর্ঘ্য ১ সেট করা
  }
}

const myLinkedList = new LinkedList(4); // ৪ মান সহ একটি নতুন লিঙ্কড লিস্ট তৈরি করা

LinkedList {
    head: Node { value: 4, next: null },
    tail: Node { value: 4, next: null },
    length: 1
}

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

class LinkdList {
  constructor(value) {
    const newNode = new CreateNode(value);
    this.head = newNode;
    this.tail = this.head;
    this.length = 1;
  }
}

let LL1 = new LinkdList(4);

/*  outPut:
LinkdList {
  head: CreateNode { value: 4, next: null },
  tail: CreateNode { value: 4, next: null },
  length: 1
}

*/

🔥05- লিঙ্কড লিস্টের পুশ (Push) মেথড
<br>

push(value) {
    const newNode = new Node(value); // নতুন নোড তৈরি করা

    // যদি হেড খালি হয়
    if (!this.head) {
        this.head = newNode; // হেডকে নতুন নোডের দিকে নির্দেশ করা
        this.tail = newNode; // টেইলকেও নতুন নোডের দিকে নির্দেশ করা
    } else {
        this.tail.next = newNode; // শেষ নোডের পরবর্তী পয়েন্টারকে নতুন নোডের দিকে নির্দেশ করা
        this.tail = newNode; // টেইলকে নতুন নোডের দিকে নির্দেশ করা
    }

    this.length++; // দৈর্ঘ্য ১ বাড়ানো
    return this; // পুরো লিঙ্কড লিস্ট ফেরত দেওয়া
}

let myLinkedList = new LinkedList(7); // ৭ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.push(4); // ৪ মান যুক্ত করা

LinkedList {
    head: Node { value: 7, next: Node { value: 4, next: null } },
    tail: Node { value: 4, next: null },
    length: 2
}

/* 
    🌟 Create a new node 
    🌟if it is first clild or head === null
        assign head pointer to the new Node
        assign tail pointer to the newNode
    🌟 else
        tail.next = newNode e point koray dibo
        tail=newNode kore dibo
    lenght =lenght+1;
    return this --> this represents the global object

*/

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

class LL {
  constructor(value) {
    const newNode = new CreateNode(value);
    this.head = newNode;
    this.tail = newNode;
    this.length = 1;
  }

  // push or add node at the end
  push(value) {
    const newNode = new CreateNode(value);
    if (this.head === null) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail = newNode;
    }
    this.length++;
    return this;
  }
}

let myLL = new LL(null);
myLL.push(4);
myLL.push(4);
console.log(myLL);

🔥06- লিঙ্কড লিস্টের পপ (Pop) মেথড
<br>

pop() {
    // case 0 items
    if (!this.head) {
        return undefined; // যদি তালিকা খালি হয়
    }
// case two or more items
    let temp = this.head;
    let pre = this.head;

    // তালিকার মধ্য দিয়ে পুনরাবৃত্তি করা means as long as temp !== null
    while (temp.next) {
        pre = temp; // পূর্ববর্তী নোড আপডেট করা
        temp = temp.next; // পরবর্তী নোডে যাওয়া
    }

    this.tail = pre; // টেইলকে পূর্ববর্তী নোডে নির্দেশ করা
    this.tail.next = null; // শেষ নোড অপসারণ করা
    this.length --;

    return temp; // অপসারিত নোড ফেরত দেওয়া

//case for one items
   this.tail = pre; // টেইলকে পূর্ববর্তী নোডে নির্দেশ করা
    this.tail.next = null; // শেষ নোড অপসারণ করা
    this.length --;
    if(this.length ===0){
        this.head =null;
        this.tail =null;
    }
    return temp


}

pop() {
    // ১. শূন্য আইটেম চেক করা
    if (!this.head || this.length === 0) {
        return undefined; // তালিকা খালি হলে undefined ফেরত দিন
    }

    let temp = this.head; // টেম্প ভেরিয়েবল হেডকে নির্দেশ করে
    let pre = null; // পূর্ববর্তী নোডের জন্য ভেরিয়েবল

    // ২. তালিকার মধ্য দিয়ে পুনরাবৃত্তি করা
    while (temp.next) {
        pre = temp; // পূর্ববর্তী নোড আপডেট করা
        temp = temp.next; // টেম্পকে পরবর্তী নোডে সরানো
    }

    // ৩. টেইল আপডেট করা
    this.tail = pre; // টেইলকে পূর্ববর্তী নোডে নির্দেশ করা
    this.tail.next = null; // শেষ নোড অপসারণ করা

    this.length--; // দৈর্ঘ্য কমানো

    // ৪. একমাত্র আইটেম থাকলে হেড এবং টেইল আপডেট করা
    if (this.length === 0) {
        this.head = null;
        this.tail = null;
    }

    return temp; // অপসারিত নোড ফেরত দেওয়া
}

let myLinkedList = new LinkedList(1); // ১ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.push(2); // ২ মান যুক্ত করা

console.log(myLinkedList.pop()); // এটি ২ নোড ফেরত দেবে
console.log(myLinkedList); // এখন হেড ১ নোডকে নির্দেশ করবে, টেইলও ১ হবে

console.log(myLinkedList.pop()); // এটি ১ নোড ফেরত দেবে
console.log(myLinkedList); // এখন তালিকা খালি হবে, হেড এবং টেইল উভয়ই null হবে

console.log(myLinkedList.pop()); // এটি undefined ফেরত দেবে কারণ তালিকা খালি

/*  
Pop is O(n) operation.
    case 1: no element
    case 2: two or more elements
    case 3: 1 element


*/



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

class LinkdList {
  constructor(value) {
    const newNode = new CreateNode(value);
    this.head = newNode;
    this.tail = newNode;
    this.length = 1;
  }

  // push or add node at the end
  push(value) {
    const newNode = new CreateNode(value);
    if (this.head === null) {
      this.head = newNode;
      this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail = newNode;
    }
    this.length++;
    return this;
  };


  // pop or remove node at the last O(n)
  pop(){

    // case 1: no element
    if(!this.head || this.length ===0){
        return undefined;
    }
    // case 2: two or more elements
    let temp =this.head;
    let pre =this.head;
    while(temp.next !==null){
        pre =temp;
        temp = temp.next;
    }
    //both case 2 and 3
    this.tail =pre;
    this.tail.next =null;
    this.length --;

    // case 3: 1 element
    if(this.length ===0){
        this.head =null;
        this.tail =null;
    }
    return temp;

  }
};

let myLinkedList =new LinkdList(1);
myLinkedList.push(23);
myLinkedList.push(26);
console.log(myLinkedList)

myLinkedList.pop()
console.log(myLinkedList);

myLinkedList.pop()
console.log(myLinkedList);

myLinkedList.pop()
console.log(myLinkedList)

myLinkedList.pop()
console.log(myLinkedList);

🔥07- লিঙ্কড লিস্টের আনশিফট (Unshift) মেথড
<br>

unshift(value) {
    const newNode = new Node(value); // নতুন নোড তৈরি করা

    // যদি তালিকা খালি হয়
    if (!this.head) {
        this.head = newNode; // হেডকে নতুন নোডের দিকে নির্দেশ করা
        this.tail = newNode; // টেইলকেও নতুন নোডের দিকে নির্দেশ করা
    } else {
        newNode.next = this.head; // নতুন নোডের পরবর্তী পয়েন্টারকে বর্তমান হেডের দিকে নির্দেশ করা
        this.head = newNode; // হেডকে নতুন নোডের দিকে নির্দেশ করা
    }

    this.length++; // দৈর্ঘ্য ১ বাড়ানো
    return this; // পুরো লিঙ্কড লিস্ট ফেরত দেওয়া
}

let myLinkedList = new LinkedList(11); // ১১ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.unshift(4); // ৪ মান যুক্ত করা

LinkedList {
    head: Node { value: 4, next: Node { value: 11, next: null } },
    tail: Node { value: 11, next: null },
    length: 2
}

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

class LinkdList {
    constructor(value) {
        const newNode = new CreateNode(value);
        this.head = newNode;
        this.tail = newNode;
        this.length = 1;
    }

    // push or add node at the end
    push(value) {
        const newNode = new CreateNode(value);
        if (this.head === null) {
            this.head = newNode;
            this.tail = newNode;
        } else {
            this.tail.next = newNode;
            this.tail = newNode;
        }
        this.length++;
        return this;
    }
    pop() {

        if (!this.head)
            return undefined;
        let temp = this.head;
        let pre = this.head;
        while (temp.next) {
            pre = temp;
            temp = temp.next;
        }
        this.tail = pre;
        this.tail.next = null;
        this.length--;

        if (this.length === 0) {
            this.head = null;
            this.tail = null;
        }
        return temp;
    };


    unshift(value){
        const newNode =new CreateNode(value);

        if(!this.head){
            this.head = newNode;
            this.tail = newNode;
        }else{
            newNode.next =this.head; // pointer update
            this.head =newNode;   // new node k head banalam 
            // newNode =this.head;   // not working anymore
        }
        this.length++;
        return this; //whole linked list

    }
}

let myLinkedList = new LinkdList(1);
myLinkedList.push(20);
myLinkedList.push(70);
myLinkedList.push(40);
// console.log(myLinkedList);

myLinkedList.unshift(33);
console.log(myLinkedList);

🔥08- লিঙ্কড লিস্টের শিফট (Shift) মেথড
<br>

shift() {
    // ১. শূন্য আইটেম চেক করা
    if (!this.head) {
        return undefined; // তালিকা খালি হলে undefined ফেরত দিন
    }

    let temp = this.head; // টেম্প ভেরিয়েবল হেডকে নির্দেশ করে

    // ২. হেড আপডেট করা
    this.head = this.head.next; // হেডকে পরবর্তী নোডে নির্দেশ করা

    // ৩. অপসারিত নোডের পরবর্তী পয়েন্টারকে null সেট করা
    temp.next = null;

    // ৪. দৈর্ঘ্য কমানো
    this.length--;

    // ৫. যদি তালিকা খালি হয়, তাহলে টেইল আপডেট করা
    if (this.length === 0) {
        this.tail = null;
    }

    return temp; // অপসারিত নোড ফেরত দেওয়া
}

let myLinkedList = new LinkedList(2); // ২ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.unshift(1); // ১ মান যুক্ত করা

console.log(myLinkedList.shift()); // এটি ১ নোড ফেরত দেবে
console.log(myLinkedList); // এখন তালিকায় ২ নোড থাকবে

myLinkedList.shift(); // এটি ২ নোড ফেরত দেবে
console.log(myLinkedList); // এখন তালিকা খালি হবে, হেড এবং টেইল উভয়ই null হবে

console.log(myLinkedList.shift()); // এটি undefined ফেরত দেবে কারণ তালিকা খালি

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

class LinkdList {
    constructor(value) {
        const newNode = new CreateNode(value);
        this.head = newNode;
        this.tail = newNode;
        this.length = 1;
    }


    //todo: Add Node
    // push or add node at the end
    push(value) {
        const newNode = new CreateNode(value);
        if (this.head === null) {
            this.head = newNode;
            this.tail = newNode;
        } else {
            this.tail.next = newNode;
            this.tail = newNode;
        }
        this.length++;
        return this;
    }

    // add node at the start
    unshift(value){
        const newNode =new CreateNode(value);

        if(!this.head){
            this.head = newNode;
            this.tail = newNode;
        }else{
            newNode.next =this.head; // pointer update
            this.head =newNode;   // new node k head banalam 
        }
        this.length++;
        return this; //whole linked list
    }

    //todo: Delete Node 

    // remove from end
    pop() {

        if (!this.head)
            return undefined;
        let temp = this.head;
        let pre = this.head;
        while (temp.next) {
            pre = temp;
            temp = temp.next;
        }
        this.tail = pre;
        this.tail.next = null;
        this.length--;

        if (this.length === 0) {
            this.head = null;
            this.tail = null;
        }
        return temp;
    };

    //remove from first
    shift(){
        if(!this.head) 
            return this.undefined;
        let tempNode =this.head;   // tempNode pointing to the head
        this.head =this.head.next;  // move head pointer
        tempNode.next= null;   // finally ser tempNode to null for detaching from head
        this.length--;

        if(this.length ===0){
            this.tail =null;
        }
        return this;
    }
}

let myLinkedList = new LinkdList(1);
myLinkedList.push(20);

myLinkedList.unshift(33);
console.log(myLinkedList);

myLinkedList.shift();
console.log(myLinkedList);

🔥09 -লিঙ্কড লিস্টের গেট (Get) মেথড
<br>

get(index) {
    // ১. ইনডেক্স চেক করা
    if (index < 0 || index >= this.length) {
        return undefined; // অবৈধ ইনডেক্স হলে undefined ফেরত দিন
    }

    let temp = this.head; // টেম্প ভেরিয়েবল হেডকে নির্দেশ করে

    // ২. তালিকার মধ্য দিয়ে পুনরাবৃত্তি করা
    for (let i = 0; i < index; i++) {
        temp = temp.next; // টেম্পকে পরবর্তী নোডে সরানো
    }

    return temp; // নির্দিষ্ট ইনডেক্সের নোড ফেরত দেওয়া
}

let myLinkedList = new LinkedList(0); // ০ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.unshift(1); // ১ মান যুক্ত করা
myLinkedList.unshift(2); // ২ মান যুক্ত করা
myLinkedList.unshift(3); // ৩ মান যুক্ত করা

console.log(myLinkedList.get(-1)); // এটি undefined ফেরত দেবে (অবৈধ ইনডেক্স)
console.log(myLinkedList.get(10)); // এটি undefined ফেরত দেবে (অবৈধ ইনডেক্স)
console.log(myLinkedList.get(2)); // এটি ২ নোড ফেরত দেবে (বৈধ ইনডেক্স)

🔥10- লিঙ্কড লিস্টের সেট (Set) মেথড
<br>

set(index, value) {
    // ১. ইনডেক্স চেক করা
    if (index < 0 || index >= this.length) {
        return false; // অবৈধ ইনডেক্স হলে false ফেরত দিন
    }

    let temp = this.get(index); // নির্দিষ্ট ইনডেক্সের নোড খোঁজা

    // ২. নোড পাওয়া গেলে মান পরিবর্তন করা
    if (temp) {
        temp.value = value; // নোডের মান পরিবর্তন করা
        return true; // সফলভাবে পরিবর্তন হলে true ফেরত দিন
    }

    return false; // নোড না পাওয়া গেলে false ফেরত দিন
}

let myLinkedList = new LinkedList(3); // ৩ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.unshift(2); // ২ মান যুক্ত করা
myLinkedList.unshift(1); // ১ মান যুক্ত করা

console.log(myLinkedList.set(1, 4)); // এটি true ফেরত দেবে এবং ২ নোডের মানকে ৪ এ পরিবর্তন করবে
console.log(myLinkedList.get(1)); // এটি এখন ৪ ফেরত দেবে

🔥11 -লিঙ্কড লিস্টের ইনসার্ট (Insert) মেথড
<br>

insert(index, value) {
    // ১. ইনডেক্স চেক করা
    if (index < 0 || index > this.length) {
        return false; // অবৈধ ইনডেক্স হলে false ফেরত দিন
    }

    const newNode = new Node(value); // নতুন নোড তৈরি করা

    // ২. যদি ইনডেক্স ০ হয়
    if (index === 0) {
        return this.unshift(value); // unshift মেথড কল করা
    }

    // ৩. যদি ইনডেক্স তালিকার দৈর্ঘ্যের সমান হয়
    if (index === this.length) {
        return this.push(value); // push মেথড কল করা
    }

    // ৪. তালিকার মাঝখানে ইনসার্ট করা
    let temp = this.get(index - 1); // পূর্ববর্তী নোড খোঁজা
    newNode.next = temp.next; // নতুন নোডের পরবর্তী পয়েন্টার আপডেট করা
    temp.next = newNode; // পূর্ববর্তী নোডের পরবর্তী পয়েন্টারকে নতুন নোডে নির্দেশ করা

    this.length++; // দৈর্ঘ্য বাড়ানো
    return true; // সফলভাবে পরিবর্তন হলে true ফেরত দিন
}

let myLinkedList = new LinkedList(0); // ০ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.push(2); // ২ মান যুক্ত করা

console.log(myLinkedList.insert(1, 1)); // এটি true ফেরত দেবে এবং ১ নোডকে ইনসার্ট করবে
console.log(myLinkedList); // এখন তালিকায় ০ -> ১ -> ২ থাকবে

🔥12-লিঙ্কড লিস্টের রিমুভ (Remove) মেথড 
<br>

remove(index) {
    // ১. ইনডেক্স চেক করা
    if (index < 0 || index >= this.length) {
        return undefined; // অবৈধ ইনডেক্স হলে undefined ফেরত দিন
    }

    // ২. প্রথম আইটেম সরানো
    if (index === 0) {
        return this.shift(); // shift মেথড কল করা
    }

    // ৩. শেষ আইটেম সরানো
    if (index === this.length - 1) {
        return this.pop(); // pop মেথড কল করা
    }

    // ৪. মাঝখানে আইটেম সরানো
    let before = this.get(index - 1); // পূর্ববর্তী নোড খোঁজা
    let temp = before.next; // অপসারিত নোডটি খোঁজা

    before.next = temp.next; // পূর্ববর্তী নোডের পরবর্তী পয়েন্টার আপডেট করা
    temp.next = null; // অপসারিত নোডের পরবর্তী পয়েন্টারকে null সেট করা

    this.length--; // দৈর্ঘ্য কমানো

    return temp; // অপসারিত নোড ফেরত দেওয়া
}

let myLinkedList = new LinkedList(11); // ১১ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.push(23); // ২৩ মান যুক্ত করা
myLinkedList.push(7); // ৭ মান যুক্ত করা

console.log(myLinkedList.remove(1)); // এটি ২৩ নোড ফেরত দেবে এবং তালিকা থেকে সরিয়ে দেবে
console.log(myLinkedList); // এখন তালিকায় ১১ -> ৭ থাকবে, দৈর্ঘ্য হবে 2

🔥13-Reverse Linked List
<br>

reverse() {
    // ১. হেড এবং টেইল পরিবর্তন করা
    let temp = this.head; // টেম্প ভেরিয়েবল হেডকে নির্দেশ করে
    this.head = this.tail; // হেডকে টেইলে নির্দেশ করা
    this.tail = temp; // টেইলকে পূর্ববর্তী হেডে নির্দেশ করা

    let next = null; // পরবর্তী নোডের জন্য ভেরিয়েবল
    let previous = null; // পূর্ববর্তী নোডের জন্য ভেরিয়েবল

    // ২. তালিকার মধ্য দিয়ে পুনরাবৃত্তি করা
    while (temp) {
        next = temp.next; // পরবর্তী নোড সংরক্ষণ করা
        temp.next = previous; // বর্তমান নোডের পরবর্তী পয়েন্টার আপডেট করা
        previous = temp; // পূর্ববর্তী নোড আপডেট করা
        temp = next; // টেম্পকে পরবর্তী নোডে সরানো
    }

    // ৩. ফলাফল ফেরত দেওয়া
    return this; // পুরো উল্টানো তালিকা ফেরত দেওয়া
}

let myLinkedList = new LinkedList(1); // ১ মান সহ একটি নতুন লিঙ্কেড লিস্ট তৈরি করা
myLinkedList.push(2); // ২ মান যুক্ত করা
myLinkedList.push(3); // ৩ মান যুক্ত করা

console.log(myLinkedList.reverse()); // এটি উল্টানো তালিকা ফেরত দেবে

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

class LinkedList {
    constructor(value) {
        const newNode = new Node(value);
        this.head = newNode;
        this.tail = this.head;
        this.length = 1;
    }

    printList() {
        let temp = this.head;
        while (temp !== null) {
            console.log(temp.value);
            temp = temp.next;
        }
    }

    getHead() {
        if (this.head === null) {
            console.log("Head: null");
        } else {
            console.log("Head: " + this.head.value);
        }
    }

    getTail() {
        if (this.tail === null) {
            console.log("Tail: null");
        } else {
            console.log("Tail: " + this.tail.value);
        }
    }

    getLength() {
        console.log("Length: " + this.length);
    }

    makeEmpty() {
        this.head = null;
        this.tail = null;
        this.length = 0;
    }

    push(value) {
        const newNode = new Node(value);
        if (!this.head) {
            this.head = newNode;
            this.tail = newNode;
        } else {
            this.tail.next = newNode;
            this.tail = newNode;
        }
        this.length++;
        return this;
    }

    pop() {
        if (this.length === 0) return undefined;
        let temp = this.head;
        let pre = this.head;
        while (temp.next) {
            pre = temp;
            temp = temp.next;
        }
        this.tail = pre;
        this.tail.next = null;
        this.length--;
        if (this.length === 0) {
            this.head = null;
            this.tail = null;
        }
        return temp;
    }

    unshift(value) {
        const newNode = new Node(value);
        if (!this.head) {
            this.head = newNode;
            this.tail = newNode;
        } else {
            newNode.next = this.head;
            this.head = newNode;
        }
        this.length++;
        return this;
    }

    shift() {
        if (this.length === 0) return undefined;
        let temp = this.head;
        this.head = this.head.next;
        this.length--;
        if (this.length === 0) {
            this.tail = null;
        }
        temp.next = null;
        return temp;
    }

    get(index) {
        if (index < 0 || index >= this.length) return undefined;
        let temp = this.head;
        for (let i = 0; i < index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    set(index, value) {
        let temp = this.get(index);
        if (temp) {
            temp.value = value;
            return true;
        }
        return false;
    }

    insert(index, value) {
        if (index < 0 || index > this.length) return false;
        if (index === this.length) return this.push(value);
        if (index === 0) return this.unshift(value);

        const newNode = new Node(value);
        const temp = this.get(index - 1);
        newNode.next = temp.next;
        temp.next = newNode;
        this.length++;
        return true;
    }

    remove(index) {
        if (index < 0 || index >= this.length) return undefined;
        if (index === 0) return this.shift();
        if (index === this.length - 1) return this.pop();

        const before = this.get(index - 1);
        const temp = before.next;

        before.next = temp.next;
        temp.next = null;
        this.length--;
        return temp;
    }

    reverse() {
        let temp = this.head;
        this.head = this.tail;
        this.tail = temp;
        let next = temp.next;
        let prev = null;
        for (let i = 0; i < this.length; i++) {
            next = temp.next;
            temp.next = prev;
            prev = temp;
            temp = next;
        }
    }  

}


function test() {
    let myLinkedList = new LinkedList(1);
    myLinkedList.push(2);
    myLinkedList.push(3);
    myLinkedList.push(4);

    console.log("LL before reverse():");
    myLinkedList.printList();

    myLinkedList.reverse();

    console.log("\nLL after reverse():");
    myLinkedList.printList();
}


test();