### Front view woman wearing trucker hat.

Through a wide variety of **mobile applications**

**Client**Nusrat Nill**Date**25 June 2021

Xinrui's personal website that shares my work and thoughts

Lorem ipsum, dolor sit amet consectetur

Visit my portfolio & Hire me
## About Me

Lorem ipsum dolor sit amet, consectetur adipisicing elit. Eum in eos saepe ipsa cupiditate accusantium voluptatibus quidem nam, reprehenderit, et necessitatibus adipisci labore sit veritatis vero tempore sequi at sed facere dolore. Quae obcaecati eius quasi doloribus illum minus fugit.

Lorem ipsum dolor sit amet, consectetur adipisicing elit. Eum in eos saepe ipsa cupiditate accusantium voluptatibus quidem nam, reprehenderit,

Visit my portfolio and keep your feedback
## My Portfolio

Through a wide variety of **mobile applications**

**Client**Nusrat Nill**Date**25 June 2021

A strategy is a general plan to achieve one or more long-term.

- The Design Approach
- Project Challenge
- The Solution

UI/UX Design, Art Direction, A *design* is a plan or specification for art.

- Project Challenge
- The Design Approach
- The Solution

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Quis ipsum suspendisse ultrices gravida. Risus commod viverra maecenas accumsan lacus vel facilisis. ut labore et dolore magna aliqua.

However, if you can precisely spot such toxic stocks, you may gain by resorting to an investing strategy called short selling. This strategy allows one to sell a stock first and then buy it when the price falls.

While short selling excels in bear markets, it typically loses money in bull markets.

So, just like identifying stocks with growth potential, pinpointing toxic stocks and offloading them at the right time is crucial to guard one’s portfolio from big losses or make profits by short selling them. Heska Corporation HSKA, Tandem Diabetes Care, Inc. TNDM, Credit Suisse Group CS,Zalando SE ZLNDY and Las Vegas Sands LVS are a few such toxic stocks.Screening Criteria

Through a wide variety of **mobile applications**, we’ve developed a unique visual system and strategy that can be applied across the spectrum of available applications.

A strategy is a general plan to achieve one or more long-term.

- The Design Approach
- Project Challenge
- The Solution

UI/UX Design, Art Direction, A *design* is a plan or specification for art.

- Project Challenge
- The Design Approach
- The Solution

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Quis ipsum suspendisse ultrices gravida. Risus commod viverra maecenas accumsan lacus vel facilisis. ut labore et dolore magna aliqua.

There are always some stocks, which illusively scale lofty heights in a given time period. However, the good show doesn’t last for these overblown toxic stocks as their current price is not justified by their fundamental strength.

Toxic companies are usually characterized by huge debt loads and are vulnerable to external shocks. Accurately identifying such bloated stocks and getting rid of them at the right time can protect your portfolio.

Overpricing of these toxic stocks can be attributed to either an irrational enthusiasm surrounding them or some serious fundamental drawbacks. If you own such bubble stocks for an inordinate period of time, you are bound to see a massive erosion of wealth.

However, if you can precisely spot such toxic stocks, you may gain by resorting to an investing strategy called short selling. This strategy allows one to sell a stock first and then buy it when the price falls.

While short selling excels in bear markets, it typically loses money in bull markets.

So, just like identifying stocks with growth potential, pinpointing toxic stocks and offloading them at the right time is crucial to guard one’s portfolio from big losses or make profits by short selling them. Heska Corporation HSKA, Tandem Diabetes Care, Inc. TNDM, Credit Suisse Group CS,Zalando SE ZLNDY and Las Vegas Sands LVS are a few such toxic stocks.Screening Criteria

Through a wide variety of **mobile applications**, we’ve developed a unique visual system and strategy that can be applied across the spectrum of available applications.

So, just like identifying stocks with growth potential, pinpointing toxic stocks and offloading them at the right time is crucial to guard one’s portfolio from big losses or make profits by short selling them.

Heska Corporation HSKA, Tandem Diabetes Care, Inc. TNDM, Credit Suisse Group CS,Zalando SE ZLNDY and Las Vegas Sands LVS are a few such toxic stocks.Screening Criteria

Through a wide variety of **mobile applications**, we’ve developed a unique visual system and strategy that can be applied across the spectrum of available applications.

A strategy is a general plan to achieve one or more long-term.

- The Design Approach
- Project Challenge
- The Solution

UI/UX Design, Art Direction, A *design* is a plan or specification for art.

