Xinrui's personal website that shares my work and thoughts

## Hi, I’m Michael

Web designer and developer working for envato.com in Paris, France.

## My Experience

#### Software Develop.

###### Co-Founder

Microsoft Corporation

#### Web Design.

###### Founder, XYZ IT Company

Reinvetning the way you create websites

#### Teacher and Developer

###### SuperKing LTD

Sr. Software Engineer

## Education

#### BSc in Computer Science

###### University of DVI

New Haven, CT ‧ Private, non-profit

#### AS - Science & Information

###### SuperKing College

Los Angeles, CA 90095, United States

#### Secondary School Education

###### Kingstar Secondary School

New Haven, CT ‧ Private, non-profit

## My Resume

#### Education Quality

#### MS in Computer Science

George Washington University (2012 - 2014)The training provided by universities in order to prepare me to work in various sectors of the computer science area.

#### BS in Computer Science

South-Central Minzu University For Nationalities (2008 - 2012)I get my foundation of CS built here, I learn from the lower level operation system, network, Assembly language to Database, Java and data structure.

#### Job Experience

#### Front End Engineer II

AWS IAM Team, AWS ILT Team, AWS PxT - (2020 - Present)Using React, Redux, React Query, Webpack and TypeScript to build AWS IAM Console, integrate with backend APIs, develop a widget system that can plug and play with other AWS Console.

#### SDE II

Expedia Insurance Team - (2019 - 2020)Re-design the Expedia checkout insurance module experience, re-write the jQuery based module to React widgets.

#### Senior Member of Technical Staff

Oracle Cloud Infrastructure - (2018 - 2019)The India economy has grown strongly over recent years, having transformed itself from a producer and innovation-based economy.

#### Life Skills

###### Scuba Diving

###### Basketball

###### Saltwater fish aquarium

###### Cooking Chinese food

###### Piano

#### Development Skill

###### React

###### NodeJS

###### JAVASCRIPT

###### AWS

###### Java

#### Education Quality

#### MS in Computer Science

George Washington University (2012 - 2014)The training provided by universities in order to prepare me to work in various sectors of the computer science area.

#### BS in Computer Science

South-Central Minzu University For Nationalities (2008 - 2012)I get my foundation of CS built here, I learn from the lower level operation system, network, Assembly language to Database, Java and data structure.

#### Job Experience

#### Front End Engineer II

AWS IAM Team, AWS ILT Team, AWS PxT - (2020 - Present)Using React, Redux, React Query, Webpack and TypeScript to build AWS IAM Console, integrate with backend APIs, develop a widget system that can plug and play with other AWS Console.

#### SDE II

Expedia Insurance Team - (2019 - 2020)Re-design the Expedia checkout insurance module experience, re-write the jQuery based module to React widgets.

#### Senior Member of Technical Staff

Oracle Cloud Infrastructure - (2018 - 2019)The India economy has grown strongly over recent years, having transformed itself from a producer and innovation-based economy.

#### Education Quality

#### MS in Computer Science

George Washington University (2012 - 2014)The training provided by universities in order to prepare me to work in various sectors of the computer science area.

#### BS in Computer Science

South-Central Minzu University For Nationalities (2008 - 2012)I get my foundation of CS built here, I learn from the lower level operation system, network, Assembly language to Database, Java and data structure.

#### Job Experience

#### Front End Engineer II

AWS IAM Team, AWS ILT Team, AWS PxT - (2020 - Present)Using React, Redux, React Query, Webpack and TypeScript to build AWS IAM Console, integrate with backend APIs, develop a widget system that can plug and play with other AWS Console.

#### SDE II

Expedia Insurance Team - (2019 - 2020)Re-design the Expedia checkout insurance module experience, re-write the jQuery based module to React widgets.

#### Senior Member of Technical Staff

Oracle Cloud Infrastructure - (2018 - 2019)The India economy has grown strongly over recent years, having transformed itself from a producer and innovation-based economy.

## My Portfolio

## My Blog

## 430. Flatten a Multilevel Doubly Linked List

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]

### Problem Explanation

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.

### Approach

- 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;
};
```

### Step-by-Step Explanation

**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

### Complexity Analysis

**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.

## TypeScript Data Structure: Implementing a Doubly Linked List

## 用Typescript实现一个双向链表

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`

.

### Analysis of Doubly Linked List Implementation

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.

#### Requirements Analysis

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.

#### Thought Process and Algorithm Implementation

**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--;
}
```

### Conclusion

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)
*/
```

## Typescript Data Structures: Linked List

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.

#### Understanding LinkedLists

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.

#### Implementing Nodes in TypeScript

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.

#### The MyLinkedList Class

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.

##### Constructor and Properties

```
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.

##### Adding Elements

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.

##### Retrieving and Deleting Elements

**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.

#### Conclusion

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.

#### Next Steps

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.

#### Full Code

```
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 With Me

#### Nevine Acotanza

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

Phone: +012 345 678 90 Email: admin@example.com