前端數據結構之集合

時間  2020-04-16
標籤 前端 數據 結構 集合 欄目 快樂工作 简体版
原文   原文鏈接

集合，字典，散列表又稱哈希表

  1. 集合、字典和散列表能夠存儲不重複的值。
  2. 在集合中，咱們感興趣的是每一個值自己，並把它看成主要元素。
  3. 在字典中，咱們用[鍵，值]的形式來存儲數據。
  4. 在散列表中也是同樣（也是以[鍵，值]對的形式來存儲數據）。

集合

集合是由一組無序且惟一的項組成的。（即不能重複的）
集合是一組不一樣的對象（的集）。好比說，一個由大於或等於0的整數組成的天然數集合：N={0,1,2,3,4,5,6,…}。
集合也有並集、交集、差集等基本操做。下面將介紹這些操做es6

建立集合（實現的類與es6的set類相似）
function Set() { 
  var items = {};
}

接下來，須要聲明一些集合可用的方法數組

add(value)：向集合添加一個新的項。
delete(value)：從集合移除一個值。
has(value)：若是值在集合中，返回true，不然返回false。
clear()：移除集合中的全部項。
size()：返回集合所包含元素的數量。與數組的length屬性相似。
values()：返回一個包含集合中全部值的數組。

has(value)：若是值在集合中，返回true，不然返回false。測試

/**
* @description 定義一個集合是否有該值的方法
* @param {string} 值
* @return {boolean}
*/
this.has = value => value in items;

add(value)：向集合添加一個新的項。this

/**
* @description 添加
*/
this.add = value => {
if (!this.has(value)) {
  items[value] = value;

  return true;
}

return false;
}

delete(value)：從集合移除一個值。spa

/**
* @description 刪除
*/
this.delete = value => {
if (this.has(value)) {
  delete items[value];

  return true;
}

return false;
}

clear()：移除集合中的全部項。3d

/**
* @description 清除
*/
this.clear = () => {
items = {};

return true;
}

size()：返回集合所包含元素的數量。與數組的length屬性相似。code

/**
* @description 求集合長度
*/
this.size = () => Object.keys(items).length;

values()：返回一個包含集合中全部值的數組。對象

/**
* @description 返回集合中值的數組
*/
this.values = () => Object.values(items);

測試咱們的Set類blog

var set = new Set(); 
set.add(1);
console.log(set.values()); //輸出["1"]
console.log(set.has(1)); //輸出true
console.log(set.size()); //輸出1
set.add(2);
console.log(set.values()); //輸出["1", "2"]
console.log(set.has(2)); //true 
console.log(set.size()); //2
set.delete(1); 
console.log(set.values()); //輸出["2"]
console.log(set.has(2)); //false
console.log(set.size()); //1
set.delete(2); 
console.log(set.values()); //輸出[]
console.log(set.has(2)); //false
console.log(set.size()); //0
集合操做

　　對集合能夠進行以下操
　　一、並集：對於給定的兩個集合，返回一個包含兩個集合中全部元素的新集合
image.png
實現Set類的union方法ip

/**
* @description 並集
*/
this.union = setB => {
let unionSet = new Set();
const values = this.values();

for (let i = 0; i < values.length; i++) {
  unionSet.add(values[i]);
}

const setBValues = setB.values();

for (let i = 0; i < setBValues.length; i++) {
  if (!unionSet.has(setBValues[i])) {
    unionSet.add(setBValues[i]);
  }
}

return unionSet;
}

輸出爲[1, 2, 3, 4, 5, 6]。注意元素3同時存在於A和B中，它在結果的 集合中只出現一次。
　　二、交集：對於給定的兩個集合，返回一個包含兩個集合中共有元素的新集合
image.png
如今來實現Set類的intersection方法：

/**
* @description 交集
*/
this.intersection = setB => {
let intersectionSet = new Set();
const values = this.values();


for (let i = 0; i < values.length; i++) {
  if (setB.has(values[i])) {
    intersectionSet.add(values[i]);
  }
}

return intersectionSet;
}

　　三、差集：對於給定的兩個集合，返回一個包含全部存在於第一個集合且不存在於第二個集合的元素的新集合
image.png

/**
* @description 差集
*/
this.difference = setB => {
let differenceSet = new Set();
const values = this.values();

for (let i = 0; i < values.length; i++) {
  if (!setB.has(values[i])) {
    differenceSet.add(values[i]);
  }
}

return differenceSet;
}

　　四、子集：驗證一個給定集合是不是另外一集合的子集
image.png