- Project Challenge
- The Design Approach
- The Solution

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Quis ipsum suspendisse ultrices gravida. Risus commod viverra maecenas accumsan lacus vel facilisis. ut labore et dolore magna aliqua.

There are always some stocks, which illusively scale lofty heights in a given time period. However, the good show doesn’t last for these overblown toxic stocks as their current price is not justified by their fundamental strength.

Toxic companies are usually characterized by huge debt loads and are vulnerable to external shocks. Accurately identifying such bloated stocks and getting rid of them at the right time can protect your portfolio.

Overpricing of these toxic stocks can be attributed to either an irrational enthusiasm surrounding them or some serious fundamental drawbacks. If you own such bubble stocks for an inordinate period of time, you are bound to see a massive erosion of wealth.

However, if you can precisely spot such toxic stocks, you may gain by resorting to an investing strategy called short selling. This strategy allows one to sell a stock first and then buy it when the price falls.

While short selling excels in bear markets, it typically loses money in bull markets.

**mobile applications**, we’ve developed a unique visual system and strategy that can be applied across the spectrum of available applications.

A strategy is a general plan to achieve one or more long-term.

- The Design Approach
- Project Challenge
- The Solution

UI/UX Design, Art Direction, A *design* is a plan or specification for art.

- Project Challenge
- The Design Approach
- The Solution

There are always some stocks, which illusively scale lofty heights in a given time period. However, the good show doesn’t last for these overblown toxic stocks as their current price is not justified by their fundamental strength.

Toxic companies are usually characterized by huge debt loads and are vulnerable to external shocks. Accurately identifying such bloated stocks and getting rid of them at the right time can protect your portfolio.

Overpricing of these toxic stocks can be attributed to either an irrational enthusiasm surrounding them or some serious fundamental drawbacks. If you own such bubble stocks for an inordinate period of time, you are bound to see a massive erosion of wealth.

While short selling excels in bear markets, it typically loses money in bull markets.

**mobile applications**, we’ve developed a unique visual system and strategy that can be applied across the spectrum of available applications.

A strategy is a general plan to achieve one or more long-term.

- The Design Approach
- Project Challenge
- The Solution

UI/UX Design, Art Direction, A *design* is a plan or specification for art.

- Project Challenge
- The Design Approach
- The Solution

While short selling excels in bear markets, it typically loses money in bull markets.

Visit my Client
## Our Trusted Client

What Clients Say
## Testimonial

Rainbow-Themes
### Nevine Acotanza

Chief Operating Officer

Maecenas finibus nec sem ut imperdiet. Ut tincidunt est ac dolor aliquam sodales. Phasellus sed mauris hendrerit, laoreet sem in, lobortis mauris hendrerit ante. Ut tincidunt est ac dolor aliquam sodales phasellus smauris test

Bound - Trolola
### Jone Duone Joe

Operating Officer

Maecenas finibus nec sem ut imperdiet. Ut tincidunt est ac dolor aliquam sodales. Phasellus sed mauris hendrerit, laoreet sem in, lobortis mauris hendrerit ante. Ut tincidunt est ac dolor aliquam sodales phasellus smauris

Glassfisom
### Nevine Dhawan

CEO Of Officer

Maecenas finibus nec sem ut imperdiet. Ut tincidunt est ac dolor aliquam sodales. Phasellus sed mauris hendrerit, laoreet sem in, lobortis mauris hendrerit ante. Ut tincidunt est ac dolor aliquam sodales phasellus smauris

Visit my blog and keep your feedback
## My Blog

You are given a doubly linked list, which contains nodes that have a next pointer, a previous pointer, and an additional **child pointer**. This child pointer may or may not point to a separate doubly linked list, also containing these special nodes. These child lists may have one or more children of their own, and so on, to produce a **multilevel data structure** as shown in the example below.

Given the `head`

of the first level of the list, **flatten** the list so that all the nodes appear in a single-level, doubly linked list. Let `curr`

be a node with a child list. The nodes in the child list should appear **after** `curr`

and **before** `curr.next`

in the flattened list.

Return *the *`head`

* of the flattened list. The nodes in the list must have all of their child pointers set to *

`null`

.

**Example 1:**

Input:head = [1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]Output:[1,2,3,7,8,11,12,9,10,4,5,6]Explanation:The multilevel linked list in the input is shown. After flattening the multilevel linked list it becomes:

**Example 2:**

