Detaillierte Erläuterung der JS-Simulationsimplementierung der Hash-Tabelle und ihrer Anwendung

Dieser Artikel stellt hauptsächlich die JS-Simulation zur Implementierung von Hash-Tabellen und ihre Anwendungen vor. Er analysiert die Schritte der Javascript-Simulation zur Implementierung von Hash-Tabellen, zugehörige Betriebstechniken und Verwendungsmethoden in Form von Beispielen.

Die Beispiele in diesem Artikel beschreiben die JS-Simulationsimplementierung von Hash-Tabellen und ihre Anwendungen. Teilen Sie es wie folgt mit allen als Referenz:

In Algorithmen, insbesondere in Algorithmen im Zusammenhang mit Arrays, kann die Verwendung von Hash-Tabellen Probleme sehr gut lösen, daher werden in diesem Artikel einige relevante js-Implementierungen und Hash-Tabellen aufgezeichnet Geben Sie Beispiele für die Lösung realer Probleme.

Hinweis: In diesem Artikel geht es nicht um eine Hash-Tabelle im eigentlichen Sinne, sondern ähnelt der Verwendung einer Hash-Tabelle.

Teil 1: Verwandte Wissenspunkte

Aufzählung von Attributen:

var person = {
  name: "zzw",
  sex: "Male",
  age: 21
};
for (var prop in person) {
  console.log(prop + " ",person[prop]);
}

Ausgabe:

Das heißt, für Objekte können wir for in verwenden, um die Eigenschaften des Objekts aufzuzählen.

Löschen von Attributen:

var person = {
  name: "zzw",
  sex: "Male",
  age: 21
};
var ifRemove = delete person.name;
for (var prop in person) {
  console.log(prop + " ",person[prop]);
}
console.log(ifRemove);

Die Attribute eines Objekts können durch Löschen gelöscht werden, und das wird auch so sein ein Rückgabewert. Wie folgt:

Hinweis: Im Allgemeinen können nur die Attribute von Objekten gelöscht werden, Variablen können jedoch nicht gelöscht werden, wie zum Beispiel:

var x = 1;
console.log(delete x);

Zu diesem Zeitpunkt gibt die Druckkonsole „false“ aus, da die Variable nicht gelöscht werden kann.

Erkennen Sie, ob das Attribut vorhanden ist:

var person = {
  name: "zzw",
  sex: "Male",
  age: 21
};
console.log("age" in person);
console.log("someOther" in person);

Ersteres gibt true und letzteres false zurück. Das heißt, wir können in verwenden, um festzustellen, ob ein Objekt dieses Attribut enthält.

Attribute hinzufügen:

var person = {
  name: "zzw",
  sex: "Male",
  age: 21
};
person["school"] = "XJTU";
console.log(person);

Das Hinzufügen von Attributen ist sehr einfach, wie oben gezeigt, das endgültige gedruckte Objekt Es enthält das Schulattribut.

Teil 2: Verwenden von js zum Implementieren einer Hash-Tabelle

Das Folgende ist eine Hash-Tabelle, die über den Konstruktor erhalten wurde Instanziieren Sie es einfach und die folgenden Funktionen sind relativ umfangreich. Bei tatsächlichen Problemen können wir sie selektiv verwenden.

// 创建构造函数HashTable
function HashTable() {
    // 初始化哈希表的记录条数size
    var size = 0;
    // 创建对象用于接受键值对
    var res = {};
    // 添加关键字，无返回值
    this.add = function (key, value) {
      //判断哈希表中是否存在key，若不存在，则size加1，且赋值
      if (!this.containKey(key)) {
        size++;
      }
      // 如果之前不存在，赋值； 如果之前存在，覆盖。
      res[key] = value;
    };
    // 删除关键字, 如果哈希表中包含key，并且delete返回true则删除，并使得size减1
    this.remove = function (key) {
      if (this.containKey(key) && (delete res[key])) {
        size--;
      }
    };
    // 哈希表中是否包含key，返回一个布尔值
    this.containKey = function (key) {
      return (key in res);
    };
    // 哈希表中是否包含value，返回一个布尔值
    this.containValue = function (value) {
      // 遍历对象中的属性值，判断是否和给定value相等
      for (var prop in res) {
        if (res[prop] === value) {
          return true;
        }
      }
      return false;
    };
    // 根据键获取value,如果不存在就返回null
    this.getValue = function (key) {
      return this.containKey(key) ? res[key] : null;
    };
    // 获取哈希表中的所有value, 返回一个数组
    this.getAllValues = function () {
      var values = [];
      for (var prop in res) {
        values.push(res[prop]);
      }
      return values;
    };
    // 根据值获取哈希表中的key，如果不存在就返回null
    this.getKey = function (value) {
      for (var prop in res) {
        if (res[prop] === value) {
          return prop;
        }
      }
      // 遍历结束没有return，就返回null
      return null;
    };
    // 获取哈希表中所有的key,返回一个数组
    this.getAllKeys = function () {
      var keys = [];
      for (var prop in res) {
        keys.push(prop);
      }
      return keys;
    };
    // 获取哈希表中记录的条数，返回一个数值
    this.getSize = function () {
      return size;
    };
    // 清空哈希表，无返回值
    this.clear = function () {
      size = 0;
      res = {};
    };
}

