zoukankan      html  css  js  c++  java
  • [TS] Implement a doubly linked list in TypeScript

    In a doubly linked list each node in the list stores the contents of the node and a pointer or reference to the next and the previous nodes in the list. It is one of the simplest way to store a collection of items.

    In this lesson we cover how to create a doubly linked list data structure and how to use its strengths to implement an O(1) FIFO queue + O(1) LIFO stack. We also demonstrate why one would use it over a singly linked list. We also cover how to approach authoring such data structures.

     The reason for use double linked list is that we can do LIFO opreation in O(1), in Single linked List, it requires O(n), because you need to go thought from the head, in order to know what will be the next tail item for new linked list. 

    /**
     * Linked list node
     */
    export interface DoublyLinkedListNode<T> {
      value: T
      next?: DoublyLinkedListNode<T>
      prev?: DoublyLinkedListNode<T>
    }
    
    /**
     * Linked list for items of type T
     */
    export class DoublyLinkedList<T> {
      public head?: DoublyLinkedListNode<T> = undefined;
      public tail?: DoublyLinkedListNode<T> = undefined;
    
      /**
       * Adds an item in O(1)
       **/
      add(value: T) {
        const node: DoublyLinkedListNode<T> = {
          value,
          next: undefined,
          prev: undefined,
        }
        if (!this.head) {
          this.head = node;
        }
        if (this.tail) {
          this.tail.next = node;
          node.prev = this.tail;
        }
        this.tail = node;
      }
    
      /**
       * FIFO removal in O(1)
       */
      dequeue(): T | undefined {
        if (this.head) {
          const value = this.head.value;
          this.head = this.head.next;
          if (!this.head) {
            this.tail = undefined;
          }
          else {
            this.head.prev = undefined;
          }
          return value;
        }
      }
    
      /**
       * LIFO removal in O(1)
       */
      pop(): T | undefined {
        if (this.tail) {
          const value = this.tail.value;
          this.tail = this.tail.prev;
          if (!this.tail) {
            this.head = undefined;
          }
          else {
            this.tail.next = undefined;
          }
          return value;
        }
      }
    
      /**
       * Returns an iterator over the values
       */
      *values() {
        let current = this.head;
        while (current) {
          yield current.value;
          current = current.next;
        }
      }
    }
    import { DoublyLinkedList } from './doublyLinkedList';
    
    test('basic', () => {
      const list = new DoublyLinkedList<number>();
      list.add(1);
      list.add(10);
      list.add(5);
      expect(Array.from(list.values())).toMatchObject([1, 10, 5]);
      expect(list.dequeue()).toBe(1);
      expect(Array.from(list.values())).toMatchObject([10, 5]);
      expect(list.dequeue()).toBe(10);
      expect(list.dequeue()).toBe(5);
      expect(list.dequeue()).toBe(undefined);
      expect(Array.from(list.values())).toMatchObject([]);
      list.add(5);
      list.add(10);
      list.add(1);
      expect(Array.from(list.values())).toMatchObject([5, 10, 1]);
      expect(list.pop()).toBe(1);
      expect(list.dequeue()).toBe(5);
      expect(list.pop()).toBe(10);
      expect(list.pop()).toBe(undefined);
      expect(list.dequeue()).toBe(undefined);
      expect(Array.from(list.values())).toMatchObject([]);
    });
  • 相关阅读:
    java实现动态上传多个文件并解决文件重名问题
    MySQL存储过程之事务管理
    Java IO--字符流--InputStreamReader 和 OutputStreamWriter
    Java IO--字符流--BufferedReader和BufferedWriter
    java线程同步小结
    进程和线程的区别与联系
    java中“==”和equals方法的区别,再加上特殊的String引用类型
    java.util.Date 与 java.sql.Date 之间的转换
    Java Applet 与Servlet之间的通信
    Applet 应用程序进行数字签名,对系统文件进行读写操作
  • 原文地址:https://www.cnblogs.com/Answer1215/p/7623103.html
Copyright © 2011-2022 走看看