Input:head = [1,2,null,3]Output:[1,3,2]Explanation:The multilevel linked list in the input is shown. After flattening the multilevel linked list it becomes:

**Example 3:**

Input:head = []Output:[]Explanation:There could be empty list in the input.

**Constraints:**

- The number of Nodes will not exceed
`1000`

. `1 <= Node.val <= 10`

^{5}

**How the multilevel linked list is represented in test cases:**

We use the multilevel linked list from **Example 1** above:

1---2---3---4---5---6--NULL | 7---8---9---10--NULL | 11--12--NULL

The serialization of each level is as follows:

[1,2,3,4,5,6,null] [7,8,9,10,null] [11,12,null]

To serialize all levels together, we will add nulls in each level to signify no node connects to the upper node of the previous level. The serialization becomes:

[1, 2, 3, 4, 5, 6, null] | [null, null, 7, 8, 9, 10, null] | [ null, 11, 12, null]

Merging the serialization of each level and removing trailing nulls we obtain:

[1,2,3,4,5,6,null,null,null,7,8,9,10,null,null,11,12]

The goal is to flatten a multilevel doubly linked list. Each node has `next`

, `prev`

, and `child`

pointers. The `child`

pointer points to another doubly linked list, which might have its own `child`

pointers. We need to flatten this structure into a single-level doubly linked list.

- Traverse the linked list using a pointer
`current`

. - Whenever we encounter a node with a
`child`

, we need to:- Temporarily store the
`next`

node. - Flatten the
`child`

list recursively. - Insert the flattened
`child`

list between the current node and the next node. - Update all the necessary pointers (
`next`

and`prev`

). - Ensure the
`child`

pointer is set to`null`

.

- Temporarily store the
- Continue this process until the entire list is flattened.

Code with Detailed Comments

```
var flatten = function(head) {
if (head === null) return null;
// Start traversing from the head node
let current = head;
// Traverse the entire linked list
while (current !== null) {
// If the current node has a child, we need to flatten it
if (current.child !== null) {
// Store the next node temporarily
let next = current.next;
// Recursively flatten the child list
let child = flatten(current.child);
// Insert the flattened child list
current.next = child;
child.prev = current;
// Find the tail of the flattened child list
while (child.next !== null) {
child = child.next;
}
// Connect the tail of the flattened child list to the next node
if (next !== null) {
next.prev = child;
}
child.next = next;
// Remove the child pointer
current.child = null;
}
// Move to the next node
current = current.next;
}
return head;
};
```

**Initialization**:- Check if
`head`

is`null`

. If it is, return`null`

immediately. - Initialize
`current`

to start from the`head`

node.

- Check if
**Traversal**:- Use a
`while`

loop to traverse the entire linked list.

- Use a
**Handling the**:`child`

- If
`current`

has a`child`

, perform the following steps:- Temporarily store the
`next`

node (`current.next`

). - Recursively flatten the
`child`

list by calling`flatten(current.child)`

. - Insert the flattened
`child`

list between the`current`

node and the`next`

node:- Set
`current.next`

to the head of the flattened`child`

list. - Update the
`prev`

pointer of the flattened`child`

list head to point to`current`

.

- Set
- Find the tail of the flattened
`child`

list by iterating through it until`child.next`

is`null`

. - Connect the tail of the flattened
`child`

list to the`next`

node:- Set
`next.prev`

to the tail of the flattened`child`

list (if`next`

is not`null`

). - Set the
`next`

pointer of the tail of the flattened`child`

list to`next`

.

- Set
- Set
`current.child`

to`null`

as it is now flattened and integrated into the main list.

- Temporarily store the

- If
**Continue Traversal**:- Move
`current`

to the next node (`current.next`

) and repeat the process until the end of the list is reached.

- Move

**Time Complexity**: O(n), where n is the total number of nodes in the list. Each node is processed once, and the child lists are flattened and inserted in linear time.**Space Complexity**: O(d), where d is the maximum depth of the multilevel list. This space is used by the recursion stack due to the depth-first search approach.

This approach ensures that all pointers are correctly updated, maintaining the doubly linked structure while flattening the multilevel list into a single-level list.

Design your implementation of the linked list. You can choose to use a singly or doubly linked list.

A node in a singly linked list should have two attributes: `val`

and `next`

. `val`

is the value of the current node, and `next`

is a pointer/reference to the next node.

If you want to use the doubly linked list, you will need one more attribute `prev`

