Merge pull request #314 from jsrdxzw/master

add stack and queue

Author: wangzheng0822

typescript/07_linkedlist/LinkedListAlog.ts

@@ -33,7 +33,7 @@ class LinkedListAlog {
     let slow: SingleNode<T> | null = list
     while (fast && fast.next) {
       fast = fast.next.next
-      slow = slow!!.next
+      slow = slow!.next
       if (fast === slow) return true
     }
     return false
@@ -68,7 +68,7 @@ class LinkedListAlog {
     let slow = list
     while (fast && fast.next) {
       fast = fast.next.next
-      slow = slow.next!!
+      slow = slow.next!
     }
     return slow
   }
@@ -121,7 +121,6 @@ class SingleNode<T> {
   }
 }
 
-
 const node1 = new SingleNode(1)
 node1.next = new SingleNode(3)
 node1.next.next = new SingleNode(5)

typescript/08_stack/StackAndBrowser.ts

@@ -0,0 +1,112 @@
+/**
+ * 基于单向链表实现栈结构
+ */
+export class Stack<T> {
+  private node: LinkedNode<T> | null = null
+  size: number = 0
+
+  public push(value: T) {
+    if (!value) return
+    const newNode = new LinkedNode(value)
+    if (!this.node) {
+      this.node = newNode
+    } else {
+      newNode.next = this.node
+      this.node = newNode
+    }
+    this.size++
+  }
+
+  public pop(): T | null {
+    if (!this.node) {
+      return null
+    }
+    const value = this.node.value
+    this.node = this.node.next
+    this.size--
+    return value
+  }
+}
+
+/**
+ * 单向链表
+ */
+class LinkedNode<T> {
+  value: T
+  next: LinkedNode<T> | null
+
+  constructor(value: T, next: LinkedNode<T> | null = null) {
+    this.value = value
+    this.next = next
+  }
+}
+
+/**
+ * 使用双栈结构实现浏览器的前进后退
+ */
+class Browser<T> {
+  // 存放后退的所有历史url
+  private backStack: Stack<T>
+  // 存放前进的所有url
+  private forwardStack: Stack<T>
+  private current: T
+
+  constructor(current: T) {
+    this.backStack = new Stack<T>()
+    this.forwardStack = new Stack<T>()
+    this.current = current
+  }
+
+  public back(): T | null {
+    if (this.backStack.size > 0) {
+      this.forwardStack.push(this.current)
+      this.current = this.backStack.pop()!
+      return this.getCurrentPage()
+    }
+    return null
+  }
+
+  public forward(): T | null {
+    if (this.forwardStack.size > 0) {
+      this.backStack.push(this.current)
+      this.current = this.forwardStack.pop()!
+      return this.getCurrentPage()
+    }
+    return null
+  }
+
+  /**
+   * 在网页上点击一个链接
+   * @param value
+   */
+  public linkUrl(value: T) {
+    this.current && this.backStack.push(this.current)
+    this.current = value
+  }
+
+  public getCurrentPage(): T {
+    return this.current
+  }
+}
+
+const browser = new Browser('www.baidu.com')
+browser.linkUrl('www.yuanzhoucehui.com')
+browser.linkUrl('www.github.com/jsrdxzw')
+// browser.back()
+// www.github.com/jsrdxzw
+console.log(browser.getCurrentPage())
+browser.back()
+// www.yuanzhucehui.com
+console.log(browser.getCurrentPage())
+browser.back()
+// www.baidu.com
+console.log(browser.getCurrentPage())
+browser.back()
+// www.baidu.com
+console.log(browser.getCurrentPage())
+browser.forward()
+// www.yuanzhucehui.com
+console.log(browser.getCurrentPage())
+browser.forward()
+// www.github.com/jsrdxzw
+console.log(browser.getCurrentPage())

typescript/09_queue/CircularQueue.ts

@@ -0,0 +1,51 @@
+/**
+ * 基于数组的循环队列
+ * 为了方便判断队列为空的情况，这里最好引入元素个数
+ */
+class CircularQueue<T> {
+  private items: T[] = []
+  private readonly n: number = 0
+  private head: number = 0
+  private tail: number = 0
+  // 队列的实际元素大小
+  size: number = 0
+
+
+  constructor(capacity: number) {
+    this.n = capacity
+  }
+
+  public enqueue(item: T): boolean {
+    // 表示队列已经满了
+    if (this.size === this.n) return false
+    this.items[this.tail] = item
+    this.tail = (this.tail + 1) % this.n
+    this.size++
+    return true
+  }
+
+  public dequeue(): T | null {
+    if (!this.size) return null
+    const item = this.items[this.head]
+    this.head = (this.head + 1) % this.n
+    this.size--
+    return item
+  }
+}
+
+const circularQueue = new CircularQueue<number>(3)
+circularQueue.enqueue(1)
+circularQueue.enqueue(2)
+circularQueue.enqueue(3)
+circularQueue.enqueue(4)
+
+const value = circularQueue.dequeue()
+const value1 = circularQueue.dequeue()
+const value2 = circularQueue.dequeue()
+const value3 = circularQueue.dequeue()
+
+// null
+console.log(value3)
+// 0
+console.log(circularQueue.size)
+

typescript/09_queue/README.md

