xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-24 20:26:29 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

Updated code formats and removed useless codes

Browse source
This commit is contained in:
danielsss 2022-12-22 00:04:30 +11:00
parent e9e30833fa
commit 1e72f66f09
No known key found for this signature in database
GPG key ID: 2A5967D8F31A22D2
4 changed files with 149 additions and 260 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

236
codes/typescript/chapter_hashing/array_hash_map.ts
View file

@ -6,134 +6,130 @@
/* 键值对 Number -> String */
class Entry {
public key: number;
public val: string;
constructor(key: number, val: string) {
this.key = key;
this.val = val;
}
}
public key: number;
public val: string;
/* 数组的初始化和基本操作 */
class ArrayList {
private readonly elements: Entry[];
constructor(length: number) {
this.elements = new Array(length);
this.initialize();
}
/* 初始化 */
private initialize() {
this.elements.fill(null as any, 0, this.elements.length - 1);
}
/* 新增和删除 */
public set(key: number, val: string | null) {
if (val !== null) {
this.elements[key] = new Entry(key, val);
} else {
this.elements[key] = null as any;
constructor(key: number, val: string) {
this.key = key;
this.val = val;
}
}
/* 获取 */
public get(key: number): string | null {
if (this.elements[key] instanceof Entry) {
return this.elements[key].val;
}
return null;
}
public entrySet() {
let arr = [];
for (let i = 0; i < this.elements.length; i++) {
if (this.elements[i]) {
arr.push(this.elements[i]);
}
}
return arr;
}
public valueSet() {
let arr = [];
for (let i = 0; i < this.elements.length; i++) {
if (this.elements[i]) {
arr.push(this.elements[i].val);
}
}
return arr;
}
public keySet() {
let arr = [];
for (let i = 0; i < this.elements.length; i++) {
if (this.elements[i]) {
arr.push(this.elements[i].key);
}
}
return arr;
}
}
/* 基于数组简易实现的哈希表 */
class ArrayHashMap {
// 初始化一个长度为 100 的桶（数组）
private bucket: ArrayList;
constructor() {
this.bucket = new ArrayList(100);
}
private readonly bucket: Entry[];
/* 哈希函数 */
private hashFunc(key: number): number {
return key % 100;
}
/* 查询操作 */
public get(key: number): string | null {
let index = this.hashFunc(key);
let val = this.bucket.get(index);
if (val === null) return null;
return val;
}
/* 添加操作 */
public put(key: number, val: string) {
let index = this.hashFunc(key);
this.bucket.set(index, val);
}
/* 删除操作 */
public remove(key: number) {
let index = this.hashFunc(key);
// 置为 null ，代表删除
this.bucket.set(index, null);
}
/* 获取所有键值对 */
public entrySet(): Entry[] {
return this.bucket.entrySet();
}
/* 获取所有键 */
public keySet(): number[] {
return this.bucket.keySet();
}
/* 获取所有值 */
public valueSet(): string[] {
return this.bucket.valueSet();
}
/* 打印哈希表 */
public print() {
let entrySet = this.entrySet();
for (const entry of entrySet) {
if (!entry) continue;
console.info(`${entry.key} -> ${entry.val}`);
constructor() {
// 初始化一个长度为 100 的桶（数组）
this.bucket = (new Array(100)).fill(null as any);
}
/* 哈希函数 */
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 put(key: number, val: string) {
let index = this.hashFunc(key);
this.bucket[index] = new Entry(index, val);
}
/* 删除操作 */
public remove(key: number) {
let index = this.hashFunc(key);
// 置为 null ，代表删除
this.bucket[index] = null as any;
}
/* 获取所有键值对 */
public entrySet(): Entry[] {
let arr = [];
for (let i = 0; i < this.bucket.length; i++) {
if (this.bucket[i]) {
arr.push(this.bucket[i]);
}
}
return arr;
}
/* 获取所有键 */
public keySet(): number[] {
let arr = [];
for (let i = 0; i < this.bucket.length; i++) {
if (this.bucket[i]) {
arr.push(this.bucket[i].key);
}
}
return arr;
}
/* 获取所有值 */
public valueSet(): string[] {
let arr = [];
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.entrySet();
for (const entry of entrySet) {
if (!entry) continue;
console.info(`${entry.key} -> ${entry.val}`);
}
}
}
}
export default ArrayHashMap;
/* 初始化哈希表 */
const map = new ArrayHashMap();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.put(12836, '小哈');
map.put(15937, '小啰');
map.put(16750, '小算');
map.put(13276, '小法');
map.put(10583, '小鸭');
console.info('\n添加完成后，哈希表为\nKey -> Value');
map.print();
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
let name = map.get(15937);
console.info('\n输入学号 15937 ，查询到姓名 ' + name);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.remove(10583);
console.info('\n删除 10583 后，哈希表为\nKey -> Value');
map.print();
/* 遍历哈希表 */
console.info('\n遍历键值对 Key->Value');
for (const entry of map.entrySet()) {
console.info(entry.key + ' -> ' + entry.val);
}
console.info('\n单独遍历键 Key');
for (const key of map.keySet()) {
console.info(key);
}
console.info('\n单独遍历值 Value');
for (const val of map.valueSet()) {
console.info(val);
}
export {};

51
codes/typescript/chapter_hashing/hash_map.ts
View file

@ -1,51 +0,0 @@
/*
* File: hash_map.ts
* Created Time: 2022-12-20
* Author: Daniel (better.sunjian@gmail.com)
*/
import ArrayHashMap from './array_hash_map';
class HashMap {
constructor() {
/* 初始化哈希表 */
const map = new ArrayHashMap();
/* 添加操作 */
// 在哈希表中添加键值对 (key, value)
map.put(12836, '小哈');
map.put(15937, '小啰');
map.put(16750, '小算');
map.put(13276, '小法');
map.put(10583, '小鸭');
console.info('\n添加完成后，哈希表为\nKey -> Value');
map.print();
/* 查询操作 */
// 向哈希表输入键 key ，得到值 value
let name = map.get(15937);
console.info('\n输入学号 15937 ，查询到姓名 ' + name);
/* 删除操作 */
// 在哈希表中删除键值对 (key, value)
map.remove(10583);
console.info('\n删除 10583 后，哈希表为\nKey -> Value');
map.print();
/* 遍历哈希表 */
console.info('\n遍历键值对 Key->Value');
for (const entry of map.entrySet()) {
console.info(entry.key + ' -> ' + entry.val);
}
console.info('\n单独遍历键 Key');
for (const key of map.keySet()) {
console.info(key);
}
console.info('\n单独遍历值 Value');
for (const val of map.valueSet()) {
console.info(val);
}
}
}
export default HashMap;

15
codes/typescript/tsconfig.json
View file

@ -1,15 +0,0 @@
{
"compilerOptions": {
"target": "es6",
"moduleResolution": "node",
"resolveJsonModule": true,
"module": "commonjs",
"strict": true,
"noEmit": false,
"sourceMap": true,
"baseUrl": ".",
"esModuleInterop": true,
"downlevelIteration": true,
},
"include": ["./**/*"],
}

107
docs/chapter_hashing/hash_map.md
View file

@ -512,83 +512,24 @@ $$
```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 ArrayList {
private readonly elements: Entry[];
constructor(length: number) {
this.elements = new Array(length);
this.initialize();
}
/* 初始化 */
private initialize() {
this.elements.fill(null as any, 0, this.elements.length - 1);
}
/* 新增和删除 */
public set(key: number, val: string | null) {
if (val !== null) {
this.elements[key] = new Entry(key, val);
} else {
this.elements[key] = null as any;
}
}
/* 获取 */
public get(key: number): string | null {
if (this.elements[key] instanceof Entry) {
return this.elements[key].val;
}
return null;
}
public entrySet() {
let arr = [];
for (let i = 0; i < this.elements.length; i++) {
if (this.elements[i]) {
arr.push(this.elements[i]);
}
}
return arr;
}
public valueSet() {
let arr = [];
for (let i = 0; i < this.elements.length; i++) {
if (this.elements[i]) {
arr.push(this.elements[i].val);
}
}
return arr;
}
public keySet() {
let arr = [];
for (let i = 0; i < this.elements.length; i++) {
if (this.elements[i]) {
arr.push(this.elements[i].key);
}
}
return arr;
}
}
/* 基于数组简易实现的哈希表 */
class ArrayHashMap {
// 初始化一个长度为 100 的桶（数组）
private bucket: ArrayList;
private readonly bucket: Entry[];
constructor() {
this.bucket = new ArrayList(100);
// 初始化一个长度为 100 的桶（数组）
this.bucket = (new Array(100)).fill(null as any);
}
/* 哈希函数 */
@ -599,37 +540,55 @@ $$
/* 查询操作 */
public get(key: number): string | null {
let index = this.hashFunc(key);
let val = this.bucket.get(index);
if (val === null) return null;
return val;
let entry = this.bucket[index];
if (entry === null) return null;
return entry.val;
}
/* 添加操作 */
public put(key: number, val: string) {
let index = this.hashFunc(key);
this.bucket.set(index, val);
this.bucket[index] = new Entry(index, val);
}
/* 删除操作 */
public remove(key: number) {
let index = this.hashFunc(key);
// 置为 null ，代表删除
this.bucket.set(index, null);
this.bucket[index] = null as any;
}
/* 获取所有键值对 */
public entrySet(): Entry[] {
return this.bucket.entrySet();
let arr = [];
for (let i = 0; i < this.bucket.length; i++) {
if (this.bucket[i]) {
arr.push(this.bucket[i]);
}
}
return arr;
}
/* 获取所有键 */
public keySet(): number[] {
return this.bucket.keySet();
let arr = [];
for (let i = 0; i < this.bucket.length; i++) {
if (this.bucket[i]) {
arr.push(this.bucket[i].key);
}
}
return arr;
}
/* 获取所有值 */
public valueSet(): string[] {
return this.bucket.valueSet();
let arr = [];
for (let i = 0; i < this.bucket.length; i++) {
if (this.bucket[i]) {
arr.push(this.bucket[i].val);
}
}
return arr;
}
}
```