jc-structure 0.2.7 → 0.2.9

package/dist/jc-structure.js

@@ -236,7 +236,6 @@ class G {
   count = 0;
   head = null;
   tail = null;
-  // 添加尾指针优化
   constructor(t) {
     t && t.forEach((e) => this.push(e));
   }

package/index.d.ts

@@ -1,296 +1,119 @@
 /// <reference path="./types/index.d.ts" />
 
 declare module "jc-structure" {
-  import * as Types from "./types";
-  export = Types;
-
   //#region  data structure
-  /**
-   * #### 数据结构接口
-   */
-  // interface DataStructure {
-  //   /**
-  //    * 判断数据结构是否为空
-  //    */
-  //   isEmpty(): boolean;
-  //   /**
-  //    * 数据结构元素长度
-  //    */
-  //   size(): number;
-  //   /**
-  //    * 清除数据结构元素
-  //    */
-  //   clear(): void;
-  //   /**
-  //    * 重写 toString 方法
-  //    */
-  //   toString(): string;
-  // }
-
   /**
    * 栈类，采用object实现
    */
   export class Stack<T> implements IStack<T> {
     constructor();
+    pop(): T | undefined;
+    push(...args: (T | T[])[]): this;
+    peek(): T | undefined;
+    isEmpty(): boolean;
+    size(): number;
+    clear(): void;
+    toString(): string;
   }
-  // interface Stack<T> extends DataStructure {
-  //   /**
-  //    * #### 移除栈顶元素并返回该元素
-  //    */
-  //   pop(): T | undefined;
-
-  //   /**
-  //    * #### 向栈顶添加元素
-  //    * @param args 要添加的元素,key可以是多个或一个元素。
-  //    */
-  //   push(item: T): this;
-  //   push(items: Array<T>): this;
-  //   push(...items: T[]): this;
-  //   push(itemOrItems: T | Array<T>): this;
-
-  //   /**
-  //    * #### 返回栈顶元素，但不移除
-  //    */
-  //   peek(): T | undefined;
-  // }
-  // interface StackConstructor {
-  //   new <T>(): Stack<T>;
-  //   readonly prototype: Stack<T>;
-  // }
-  // var Stack: StackConstructor;
 
   /**
    * 队列类，采用object实现
    */
-  interface Queue<T> extends DataStructure {
-    /**
-     * #### 移除队列头部元素并返回该元素
-     */
+  export class Queue<T> implements IQueue<T> {
+    constructor();
     dequeue(): T | undefined;
-
-    /**
-     * #### 向队列末尾添加元素
-     * @param args 要添加的元素
-     */
-    enqueue(items: T | Array<T>): this;
-    enqueue(...args: Array<T>): this;
-    /**
-     * #### 返回队列头部元素，但不移除
-     */
+    enqueue(...args: (T | T[])[]): this;
     front(): T | undefined;
+    isEmpty(): boolean;
+    size(): number;
+    clear(): void;
+    toString(): string;
   }
-  interface QueueConstructor {
-    new <T>(): Queue<T>;
-    readonly prototype: Queue<T>;
-  }
-  var Queue: QueueConstructor;
-
-  type CompareResult = -1 | 0 | 1;
 
-  interface CompareFn<T> {
-    (a: T, b: T): CompareResult;
+  export class JcNode<T> {
+    value: T;
+    next: JcNode<T> | null;
+    constructor(value: T, next: JcNode<T> | null = null): void;
   }
 
-  interface Obj<V = any> {
-    [key: string]: V;
-  }
   /**
-   * 最小堆
+   * 双向链表类
    */
-  interface MinHeap<T> extends DataStructure {
-    /**
-     * #### 插入一个值，返回一个布尔值
-     * @param value 要插入的值
-     */
-    insert(value: T): boolean;
+  export class LinkedList<T> implements ILinkedList<T> {
+    constructor(elements?: T[]): LinkedList<T>;
+    indexOf(element: T): number;
+    getElementAt(index: number): JcNode<T> | null;
+    getValueAt(index: number): T | undefined;
+    insert(element: T, index: number): boolean;
+    push(element: T): void;
+    remove(element: T): T | null;
+    removeAt(index: number): T | null;
+    isEmpty(): boolean;
+    size(): number;
+    clear(): void;
+    toString(): string;
+    toArray(): T[];
+    [Symbol.iterator](): Iterator<T>;
+  }
 
-    /**
-     * #### 移除最小值或最大值，返回该值
-     */
+  export class MinHeap<T> implements IHeap<T> {
+    constructor(compareFn?: CompareFn<T>);
+    static swap<T>(arr: T[], index1: number, index2: number): void;
+    insert(value: T): boolean;
     extract(): T | undefined;
-
-    /**
-     * 查找一个值
-     * @param value 要查找的值
-     */
     find(): T | undefined;
+    isEmpty(): boolean;
+    size(): number;
+    clear(): void;
+    toString(): string;
   }
-  interface MinHeapConstructor {
-    new <T>(fn?: CompareFn<T>): MinHeap<T>;
-    readonly prototype: MinHeap;
-  }
-  var MinHeap: MinHeapConstructor;
 
-  /**
-   * 最大堆
-   */
-  interface MaxConstructor {
-    new <T>(fn?: CompareFn<T>): MinHeap<T>;
-    readonly prototype: MinHeap<T>;
+  export class MaxHeap<T> extends MinHeap<T> {
+    constructor(compareFn?: CompareFn<T>);
   }
-  var MaxHeap: MaxConstructor;
 
-  /**
-   * LRU缓存类
-   */
-  interface LRU<K, V> {
-    /**
-     * 获取缓存的值
-     * @param key 键值
-     */
+  export class LRU<K, V> implements ILru<K, V> {
+    constructor(capacity?: number);
     get(key: K): V | undefined;
-    /**
-     * 更新缓存
-     * @param key 键值
-     * @param value 缓存的值
-     */
     update(key: K, value: V): void;
   }
-  interface LRUConstructor {
-    new <K, V>(capacity?: number): LRU<K, V>;
-    readonly prototype: LRU;
-  }
-  var LRU: LRUConstructor;
-
-  // export class JcNode<T> {
-  //   value: T;
-  //   next: JcNode<T> | null;
-  //   constructor(value: T, next: JcNode<T> | null = null): void;
-  // }
-
-  // export interface ILinkedList<T> {
-  //   indexOf(element: T): number;
-  //   getElementAt(index: number): JcNode<T> | null;
-  //   getValueAt(index: number): T | undefined;
-  //   insert(element: T, index: number): boolean;
-  //   push(element: T): void;
-  //   remove(element: T): T | null;
-  //   removeAt(index: number): T | null;
-  //   isEmpty(): boolean;
-  //   size(): number;
-  //   clear(): void;
-  //   toString(): string;
-  //   toArray(): T[];
-  //   [Symbol.iterator](): Iterator<T>;
-  // }
-
-  // export class LinkedList<T> implements ILinkedList<T> {
-  //   constructor(elements?: T[]);
-  // }
 
-  export type NodeType<T> = JcNode<T>;
-  export type ListType<T> = LinkedList<T>;
+  export class ValuePair<K, V> {
+    key: K;
+    value: V;
+    constructor(key: K, value: V);
+  }
 
-  /**
-   * 字典类
-   */
-  export class Dictionary<K, V> {
-    constructor();
-    /**
-     * #### 设置键值对
-     * @param key 键
-     * @param value 值
-     */
+  export class Dictionary<K, V> implements IDictionary<K, V> {
     set(key: K, value: V): void;
-
-    /**
-     * #### 删除键值对
-     * @param key 键
-     */
     remove(key: K): ValuePair<K, V> | undefined;
-
-    /**
-     * #### 判断键是否存在
-     * @param key 键
-     */
     has(key: K): boolean;
-
-    /**
-     * #### 获取键值对
-     * @param key 键
-     */
     get(key: K): ValuePair<K, V> | undefined;
-
-    /**
-     * #### 获取键数组
-     */
-    keys(): Array<K>;
-
-    /**
-     * #### 获取值数组
-     */
-    values(): Array<V>;
-
-    /**
-     * #### 获取键值对数组
-     */
+    keys(): K[];
+    values(): V[];
     keyValues(): Array<[K, V]>;
-
-    /**
-     * 遍历键值对
-     * @param callbackFunc 回调函数
-     */
     forEach(callbackFunc: (key: K, value: V) => boolean | void): void;
-
-    /**
-     * 判断数据结构是否为空
-     */
     isEmpty(): boolean;
-    /**
-     * 数据结构元素长度
-     */
     size(): number;
-    /**
-     * 重写 toString 方法
-     */
-    toString(): string;
-    /**
-     * 清除数据结构元素
-     */
     clear(): void;
+    toString(): string;
   }
 
-  /**
-   * 图类
-   */
   export class Graph<T> implements IGraph<T> {
     constructor(isDirected?: boolean);
-    /**
-     * #### 添加顶点的方法
-     * @param v 顶点
-     */
     addVertex(v: T): void;
-    /**
-     * #### 添加边的方法
-     * @param v 顶点
-     * @param w
-     */
     addEdge(v: T, w: T): void;
-    /**
-     * #### 获取顶点集合的方法
-     */
-    getVertices(): Array<T>;
-    /**
-     * #### 获取邻接表的方法
-     */
-    getAdjacencyList(): IDictionary<T, Array<T>>;
+    getVertices(): T[];
+    getAdjacencyList(): Dictionary<T, T[]>;
+    toString(): string;
   }
 
-  interface Point {
-    /**
-     * #### 点x坐标
-     */
-    readonly x: number;
-    /**
-     * #### 点y坐标
-     */
-    readonly y: number;
-    /**
-     * #### 计算点与点之间的距离，实例方法
-     * @param p 点p
-     */
+  export class Point {
+    constructor(x: number, y: number);
+    static distance(p1: Point, p2: Point): number;
     distanceTo(p: Point): number;
   }
+
   interface PointConstructor {
     new (x: number, y: number): Point;
     /**
@@ -1033,7 +856,7 @@ declare module "jc-structure" {
      * @param visited
      * @returns
      */
-    deepClone(obj: unknown, visited?: WeakMap): unknown;
+    // deepClone(obj: unknown, visited?: WeakMap): unknown;
   }
   var Obj: ObjConstructor;
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "jc-structure",
   "private": false,
-  "version": "0.2.7",
+  "version": "0.2.9",
   "type": "module",
   "files": [
     "dist",

package/types/index.d.ts

@@ -2,3 +2,7 @@ export * from "./global";
 export * from "./linkedList";
 export * from "./stack";
 export * from "./queue";
+export * from "./heap";
+export * from "./lru";
+export * from "./dictionary";
+export * from "./graph";

package/types/linkedList.d.ts

@@ -1,28 +1,65 @@
-class JcNode<T> {
-  value: T;
-  next: JcNode<T> | null;
-  constructor(value: T, next: JcNode<T> | null = null): void;
-}
-
 /**
- * #### 链表接口
+ * #### 双向链表接口
  */
 interface ILinkedList<T> {
+  /**
+   * #### 查找元素位置
+   * @param element 元素
+   */
   indexOf(element: T): number;
+  /**
+   * #### 获取指定位置的元素
+   * @param index 索引
+   */
   getElementAt(index: number): JcNode<T> | null;
+  /**
+   * #### 获取指定位置的值
+   * @param index 索引
+   */
   getValueAt(index: number): T | undefined;
+  /**
+   * #### 在指定位置插入元素
+   * @param element 元素
+   * @param index 索引
+   */
   insert(element: T, index: number): boolean;
+  /**
+   * #### 在链表尾部添加元素
+   * @param element 元素
+   */
   push(element: T): void;
+  /**
+   * #### 删除指定元素
+   * @param element 元素
+   */
   remove(element: T): T | null;
+  /**
+   * #### 删除指定位置的元素
+   * @param index 索引
+   */
   removeAt(index: number): T | null;
+  /**
+   * #### 判断链表是否为空
+   */
   isEmpty(): boolean;
+  /**
+   * #### 获取链表长度
+   */
   size(): number;
+  /**
+   * #### 清空链表
+   */
   clear(): void;
+  /**
+   * #### 将链表转换为字符串
+   */
   toString(): string;
+  /**
+   * #### 将链表转换为数组
+   */
   toArray(): T[];
+  /**
+   * #### 实现了 [Symbol.iterator] 方法，使链表可以被 for...of 循环遍历
+   */
   [Symbol.iterator](): Iterator<T>;
 }
-
-class LinkedList<T> implements ILinkedList<T> {
-  constructor(elements?: T[]);
-}

package/types/lru.d.ts

@@ -0,0 +1,22 @@
+interface LRU_Node<T> {
+  value: T;
+  prev?: LRU_Node<T>;
+  next?: LRU_Node<T>;
+}
+
+/**
+ * #### Least Recently Used Cache
+ */
+interface ILru<K, V> {
+  /**
+   * #### Get the value of the key
+   * @param key
+   */
+  get(key: K): V | undefined;
+  /**
+   * #### Set the value of the key
+   * @param key
+   * @param value
+   */
+  update(key: K, value: V): void;
+}