to indicate the previous node in the linked list. Assume all nodes in the linked list are **0-indexed**.

Implement the `MyLinkedList`

class:

`MyLinkedList()`

Initializes the`MyLinkedList`

object.`int get(int index)`

Get the value of the`index`

node in the linked list. If the index is invalid, return^{th}`-1`

.`void addAtHead(int val)`

Add a node of value`val`

before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.`void addAtTail(int val)`

Append a node of value`val`

as the last element of the linked list.`void addAtIndex(int index, int val)`

Add a node of value`val`

before the`index`

node in the linked list. If^{th}`index`

equals the length of the linked list, the node will be appended to the end of the linked list. If`index`

is greater than the length, the node**will not be inserted**.`void deleteAtIndex(int index)`

Delete the`index`

node in the linked list, if the index is valid.^{th}

**Example 1:**

Input["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"] [[], [1], [3], [1, 2], [1], [1], [1]]Output[null, null, null, null, 2, null, 3]ExplanationMyLinkedList myLinkedList = new MyLinkedList(); myLinkedList.addAtHead(1); myLinkedList.addAtTail(3); myLinkedList.addAtIndex(1, 2); // linked list becomes 1->2->3 myLinkedList.get(1); // return 2 myLinkedList.deleteAtIndex(1); // now the linked list is 1->3 myLinkedList.get(1); // return 3

**Constraints:**

`0 <= index, val <= 1000`

- Please do not use the built-in LinkedList library.
- At most
`2000`

calls will be made to`get`

,`addAtHead`

,`addAtTail`

,`addAtIndex`

and`deleteAtIndex`

.

In computer science, linked lists are a fundamental data structure, and a doubly linked list is a variation that allows traversal in both directions—forward and backward. Each node in a doubly linked list contains a reference to both the next and the previous node, providing flexibility and efficiency for operations that require frequent access to both ends of the list.

In this task, the goal is to implement a doubly linked list with basic functionalities such as:

- Retrieving the value of the node at a specific index.
- Inserting a node at the beginning of the list.
- Inserting a node at the end of the list.
- Inserting a new node at a specified position in the list.
- Deleting a node at a specified index.

**1. Initialization**

We start by defining a `Node`

class, which will have three properties: `val`

(the value stored in the node), `next`

(a reference to the next node), and `prev`

(a reference to the previous node). We also define a `MyLinkedList`

class to manage these nodes, including properties for the `head`

(the first node), `tail`

(the last node), and `size`

(the length of the list).

```
class Node {
val: number;
next: Node | null;
prev: Node | null;
constructor(val: number) {
this.val = val;
this.next = null;
this.prev = null;
}
}
```

**2. Retrieving a Node Value**

The `get`

method straightforwardly traverses the list from the `head`

to the desired `index`

. It’s important to handle invalid indices by returning -1 if the index is out of bounds.

```
get(index: number): number {
if (index < 0 || index >= this.size) return -1;
let current = this.head;
for (let i = 0; i < index; i++) {
current = current.next;
}
return current.val;
}
```

**3. Adding a Node at the Head**

When adding at the head, we create a new node and adjust the `head`

pointer to point to this new node. If the list is not empty, we also need to update the previous head’s `prev`

to reference the new node. If the list is empty, the new node also becomes the `tail`

.

```
addAtHead(val: number): void {
const newNode = new Node(val);
if (this.size === 0) {
this.head = newNode;
this.tail = newNode;
} else {
newNode.next = this.head;
this.head.prev = newNode;
this.head = newNode;
}
this.size++;
}
```

**4. Adding a Node at the Tail**

Adding at the tail involves creating a new node and adjusting the `tail`

pointer. The new node’s `prev`

points to the current `tail`

, and if the list is empty, the new node will serve as both the `head`

and `tail`

.

```
addAtTail(val: number): void {
const newNode = new Node(val);
if (this.size === 0) {
this.head = newNode;
this.tail = newNode;
} else {
this.tail.next = newNode;
newNode.prev = this.tail;
this.tail = newNode;
}
this.size++;
}
```

**5. Inserting a Node at a Specified Position**

This operation is more complex, as it involves handling several cases:

- Inserting at index 0, which is equivalent to
`addAtHead`

. - Inserting at index
`size`

, equivalent to`addAtTail`

. - For other positions, find the node before the desired position and insert the new node accordingly.