Teil 3: Anwendungsbeispiel

Problem: Gegeben ein ganzzahliges Array (ungeordnet). ), finden Sie darin zwei Zahlen, deren Summe ein bestimmter Wert ist, und geben Sie die Indizes dieser beiden Zahlen zurück (Array-Indizes beginnen bei 0), vorausgesetzt, die Werte der Array-Elemente sind unterschiedlich.

wird wie folgt implementiert:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>哈希表的使用</title>
</head>
<body>
  <script>
  function queryIndex(arr, result) {
    var hashTable = new HashTable();
    var arrLength = arr.length;
    var sub = [];
    for (var i = 0; i < arrLength; i++) {
      // 扫描一遍，存储下标和值
      hashTable.add(i, arr[i]);
    }
    for (var j = 0; j < arrLength; j++) {
      if (hashTable.containValue(result - arr[j]) && result !== 2*arr[j]) {
        // 获取两个下标，跳出循环
        sub.push(j);
        var antherIndex = Number(hashTable.getKey(result - arr[j]));
        sub.push(antherIndex);
        break;
      }
    }
    if (sub.length !== 0) {
      return sub;
    } else {
      return -1;
    }
  }
  console.log(queryIndex([1,5,7,3,8], 15)); // 2, 4
  console.log(queryIndex([8,18,28,12,29,17], 46)); // 2, 4
  console.log(queryIndex([8,18,28,12,29,17], 2)); // -1
   // 创建构造函数HashTable
  function HashTable() {
    // 初始化哈希表的记录条数size
    var size = 0;
    // 创建对象用于接受键值对
    var res = {};
    // 添加关键字，无返回值
    this.add = function (key, value) {
      //判断哈希表中是否存在key，若不存在，则size加1，且赋值
      if (!this.containKey(key)) {
        size++;
      }
      // 如果之前不存在，赋值； 如果之前存在，覆盖。
      res[key] = value;
    };
    // 删除关键字, 如果哈希表中包含key，并且delete返回true则删除，并使得size减1
    this.remove = function (key) {
      if (this.containKey(key) && (delete res[key])) {
        size--;
      }
    };
    // 哈希表中是否包含key，返回一个布尔值
    this.containKey = function (key) {
      return (key in res);
    };
    // 哈希表中是否包含value，返回一个布尔值
    this.containValue = function (value) {
      // 遍历对象中的属性值，判断是否和给定value相等
      for (var prop in res) {
        if (res[prop] === value) {
          return true;
        }
      }
      return false;
    };
    // 根据键获取value,如果不存在就返回null
    this.getValue = function (key) {
      return this.containKey(key) ? res[key] : null;
    };
    // 获取哈希表中的所有value, 返回一个数组
    this.getAllValues = function () {
      var values = [];
      for (var prop in res) {
        values.push(res[prop]);
      }
      return values;
    };
    // 根据值获取哈希表中的key，如果不存在就返回null
    this.getKey = function (value) {
      for (var prop in res) {
        if (res[prop] === value) {
          return prop;
        }
      }
      // 遍历结束没有return，就返回null
      return null;
    };
    // 获取哈希表中所有的key,返回一个数组
    this.getAllKeys = function () {
      var keys = [];
      for (var prop in res) {
        keys.push(prop);
      }
      return keys;
    };
    // 获取哈希表中记录的条数，返回一个数值
    this.getSize = function () {
      return size;
    };
    // 清空哈希表，无返回值
    this.clear = function () {
      size = 0;
      res = {};
    };
  }
  </script>
</body>
</html>

Im tatsächlichen Nutzungsprozess können wir zuerst die Hauptfunktionen schreiben und sie dann bei Bedarf hinzufügen .

Verwandte Empfehlungen:

JS zur Implementierung der Riesenradlotterie

JS-Simulation zur Implementierung der Kapselungsmethode

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung der JS-Simulationsimplementierung der Hash-Tabelle und ihrer Anwendung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!