/**
   * @description 子集
   */
  this.subset = setB => {
    if (this.size > setB.size) {
      return false;
    }

    const values = this.values();

    for (let i = 0; i < values.length; i++) {
      if (!setB.has(values[i])) {
        return false;
      }
    }
    return true;
  }
}

完整代碼

function Set() {
  let items = {}; // 定義一個集合

  /**
   * @description 定義一個集合是否有該值的方法
   * @param {string} 值
   * @return {boolean}
   */
  this.has = value => value in items;

  /**
   * @description 添加
   */
  this.add = value => {
    if (!this.has(value)) {
      items[value] = value;

      return true;
    }

    return false;
  }

  /**
   * @description 刪除
   */
  this.delete = value => {
    if (this.has(value)) {
      delete items[value];

      return true;
    }

    return false;
  }

  /**
   * @description 清除
   */
  this.clear = () => {
    items = {};

    return true;
  }

  /**
   * @description 求集合長度
   */
  this.size = () => Object.keys(items).length;

  /**
   * @description 返回集合中值的數組
   */
  this.values = () => Object.values(items);

  /**
   * @description 並集
   */
  this.union = setB => {
    let unionSet = new Set();
    const values = this.values();

    for (let i = 0; i < values.length; i++) {
      unionSet.add(values[i]);
    }

    const setBValues = setB.values();

    for (let i = 0; i < setBValues.length; i++) {
      if (!unionSet.has(setBValues[i])) {
        unionSet.add(setBValues[i]);
      }
    }

    return unionSet;
  }

  /**
   * @description 交集
   */
  this.intersection = setB => {
    let intersectionSet = new Set();
    const values = this.values();


    for (let i = 0; i < values.length; i++) {
      if (setB.has(values[i])) {
        intersectionSet.add(values[i]);
      }
    }

    return intersectionSet;
  }

  /**
   * @description 差集
   */
  this.difference = setB => {
    let differenceSet = new Set();
    const values = this.values();

    for (let i = 0; i < values.length; i++) {
      if (!setB.has(values[i])) {
        differenceSet.add(values[i]);
      }
    }

    return differenceSet;
  }

  /**
   * @description 子集
   */
  this.subset = setB => {
    if (this.size() > setB.size()) {
      return false;
    }

    const values = this.values();

    for (let i = 0; i < values.length; i++) {
      if (!setB.has(values[i])) {
        return false;
      }
    }
    return true;
  }
}

驗證

// 合集
    let setA = new Set();
    setA.add(1);
    setA.add(2);
    setA.add(3);

    let setB = new Set();
    setB.add(3);
    setB.add(4);
    setB.add(5);
    setB.add(6);

    let unionAB = setA.union(setB);
    console.log('合集');
    console.log(setA.values());
    console.log(setB.values());
    console.log(unionAB.values()); // [1,2,3,4,5,6]

    // 交集
    let setC = new Set();
    setC.add(1);
    setC.add(2);
    setC.add(3);

    let setD = new Set();
    setD.add(2);
    setD.add(3);
    setD.add(4);

    let intersectionCD = setC.intersection(setD);
    console.log('交集');
    console.log(setC.values());
    console.log(setD.values());
    console.log(intersectionCD.values()); // [2,3]

    // 差集
    let setE = new Set();
    setE.add(1);
    setE.add(2);
    setE.add(3);

    let setF = new Set();
    setF.add(2);
    setF.add(3);
    setF.add(4);

    let differenceEF = setA.difference(setF);
    console.log('差集');
    console.log(setE.values());
    console.log(setF.values());
    console.log(differenceEF.values()); // [1]

    // 子集
    let setH = new Set();
    setH.add(1);
    setH.add(2);

    let setI = new Set();
    setI.add(1);
    setI.add(2);
    setI.add(3);

    let setG = new Set();
    setG.add(2);
    setG.add(3);
    setG.add(4);

    console.log('子集');
    console.log(setH.values());
    console.log(setI.values());
    console.log(setG.values());
    console.log(setH.subset(setI)); // true
    console.log(setI.subset(setG)); // false
應用es6 Set
  1. 數組去重
let arr = [3, 5, 2, 2, 5, 5];
let unique = [...new Set(arr)];
console.log(unique)// [3, 5, 2]
  1. 並集（Union）、交集（Intersect）和差集（Difference）
let a = new Set([1, 2, 3]);
let b = new Set([4, 3, 2]);

// 並集
let union = new Set([...a, ...b]);
console.log(union)// Set {1, 2, 3, 4}

// 交集
let intersect = new Set([...a].filter(x => b.has(x)));
console.log(intersect)// set {2, 3}

// 差集
let difference = new Set([...a].filter(x => !b.has(x)));
console.log(difference)// Set {1}
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程