github/hello-algo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:guowei-gong/hello-algo into gongguowei

Browse Source 
* 'master' of github.com:guowei-gong/hello-algo:
  Update JavaScript style (Chapter of Hashing)
  Update codes/typescript/chapter_hashing/array_hash_map.ts
  Add the JavaScript code to docs (Chapter of Hashing)
  Add the JavaScript code (Chapter of Hashing)
  Update hash_map docs
  Use tricky method to resolve type check
  Removed hash_map class
  Update built-in Hash Map
  Updated code formats and removed useless codes
  removed: iml file
  added: header comments
  added: header comments
  fixed: several bugs
  removed: out of array range check
  updated: .gitignore
  added: typescript hash func
This commit is contained in:
龚国玮 2022-12-27 09:52:31 +08:00
commit ea40f0fce0
6 changed files with 541 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -13,3 +13,6 @@ docs/overrides/
# python files
__pycache__
# iml
hello-algo.iml

129
codes/javascript/chapter_hashing/array_hash_map.js Normal file
View File

@ -0,0 +1,129 @@
/*
* File: array_hash_map.js
* Created Time: 2022-12-26
* Author: Justin (xiefahit@gmail.com)
*/
/* 键值对 Number -> String */
class Entry {
constructor(key, val) {
this.key = key;
this.val = val;
}
}
/* 基于数组简易实现的哈希表 */
class ArrayHashMap {
#bucket;
constructor() {
// 初始化一个长度为 100 的桶（数组）
this.#bucket = new Array(100).fill(null);
}
/* 哈希函数 */
#hashFunc(key) {
return key % 100;
}
/* 查询操作 */
get(key) {
let index = this.#hashFunc(key);
let entry = this.#bucket[index];
if (entry === null) return null;
return entry.val;
}
/* 添加操作 */
set(key, val) {
let index = this.#hashFunc(key);
this.#bucket[index] = new Entry(key, val);
}
/* 删除操作 */
delete(key) {
let index = this.#hashFunc(key);
// 置为 null ，代表删除
this.#bucket[index] = null;
}
/* 获取所有键值对 */
entries() {
let arr = [];
for (let i = 0; i < this.#bucket.length; i++) {
if (this.#bucket[i]) {
arr.push(this.#bucket[i]);
}
}
return arr;
}
/* 获取所有键 */
keys() {
let arr = [];
for (let i = 0; i < this.#bucket.length; i++) {
if (this.#bucket[i]) {
arr.push(this.#bucket[i]?.key);
}
}
return arr;
}
/* 获取所有值 */
values() {
let arr = [];
for (let i = 0; i < this.#bucket.length; i++) {
if (this.#bucket[i]) {
arr.push(this.#bucket[i]?.val);
}
}
return arr;
}
/* 打印哈希表 */
print() {
let entrySet = this.entries();
for (const entry of entrySet) {
if (!entry) continue;
console.info(`${entry.key} -> ${entry.val}`);
}
}
}
/* Driver Code */
/* 初始化哈希表 */
const map = new ArrayHashMap();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.set(12836, '小哈');
map.set(15937, '小啰');
map.set(16750, '小算');
map.set(13276, '小法');
map.set(10583, '小鸭');
console.info('\n添加完成后，哈希表为\nKey -> Value');
map.print();
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
let name = map.get(15937);
console.info('\n输入学号 15937 ，查询到姓名 ' + name);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.delete(10583);
console.info('\n删除 10583 后，哈希表为\nKey -> Value');
map.print();
/* 遍历哈希表 */
console.info('\n遍历键值对 Key->Value');
for (const entry of map.entries()) {
if (!entry) continue;
console.info(entry.key + ' -> ' + entry.val);
}
console.info('\n单独遍历键 Key');
for (const key of map.keys()) {
console.info(key);
}
console.info('\n单独遍历值 Value');
for (const val of map.values()) {
console.info(val);
}

44
codes/javascript/chapter_hashing/hash_map.js Normal file
View File

@ -0,0 +1,44 @@
/*
* File: hash_map.js
* Created Time: 2022-12-26
* Author: Justin (xiefahit@gmail.com)
*/
/* Driver Code */
/* 初始化哈希表 */
const map = new Map();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.set(12836, '小哈');
map.set(15937, '小啰');
map.set(16750, '小算');
map.set(13276, '小法');
map.set(10583, '小鸭');
console.info('\n添加完成后，哈希表为\nKey -> Value');
console.info(map);
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
let name = map.get(15937);
console.info('\n输入学号 15937 ，查询到姓名 ' + name);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.delete(10583);
console.info('\n删除 10583 后，哈希表为\nKey -> Value');
console.info(map);
/* 遍历哈希表 */
console.info('\n遍历键值对 Key->Value');
for (const [k, v] of map.entries()) {
console.info(k + ' -> ' + v);
}
console.info('\n单独遍历键 Key');
for (const k of map.keys()) {
console.info(k);
}
console.info('\n单独遍历值 Value');
for (const v of map.values()) {
console.info(v);
}

136
codes/typescript/chapter_hashing/array_hash_map.ts Normal file
View File

@ -0,0 +1,136 @@
/*
* File: array_hash_map.ts
* Created Time: 2022-12-20
* Author: Daniel (better.sunjian@gmail.com)
*/
/* 键值对 Number -> String */
class Entry {
public key: number;
public val: string;
constructor(key: number, val: string) {
this.key = key;
this.val = val;
}
}
/* 基于数组简易实现的哈希表 */
class ArrayHashMap {
private readonly bucket: (Entry | null)[];
constructor() {
// 初始化一个长度为 100 的桶（数组）
this.bucket = (new Array(100)).fill(null);
}
/* 哈希函数 */
private hashFunc(key: number): number {
return key % 100;
}
/* 查询操作 */
public get(key: number): string | null {
let index = this.hashFunc(key);
let entry = this.bucket[index];
if (entry === null) return null;
return entry.val;
}
/* 添加操作 */
public set(key: number, val: string) {
let index = this.hashFunc(key);
this.bucket[index] = new Entry(key, val);
}
/* 删除操作 */
public delete(key: number) {
let index = this.hashFunc(key);
// 置为 null ，代表删除
this.bucket[index] = null;
}
/* 获取所有键值对 */
public entries(): (Entry | null)[] {
let arr: (Entry | null)[] = [];
for (let i = 0; i < this.bucket.length; i++) {
if (this.bucket[i]) {
arr.push(this.bucket[i]);
}
}
return arr;
}
/* 获取所有键 */
public keys(): (number | undefined)[] {
let arr: (number | undefined)[] = [];
for (let i = 0; i < this.bucket.length; i++) {
if (this.bucket[i]) {
arr.push(this.bucket[i]?.key);
}
}
return arr;
}
/* 获取所有值 */
public values(): (string | undefined)[] {
let arr: (string | undefined)[] = [];
for (let i = 0; i < this.bucket.length; i++) {
if (this.bucket[i]) {
arr.push(this.bucket[i]?.val);
}
}
return arr;
}
/* 打印哈希表 */
public print() {
let entrySet = this.entries();
for (const entry of entrySet) {
if (!entry) continue;
console.info(`${entry.key} -> ${entry.val}`);
}
}
}
/* Driver Code */
/* 初始化哈希表 */
const map = new ArrayHashMap();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.set(12836, '小哈');
map.set(15937, '小啰');
map.set(16750, '小算');
map.set(13276, '小法');
map.set(10583, '小鸭');
console.info('\n添加完成后，哈希表为\nKey -> Value');
map.print();
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
let name = map.get(15937);
console.info('\n输入学号 15937 ，查询到姓名 ' + name);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.delete(10583);
console.info('\n删除 10583 后，哈希表为\nKey -> Value');
map.print();
/* 遍历哈希表 */
console.info('\n遍历键值对 Key->Value');
for (const entry of map.entries()) {
if (!entry) continue;
console.info(entry.key + ' -> ' + entry.val);
}
console.info('\n单独遍历键 Key');
for (const key of map.keys()) {
console.info(key);
}
console.info('\n单独遍历值 Value');
for (const val of map.values()) {
console.info(val);
}
export {};

44
codes/typescript/chapter_hashing/hash_map.ts Normal file
View File

@ -0,0 +1,44 @@
/*
* File: hash_map.ts
* Created Time: 2022-12-20
* Author: Daniel (better.sunjian@gmail.com)
*/
/* Driver Code */
/* 初始化哈希表 */
const map = new Map<number, string>();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.set(12836, '小哈');
map.set(15937, '小啰');
map.set(16750, '小算');
map.set(13276, '小法');
map.set(10583, '小鸭');
console.info('\n添加完成后，哈希表为\nKey -> Value');
console.info(map);
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
let name = map.get(15937);
console.info('\n输入学号 15937 ，查询到姓名 ' + name);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.delete(10583);
console.info('\n删除 10583 后，哈希表为\nKey -> Value');
console.info(map);
/* 遍历哈希表 */
console.info('\n遍历键值对 Key->Value');
for (const [k, v] of map.entries()) {
console.info(k + ' -> ' + v);
}
console.info('\n单独遍历键 Key');
for (const k of map.keys()) {
console.info(k);
}
console.info('\n单独遍历值 Value');
for (const v of map.values()) {
console.info(v);
}

188
docs/chapter_hashing/hash_map.md
View File

@ -132,13 +132,50 @@ comments: true
=== "JavaScript"
```js title="hash_map.js"
/* 初始化哈希表 */
const map = new ArrayHashMap();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.set(12836, '小哈');
map.set(15937, '小啰');
map.set(16750, '小算');
map.set(13276, '小法');
map.set(10583, '小鸭');
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
let name = map.get(15937);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.delete(10583);
```
=== "TypeScript"
```typescript title="hash_map.ts"
/* 初始化哈希表 */
const map = new Map<number, string>();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.set(12836, '小哈');
map.set(15937, '小啰');
map.set(16750, '小算');
map.set(13276, '小法');
map.set(10583, '小鸭');
console.info('\n添加完成后，哈希表为\nKey -> Value');
console.info(map);
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
let name = map.get(15937);
console.info('\n输入学号 15937 ，查询到姓名 ' + name);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.delete(10583);
console.info('\n删除 10583 后，哈希表为\nKey -> Value');
console.info(map);
```
=== "C"
@ -244,13 +281,38 @@ comments: true
=== "JavaScript"
```js title="hash_map.js"
/* 遍历哈希表 */
// 遍历键值对 key->value
for (const entry of map.entries()) {
if (!entry) continue;
console.info(entry.key + ' -> ' + entry.val);
}
// 单独遍历键 key
for (const key of map.keys()) {
console.info(key);
}
// 单独遍历值 value
for (const val of map.values()) {
console.info(val);
}
```
=== "TypeScript"
```typescript title="hash_map.ts"
/* 遍历哈希表 */
console.info('\n遍历键值对 Key->Value');
for (const [k, v] of map.entries()) {
console.info(k + ' -> ' + v);
}
console.info('\n单独遍历键 Key');
for (const k of map.keys()) {
console.info(k);
}
console.info('\n单独遍历值 Value');
for (const v of map.values()) {
console.info(v);
}
```
=== "C"
@ -500,13 +562,133 @@ $$
=== "JavaScript"
```js title="array_hash_map.js"
/* 键值对 Number -> String */
class Entry {
constructor(key, val) {
this.key = key;
this.val = val;
}
}
/* 基于数组简易实现的哈希表 */
class ArrayHashMap {
#bucket;
constructor() {
// 初始化一个长度为 100 的桶（数组）
this.#bucket = new Array(100).fill(null);
}
/* 哈希函数 */
#hashFunc(key) {
return key % 100;
}
/* 查询操作 */
get(key) {
let index = this.#hashFunc(key);
let entry = this.#bucket[index];
if (entry === null) return null;
return entry.val;
}
/* 添加操作 */
set(key, val) {
let index = this.#hashFunc(key);
this.#bucket[index] = new Entry(key, val);
}
/* 删除操作 */
delete(key) {
let index = this.#hashFunc(key);
// 置为 null ，代表删除
this.#bucket[index] = null;
}
}
```
=== "TypeScript"
```typescript title="array_hash_map.ts"
/* 键值对 Number -> String */
class Entry {
public key: number;
public val: string;
constructor(key: number, val: string) {
this.key = key;
this.val = val;
}
}
/* 基于数组简易实现的哈希表 */
class ArrayHashMap {
private readonly bucket: (Entry | null)[];
constructor() {
// 初始化一个长度为 100 的桶（数组）
this.bucket = (new Array(100)).fill(null);
}
/* 哈希函数 */
private hashFunc(key: number): number {
return key % 100;
}
/* 查询操作 */
public get(key: number): string | null {
let index = this.hashFunc(key);
let entry = this.bucket[index];
if (entry === null) return null;
return entry.val;
}
/* 添加操作 */
public set(key: number, val: string) {
let index = this.hashFunc(key);
this.bucket[index] = new Entry(index, val);
}
/* 删除操作 */
public delete(key: number) {
let index = this.hashFunc(key);
// 置为 null ，代表删除
this.bucket[index] = null;
}
/* 获取所有键值对 */
public entries(): (Entry | null)[] {
let arr: (Entry | null)[] = [];
for (let i = 0; i < this.bucket.length; i++) {
if (this.bucket[i]) {
arr.push(this.bucket[i]);
}
}
return arr;
}
/* 获取所有键 */
public keys(): (number | undefined)[] {
let arr: (number | undefined)[] = [];
for (let i = 0; i < this.bucket.length; i++) {
if (this.bucket[i]) {
arr.push(this.bucket[i]?.key);
}
}
return arr;
}
/* 获取所有值 */
public values(): (string | undefined)[] {
let arr: (string | undefined)[] = [];
for (let i = 0; i < this.bucket.length; i++) {
if (this.bucket[i]) {
arr.push(this.bucket[i]?.val);
}
}
return arr;
}
}
```
=== "C"