A Software Engineer's Blog

Hi, I’m Xinrui

10 years experiences software engineer focus on Frontend now and working for Amazon AWS in Seattle WA

SDE & FEE

fullstackguy@gmail.com

Seattle WA

Download my resume:

DOWNLOAD RESUME CONTACT ME

Over 10 years of experience

My Experience

June 2020 - Present

Front End Engineer II

Lead Frontend projects in AWS IAM and AWS T&C

Amazon - Seattle, WA

July 2019 - May 2020

SDE II

Build Expedia Insurance Widget

Expedia Group - Seattle, WA

Sep 2018 - Mar 2019

Senior Member of Technical Staff

OCI Console Development

Oracle - Seattle, WA

July 2017 - Sep 2018

Software Engineer / Senior Associate

Built Capital One Investing Tools

Capital One - McLean, VA

Oct 2015 - July 2017

Software Engineer

AOL On Team, built App Generator

AOL - Sterling, VA

June 2014 - Oct 2015

Web Developer

Build AP, SAT tests registration system

College Board - Reston, VA

Master and Bachelor, with a PhD Offer

Education

2012 - 2014

Master of Science in Computer Science

George Washington University

Washington DC

South-Central Minzu University For Nationalities

2008 - 2012

BS - Computer Science

South-Central Minzu University For Nationalities

Hubei Wuhan, China

10+ Years of Experience

My Resume

2008 - 2014

Education Quality

MS in Computer Science

George Washington University (2012 - 2014)

3.90/4

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)

4.75/5

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.

2014 - Present

Job Experience

Front End Engineer II

AWS IAM Team, AWS ILT Team, AWS PxT - (2020 - Present)

SEATTLE

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)

SEATTLE

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)

SEATTLE

The India economy has grown strongly over recent years, having transformed itself from a producer and innovation-based economy.

2014 - Present

Job Projects

App Generator

AOL On Team - (2015 - 2017)

Sterling VA

App Generator is an all-in-one platform designed for businesses or individuals lacking a development team but wishing to create their own video app. It utilizes technologies such as Angular, Java, and Swift to offer a user-friendly interface where users can select their desired video content and target platform. Ultimately, it generates a customizable app tailored to their needs. Additionally, the platform allows for on-the-fly updates to app content and themes, eliminating the need for frequent app version upgrades.

Re-write IAM Console

AWS IAM Team - (2020 - 2021)

Seattle WA

The AWS IAM Console, ranking as the third most trafficked service on the AWS platform, currently operates on an outdated framework that incorporates a blend of technologies like AngularJS 1.6, Backbone, and Ruby, making it challenging to read and maintain. We are embarking on a complete overhaul of the entire IAM console to enhance usability and maintainability. By adopting modern technologies such as React, Redux, TypeScript, React Query, and REST API, we aim to streamline the architecture while preserving the original user experience.

AWS re:Invent - Access Analyzer

AWS IAM Team

Seattle WA

I spearheaded the frontend segment of the re:Invent project titled "Least Privilege Policy Generator." This tool is designed to analyze a policy over a certain period, identify the services accessed, and refine the policy to limit its scope to only necessary permissions. Consequently, it mitigates the risk associated with granting overly broad policies to unintended recipients.

2014 - Present

Personal Projects

Rescue Diver

PADI Certified Rescue Diver

Bonarie & Mexico

I have successfully completed scuba diving training and achieved certifications in various disciplines, including PADI Open Water, Advanced Open Water, Enriched Air Diver, and EFR-Primary Care (CPR) & Secondary Care. Additionally, I am an SSI-certified Freediver.

Web Developer and Instructor

always on the road

USA

I have developed numerous websites, including e-commerce platforms for companies such as Biovive, Reflexgroup, and WolfTech Studio, showcasing this very site as an example of my work. Leveraging my extensive experience, I also mentor individuals aspiring to learn website development. My expertise spans across all web technologies, from historical methods like modifying HTML/CSS for IE6 compatibility, crafting class-like JavaScript structures before the advent of ES6 and TypeScript, to implementing functionalities traditionally handled by modern frameworks like React and Bootstrap using plain JavaScript/CSS. Furthermore, I am skilled in creating responsive designs with pure CSS, alongside other now less commonly discussed techniques.

Game Developer

Personal projects for fun

AT HOME

I Like many others, I enjoy playing video games, which inspired me to learn how to create them myself. I self-taught various game engines, including Phaser, Unity, and Three.js, and have used these tools to develop games such as Flappy Bird and Ping-Pong, among others.