```
addAtIndex(index: number, val: number): void {
if (index < 0 || index > this.size) return;
if (index == 0) {
this.addAtHead(val);
} else if (index == this.size) {
this.addAtTail(val);
} else {
let prev = this.head;
for (let i = 0; i < index - 1; i++) {
prev = prev.next;
}
const newNode = new Node(val);
newNode.next = prev.next;
newNode.prev = prev;
if (prev.next) {
prev.next.prev = newNode;
}
prev.next = newNode;
this.size++;
}
}
```

**6. Deleting a Node at a Specified Position**

Deletion requires careful pointer adjustments. Special attention is needed when deleting the head or tail node to update the `head`

and `tail`

pointers accordingly.

```
deleteAtIndex(index: number): void {
if (index < 0 || index >= this.size) return;
if (index === 0) {
this.head = this.head.next;
if (this.head) {
this.head.prev = null;
} else {
this.tail = null; // list became empty
}
} else {
let prev = this.head;
for (let i = 0; i < index - 1; i++) {
prev = prev.next;
}
const toDelete = prev.next;
prev.next = toDelete.next;
if (prev.next) {
prev.next.prev = prev;
} else {
this.tail = prev; // deleting the last node
}
}
this.size--;
}
```

This analysis not only illustrates how to implement each fundamental operation of a doubly linked list but also discusses handling edge cases and special conditions. Understanding these operations is key to mastering the linked list data structure. Hopefully, this breakdown will help you gain a deeper understanding of the implementation and application of doubly linked lists.

在计算机科学中，链表是一种常用的数据结构，双向链表是链表的一种变形，其中每个节点除了有指向下一个节点的指针`next`

外，还包含一个指向上一个节点的指针`prev`

。这种结构提供了向前和向后两种遍历方式，使得某些操作更为高效。

在这个题目中，需要实现一个双向链表，包括以下基本操作：

- 获取链表中第
`index`

个节点的值。 - 在链表头部插入一个节点。
- 在链表尾部插入一个节点。
- 在链表中的第
`index`

个位置插入一个新节点。 - 删除链表中的第
`index`

个节点。

**1. 初始化**

首先，我们需要一个`Node`

类来定义节点，包括`val`

（节点存储的值），`next`

（指向下一个节点的引用）和`prev`

（指向上一个节点的引用）。其次，定义`MyLinkedList`

类来管理这些节点，包括`head`

（头节点），`tail`

（尾节点），以及`size`

（链表长度）。

```
class Node {
val: number;
next: Node | null;
prev: Node | null;
constructor(val: number) {
this.val = val;
this.next = null;
this.prev = null;
}
}
```

**2. 获取节点值**

获取节点值的操作相对直接，从`head`

开始，遍历链表直到到达指定的`index`

位置。需要注意的是，如果`index`

无效（即超出链表范围），则返回-1。

```
get(index: number): number {
if (index < 0 || index >= this.size) return -1;
let current = this.head;
for (let i = 0; i < index; i++) {
current = current.next;
}
return current.val;
}
```

**3. 添加节点到头部**

在头部添加节点时，需要创建一个新节点，并将其`next`

指针指向当前的`head`

。同时，如果链表本身不为空，更新原有头节点的`prev`

指向新节点。如果链表为空，则同时更新`tail`

。

```
addAtHead(val: number): void {
const newNode = new Node(val);
if (this.size === 0) {
this.head = newNode;
this.tail = newNode;
} else {
newNode.next = this.head;
this.head.prev = newNode;
this.head = newNode;
}
this.size++;
}
```

**4. 添加节点到尾部**

尾部添加类似于头部添加，但是新节点的`prev`

将指向当前的`tail`

，并更新`tail`

的`next`

。

```
addAtTail(val: number): void {
const newNode = new Node(val);
if (this.size === 0) {
this.head = newNode;
this.tail = newNode;
} else {
this.tail.next = newNode;
newNode.prev = this.tail;
this.tail = newNode;
}
this.size++;
}
```

**5. 在指定位置添加节点**

这是一个稍微复杂的操作，需要分多种情况处理：

- 如果
`index`

等于0，相当于`addAtHead`

。 - 如果
`index`

等于`size`

，相当于`addAtTail`

。 - 其他情况，需要找到第
`index-1`

个节点，然后在其后插入新节点。