@@ -0,0 +1,12 @@
+### 队列
+
+由于js语言天生就可以使用array数组来实现栈和队列等结构:
+```javascript
+  // 模拟数组队列
+  const queue = []
+  queue.push(1) // 向数组尾部添加数据
+  queue.shift() //数组头部去除数据，并返回
+```
+这里我们使用链表来实现队列结构
+
+队列分为无限队列和循环队列

typescript/09_queue/SimpleQueue.ts

@@ -0,0 +1,62 @@
+/**
+ * 使用链表实现简单队列
+ */
+class SimpleQueue<T> {
+  private head: LinkedNode<T> | null = null
+  private tail: LinkedNode<T> | null = null
+
+  /**
+   * 入队,插入队尾
+   * @param value
+   */
+  public enqueue(value: T) {
+    if (!this.tail) {
+      this.head = this.tail = new LinkedNode<T>(value)
+    } else {
+      const newNode = new LinkedNode<T>(value)
+      this.tail.next = newNode
+      this.tail = newNode
+    }
+  }
+
+  /**
+   * 出队,在队头删除
+   */
+  public dequeue(): T | null {
+    if (!this.head) return null
+    const value = this.head.value
+    this.head = this.head.next
+    return value
+  }
+
+  public printAll(): string {
+    let p = this.head
+    let res = ''
+    while (p) {
+      res = `${res} ${p.value}`
+      p = p.next
+    }
+    return res
+  }
+}
+
+/**
+ * 单向链表
+ */
+class LinkedNode<T> {
+  value: T
+  next: LinkedNode<T> | null
+
+  constructor(value: T, next: LinkedNode<T> | null = null) {
+    this.value = value
+    this.next = next
+  }
+}
+
+const queue = new SimpleQueue()
+queue.enqueue(1)
+queue.enqueue(2)
+queue.enqueue(3)
+queue.dequeue()
+queue.dequeue()
+console.log(queue.printAll())

typescript/10_recursive/climbStairs.ts

@@ -0,0 +1,55 @@
+/**
+ * 递归求解爬楼梯问题
+ */
+
+/**
+ * 最开始版本的递归算法
+ * @param n
+ */
+function fn(n: number): any {
+  if (n === 1) return 1
+  if (n === 2) return 2
+  return fn(n - 1) + fn(n - 2)
+}
+
+const res1 = fn(10)
+// 89
+console.log(res1)
+
+/**
+ * 使用depth结合js的闭包特性实现限制函数调用次数的功能
+ * @param depth 递归的深度
+ */
+function fnWithDepth(depth: number) {
+  return function fn(n: number): any {
+    depth++
+    if (depth > 1000) throw new Error('function stack is too deep!')
+    if (n === 1) return 1
+    if (n === 2) return 2
+    return fn(n - 1) + fn(n - 2)
+  }
+}
+
+const res2 = fnWithDepth(3)(10)
+// 89
+console.log(res2)
+
+/**
+ * 通过map来存储已经计算过的值，避免递归重复计算
+ */
+function fnWithMap() {
+  const map = new Map<number, number>()
+  return function fn(n: number): any {
+    if (n === 1) return 1
+    if (n === 2) return 2
+    if (map.has(n)) {
+      return map.get(n)
+    }
+    const ret = fn(n - 1) + fn(n - 2)
+    map.set(n, ret)
+    return ret
+  }
+}
+
+const res3 = fnWithMap()(10)
+console.log(res3)

typescript/11_sorts/simpleSort.ts

@@ -0,0 +1,75 @@
+/**
+ * 简单的排序，分为冒泡和插入排序
+ * 注意他们都是稳定的排序,并且是原地排序
+ * 一般情况下更推荐使用插入排序，因为它所需要的操作更少
+ * 这里使用简单工厂创建我们的排序算法
+ */
+
+/**
+ * 排序的枚举类型
+ */
+enum SortType {
+  BubbleSort,
+  InsertSort
+}
+
+interface SortAlgo {
+  sort(array: number[]): void
+}
+
+class BubbleSort implements SortAlgo {
+  sort(array: number[]) {
+    for (let i = 0; i < array.length; i++) {
+      let flag = false
+      for (let j = 0; j < array.length; j++) {
+        if (array[j] > array[j + 1]) {
+          const temp = array[j]
+          array[j] = array[j + 1]
+          array[j + 1] = temp
+          flag = true
+        }
+      }
+      if (!flag) {
+        break
+      }
+    }
+  }
+}
+
+class InsertSort implements SortAlgo {
+  sort(array: number[]) {
+    for (let i = 1; i < array.length; i++) {
+      let j = i - 1
+      const temp = array[i]
+      for (; j >= 0; j--) {
+        if (array[j] > array[j + 1]) {
+          array[j + 1] = array[j]
+        } else {
+          // 这个说明之前的已经排好了，没必要继续比较
+          break
+        }
+      }
+      array[j + 1] = temp
+    }
+  }
+}
+
+class SortFactory {
+  static getSortAlgo(type: SortType): SortAlgo {
+    switch (type) {
+      case SortType.BubbleSort:
+        return new BubbleSort()
+      case SortType.InsertSort:
+        return new InsertSort()
+      default:
+        throw new Error('unknown sort algorithm type')
+    }
+  }
+}
+
+const insertSort = SortFactory.getSortAlgo(SortType.InsertSort)
+const test1 = [1, 0, 2, 4, 8, 5, 10]
+insertSort.sort(test1)
+console.log(test1)
+
+