Script Writter

When I need robots do something for me.

Cypress

I write scripts to automate some tasks, mostly using Cypress Integration Test framework.

Visit my blog and keep your feedback

April 13, 2024

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^th node in the linked list. If the index is invalid, return -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^th node in the linked list. If 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^th node in the linked list, if the index is valid.

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]

Explanation
MyLinkedList 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)
 */

April 6, 2024

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题

March 23, 2024

448. Find All Numbers Disappeared in an Array

Given an array nums of n integers where nums[i] is in the range [1, n], return an array of all the integers in the range [1, n] that do not appear in nums.

Example 1:

Input: nums = [4,3,2,7,8,2,3,1]
Output: [5,6]

Example 2:

Input: nums = [1,1]
Output: [2]

Constraints:

n == nums.length
1 <= n <= 10⁵
1 <= nums[i] <= n

Follow up: Could you do it without extra space and in O(n) runtime? You may assume the returned list does not count as extra space.

Problem Analysis: The task is to find all the numbers missing from 1 to n in a given array, which might contain duplicate numbers and should be solved without using extra space (except for the output).

Solution Approach: We can leverage the array itself by marking the presence of numbers. Specifically, we traverse the array and turn the number at the index corresponding to each encountered number into negative as a mark. Since the numbers in the array are all supposed to be between 1 and n, we can directly use the number value as the array index.

Time and Space Complexity Analysis: The time complexity is O(n), as we only need to traverse the array twice. The space complexity is O(1), as no extra space is used apart from the output.

Conclusion: This method effectively utilizes the structure of the array itself to mark the presence of numbers, thereby identifying the missing ones, while avoiding the use of extra space.

题目分析： 这个问题要求我们找出在1到n之间但没有出现在给定数组中的所有数字。数组中可能有重复数字，且没有额外空间使用（除了输出结果之外）。

解题思路： 我们可以利用数组自身，通过标记已存在的数字来找出缺失的数字。具体来说，我们可以遍历数组，并将出现的数字对应位置上的数值变为负数，作为标记。因为数组中的数字都应该在1到n之间，所以可以直接用数字值作为数组索引。

代码实现：

function findDisappearedNumbers(nums: number[]): number[] {
    let res = [];
    for (let num of nums) {
        let index = Math.abs(num) - 1;
        if (nums[index] > 0) {
            nums[index] = -nums[index];
        }
    }
    for (let i = 0; i < nums.length; i++) {
        if (nums[i] > 0) {
            res.push(i + 1);
        }
    }
    return res;
}

时间和空间复杂度分析： 时间复杂度为O(n)，因为我们只需要遍历数组两次。空间复杂度为O(1)，因为除了输出结果外，我们没有使用额外的空间。

测试用例：

console.log(findDisappearedNumbers([4,3,2,7,8,2,3,1])); // 输出 [5,6]

总结： 这个方法有效地利用了数组本身的结构来标记存在的数字，从而找出缺失的数字，同时避免了额外的空间使用。

Contact

Contact With Me

Xinrui Ma

Software Engineer

I am available for freelance work, or you have a great job opportunity. Connect with me via email below. The contact form I would advise you not to use that due to connection issue.

Email: fullstackguy@gmail.com

Hi, I’m Xinrui

My Experience

Front End Engineer II

Lead Frontend projects in AWS IAM and AWS T&C

SDE II

Build Expedia Insurance Widget

Senior Member of Technical Staff

OCI Console Development

Software Engineer / Senior Associate

Built Capital One Investing Tools

Software Engineer

AOL On Team, built App Generator

Web Developer

Build AP, SAT tests registration system

Education

Master of Science in Computer Science

George Washington University

BS - Computer Science

South-Central Minzu University For Nationalities

My Resume

Education Quality

MS in Computer Science

BS in Computer Science

Job Experience

Front End Engineer II

SDE II

Senior Member of Technical Staff

Life Skills

Scuba Diving

Basketball

Saltwater fish aquarium

Cooking Chinese food

Piano

Development Skill

React

NodeJS

JAVASCRIPT

AWS

Java

Job Projects

App Generator

Re-write IAM Console

AWS re:Invent - Access Analyzer

Personal Projects

Rescue Diver

Web Developer and Instructor

Game Developer

Script Writter

TypeScript Data Structure: Implementing a Doubly Linked List

Typescript Data Structures: Linked List

448. Find All Numbers Disappeared in an Array

Contact With Me

Xinrui Ma