```
addAtIndex(index: number, val: number): void {
if (index < 0 || index > this.size) return;
if (index === 0) {
this.addAtHead(val);
} else if (index === this.size) {
this.addAtTail(val);
} else {
let prev = this.head;
for (let i = 0; i < index - 1; i++) {
prev = prev.next;
}
const newNode = new Node(val);
newNode.next = prev.next;
newNode.prev = prev;
prev.next.prev = newNode;
prev.next = newNode;
this.size++;
}
}
```

**6. 删除指定位置的节点**

删除操作需要更新`prev`

和`next`

指针。特别要注意当删除的是头节点或尾节点时，还需要更新`head`

或`tail`

。

```
deleteAtIndex(index: number): void {
if (index < 0 || index >= this.size) return;
if (index === 0) {
this.head = this.head.next;
if (this.size === 1) {
this.tail = null;
} else {
this.head.prev = null;
}
} else {
let prev = this.head;
for (let i = 0; i < index - 1; i++) {
prev = prev.next;
}
const toDelete = prev.next;
prev.next = toDelete.next;
if (prev.next) {
prev.next.prev = prev;
} else {
this.tail = prev;
}
}
this.size--;
}
```

通过逐步解析每个操作，我们不仅展示了如何实现双向链表的各个基本功能，还深入讨论了边界情况和特殊情况的处理。理解这些基本操作是掌握链表数据结构的关键。希望这篇分析可以帮助你更好地理解双向链表的实现和应用。

Full Code, this code can also be used at Leetcode 707. Design Linked List

```
class Node {
val: number;
next: Node;
prev: Node;
constructor(val: number) {
this.val = val;
this.prev = null;
this.next = null;
}
}
class MyLinkedList {
size: number;
head: Node;
tail: Node;
constructor() {
this.head = null;
this.tail = null;
this.size = 0;
}
get(index: number): number {
if (index < 0 || index >= this.size ) return -1;
let curr = this.head;
while (index > 0) {
curr = curr.next;
index--;
}
return curr.val;
}
addAtHead(val: number): void {
let newHead = new Node(val);
if (this.size === 0) {
this.head = newHead;
this.tail = newHead;
} else {
this.head.prev = newHead;
newHead.next = this.head;
this.head = newHead;
}
this.size++;
}
addAtTail(val: number): void {
let newTail = new Node(val);
if (this.size === 0) {
this.head = newTail;
this.tail = newTail;
} else {
this.tail.next = newTail;
newTail.prev = this.tail;
this.tail = newTail;
}
this.size++;
}
addAtIndex(index: number, val: number): void {
if (index < 0 || index > this.size) return;
if (index === 0) {
this.addAtHead(val);
} else if (index === this.size) {
this.addAtTail(val);
} else {
let newNode = new Node(val);
let prev = this.head;
while (index - 1 > 0) {
prev = prev.next;
index--;
}
newNode.prev = prev;
newNode.next = prev.next;
prev.next.prev = newNode;
prev.next = newNode;
this.size++;
}
}
deleteAtIndex(index: number): void {
if (index < 0 || index >= this.size) return;
if (index === 0) {
this.head = this.head.next;
if (this.size === 1) {
this.tail = null;
}
this.size--;
} else {
let prev = this.head;
while (index - 1 > 0) {
prev = prev.next;
index--;
}
prev.next = prev.next.next;
if (prev.next) { // tail 不变
prev.next.prev = prev;
} else {
this.tail = prev;
}
this.size--;
}
}
}
/**
* Your MyLinkedList object will be instantiated and called as such:
* var obj = new MyLinkedList()
* var param_1 = obj.get(index)
* obj.addAtHead(val)
* obj.addAtTail(val)
* obj.addAtIndex(index,val)
* obj.deleteAtIndex(index)
*/
```

In the vast expanse of data structures available to developers, the LinkedList holds a unique place. Known for its efficiency in insertion and deletion operations, it’s a staple in algorithm design and application development. This post explores how to implement a LinkedList in TypeScript, bringing together the efficiency of this data structure with the strong typing and object-oriented features of TypeScript.

Before diving into the code, let’s grasp the basics of a LinkedList. At its core, a LinkedList is a collection of nodes, where each node contains data and a reference (or a pointer) to the next node in the sequence. This structure allows for efficient additions and deletions as it avoids the necessity of reindexing elements, a common performance bottleneck in array manipulations.

The foundation of our LinkedList is the node. Each node will store a value and a pointer to the next node. Here’s how we define it in TypeScript:

```
class Node {
val: number;
next: Node | null;
constructor(val: number) {
this.val = val; // The value stored in the node
this.next = null; // Pointer to the next node, initially null
}
}
```

This `Node`

class is straightforward: it initializes with a value and sets the pointer to the next node as null.

With our nodes defined, we next construct the LinkedList class, `MyLinkedList`

. This class will manage our nodes and provide methods to interact with the list.

```
class MyLinkedList {
head: Node | null;
tail: Node | null;
size: number;
constructor() {
this.head = null;
this.tail = null;
this.size = 0;
}
}
```

Our LinkedList starts empty, signified by a `null`

head and tail, with a size of 0.

We provide three methods to add elements to our list: at the head, at the tail, and at a specific index.

**addAtHead(val: number):**Inserts a new node with the provided value at the beginning of the list.**addAtTail(val: number):**Appends a new node with the provided value at the end of the list.**addAtIndex(index: number, val: number):**Inserts a new node at the specified index.

Each method updates the `head`

, `tail`

, and `size`

properties accordingly to maintain the integrity of the list.

**get(index: number):**Returns the value of the node at the specified index.**deleteAtIndex(index: number):**Removes the node at the specified index.

These methods ensure our LinkedList is dynamic, allowing retrieval and modification post-initialization.

Implementing a LinkedList in TypeScript is a rewarding exercise that deepens our understanding of both TypeScript and fundamental data structures. This guide has walked you through creating a flexible, type-safe LinkedList, suitable for various applications requiring efficient insertions and deletions. Whether you’re building a complex application or brushing up on data structures, the combination of TypeScript and LinkedLists is a powerful tool in your development arsenal.

Now that you’ve implemented a basic LinkedList, consider extending its functionality. Try adding methods to reverse the list, detect cycles, or merge two sorted lists. Each addition will not only improve your understanding of LinkedLists but also enhance your problem-solving skills in TypeScript.

```
class Node {
val: number;
next: Node | null;
constructor(val: number) {
this.val = val; // The value stored in the node
this.next = null; // Pointer to the next node, initially null
}
}
class MyLinkedList {
head: Node | null;
tail: Node | null; // Pointer to the last node
size: number; // The number of nodes in the list
constructor() {
this.head = null; // Initialize the head to null for an empty list
this.tail = null; // Likewise for the tail
this.size = 0; // Start with a list size of 0
}
// Adds a node at the front of the list
addAtHead(val: number): void {
const newNode = new Node(val);
newNode.next = this.head;
this.head = newNode;
if (this.size === 0) {
this.tail = newNode; // If the list was empty, this new node is also the tail
}
this.size++;
}
// Adds a node at the end of the list
addAtTail(val: number): void {
const newNode = new Node(val);
if (this.size === 0) {
this.head = newNode;
this.tail = newNode;
} else {
this.tail.next = newNode;
this.tail = newNode;
}
this.size++;
}
// Adds a node at the specified index
addAtIndex(index: number, val: number): void {
if (index < 0 || index > this.size) return; // Check for valid index
if (index === 0) {
this.addAtHead(val);
return;
}
if (index === this.size) {
this.addAtTail(val);
return;
}
const newNode = new Node(val);
let current = this.head;
for (let i = 0; i < index - 1; i++) { // Iterate to the node before the desired index
current = current.next;
}
newNode.next = current.next;
current.next = newNode;
this.size++;
}
// Gets the value of the node at the specified index
get(index: number): number {
if (index < 0 || index >= this.size) return -1; // Check for valid index
let current = this.head;
for (let i = 0; i < index; i++) {
current = current.next;
}
return current.val;
}
// Deletes the node at the specified index
deleteAtIndex(index: number): void {
if (index < 0 || index >= this.size) return; // Check for valid index
if (index === 0) {
this.head = this.head.next;
if (index === this.size - 1) { // If there was only one node, update tail to null
this.tail = null;
}
} else {
let current = this.head;
for (let i = 0; i < index - 1; i++) {
current = current.next;
}
current.next = current.next.next;
if (index === this.size - 1) { // If deleting the last node, update tail
this.tail = current;
}
}
this.size--;
}
}
```

Also this one can let you pass the Leetcode question: 707. Design Linked List

这个博客讲的就是TypeScript的单链表的实现方法啦，可以看看 抄抄，这个能让你直接通过Leetcode的第707题

Contact
## Contact With Me

I am available for freelance work. Connect with me via and call in to my account.

Phone: +01234567890 Email: admin@example.com