mirror of
https://github.com/krahets/hello-algo.git
synced 2026-07-13 07:46:06 +00:00
Re-translate the Japanese version (#1871)
* Retranslate Japanese docs with GPT-5.4 * Retranslate Japanese code with GPT-5.4
This commit is contained in:
Yudong Jin
@@ -0,0 +1,2 @@
|
||||
node_modules
|
||||
package-lock.json
|
||||
@@ -0,0 +1,6 @@
|
||||
{
|
||||
"tabWidth": 4,
|
||||
"useTabs": false,
|
||||
"semi": true,
|
||||
"singleQuote": true
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
/**
|
||||
* File: array.ts
|
||||
* Created Time: 2022-12-04
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* 要素へランダムアクセス */
|
||||
function randomAccess(nums: number[]): number {
|
||||
// 区間 [0, nums.length) からランダムに 1 つの数を選ぶ
|
||||
const random_index = Math.floor(Math.random() * nums.length);
|
||||
// ランダムな要素を取得して返す
|
||||
const random_num = nums[random_index];
|
||||
return random_num;
|
||||
}
|
||||
|
||||
/* 配列長を拡張する */
|
||||
// TypeScript の Array は動的配列であり、直接拡張できます
|
||||
// 学習しやすいよう、本関数では Array を長さ不変の配列として扱います
|
||||
function extend(nums: number[], enlarge: number): number[] {
|
||||
// 拡張後の長さを持つ配列を初期化する
|
||||
const res = new Array(nums.length + enlarge).fill(0);
|
||||
// 元の配列の全要素を新しい配列にコピー
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
res[i] = nums[i];
|
||||
}
|
||||
// 拡張後の新しい配列を返す
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 配列の index 番目に要素 num を挿入 */
|
||||
function insert(nums: number[], num: number, index: number): void {
|
||||
// インデックス index 以降の全要素を 1 つ後ろへ移動する
|
||||
for (let i = nums.length - 1; i > index; i--) {
|
||||
nums[i] = nums[i - 1];
|
||||
}
|
||||
// index の要素に num を代入する
|
||||
nums[index] = num;
|
||||
}
|
||||
|
||||
/* index の要素を削除する */
|
||||
function remove(nums: number[], index: number): void {
|
||||
// インデックス index より後ろの全要素を 1 つ前へ移動する
|
||||
for (let i = index; i < nums.length - 1; i++) {
|
||||
nums[i] = nums[i + 1];
|
||||
}
|
||||
}
|
||||
|
||||
/* 配列を走査 */
|
||||
function traverse(nums: number[]): void {
|
||||
let count = 0;
|
||||
// インデックスで配列を走査
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
count += nums[i];
|
||||
}
|
||||
// 配列要素を直接走査
|
||||
for (const num of nums) {
|
||||
count += num;
|
||||
}
|
||||
}
|
||||
|
||||
/* 配列内で指定要素を探す */
|
||||
function find(nums: number[], target: number): number {
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
if (nums[i] === target) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 配列を初期化 */
|
||||
const arr: number[] = new Array(5).fill(0);
|
||||
console.log('配列 arr =', arr);
|
||||
let nums: number[] = [1, 3, 2, 5, 4];
|
||||
console.log('配列 nums =', nums);
|
||||
|
||||
/* ランダムアクセス */
|
||||
let random_num = randomAccess(nums);
|
||||
console.log('nums からランダムな要素を取得', random_num);
|
||||
|
||||
/* 長さを拡張 */
|
||||
nums = extend(nums, 3);
|
||||
console.log('配列の長さを 8 に拡張すると、nums =', nums);
|
||||
|
||||
/* 要素を挿入する */
|
||||
insert(nums, 6, 3);
|
||||
console.log('インデックス 3 に数字 6 を挿入すると、nums =', nums);
|
||||
|
||||
/* 要素を削除 */
|
||||
remove(nums, 2);
|
||||
console.log('インデックス 2 の要素を削除すると、nums =', nums);
|
||||
|
||||
/* 配列を走査 */
|
||||
traverse(nums);
|
||||
|
||||
/* 要素を探索する */
|
||||
let index = find(nums, 3);
|
||||
console.log('nums 内で要素 3 を検索すると、インデックス =', index);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,86 @@
|
||||
/**
|
||||
* File: linked_list.ts
|
||||
* Created Time: 2022-12-10
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { ListNode } from '../modules/ListNode';
|
||||
import { printLinkedList } from '../modules/PrintUtil';
|
||||
|
||||
/* 連結リストでノード n0 の後ろにノード P を挿入する */
|
||||
function insert(n0: ListNode, P: ListNode): void {
|
||||
const n1 = n0.next;
|
||||
P.next = n1;
|
||||
n0.next = P;
|
||||
}
|
||||
|
||||
/* 連結リストでノード n0 の直後のノードを削除する */
|
||||
function remove(n0: ListNode): void {
|
||||
if (!n0.next) {
|
||||
return;
|
||||
}
|
||||
// n0 -> P -> n1
|
||||
const P = n0.next;
|
||||
const n1 = P.next;
|
||||
n0.next = n1;
|
||||
}
|
||||
|
||||
/* 連結リスト内で index 番目のノードにアクセス */
|
||||
function access(head: ListNode | null, index: number): ListNode | null {
|
||||
for (let i = 0; i < index; i++) {
|
||||
if (!head) {
|
||||
return null;
|
||||
}
|
||||
head = head.next;
|
||||
}
|
||||
return head;
|
||||
}
|
||||
|
||||
/* 連結リストで値が target の最初のノードを探す */
|
||||
function find(head: ListNode | null, target: number): number {
|
||||
let index = 0;
|
||||
while (head !== null) {
|
||||
if (head.val === target) {
|
||||
return index;
|
||||
}
|
||||
head = head.next;
|
||||
index += 1;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 連結リストを初期化 */
|
||||
// 各ノードを初期化
|
||||
const n0 = new ListNode(1);
|
||||
const n1 = new ListNode(3);
|
||||
const n2 = new ListNode(2);
|
||||
const n3 = new ListNode(5);
|
||||
const n4 = new ListNode(4);
|
||||
// ノード間の参照を構築する
|
||||
n0.next = n1;
|
||||
n1.next = n2;
|
||||
n2.next = n3;
|
||||
n3.next = n4;
|
||||
console.log('初期化された連結リストは');
|
||||
printLinkedList(n0);
|
||||
|
||||
/* ノードを挿入 */
|
||||
insert(n0, new ListNode(0));
|
||||
console.log('ノード挿入後の連結リストは');
|
||||
printLinkedList(n0);
|
||||
|
||||
/* ノードを削除 */
|
||||
remove(n0);
|
||||
console.log('ノード削除後の連結リストは');
|
||||
printLinkedList(n0);
|
||||
|
||||
/* ノードにアクセス */
|
||||
const node = access(n0, 3);
|
||||
console.log(`連結リストのインデックス 3 にあるノードの値 = ${node?.val}`);
|
||||
|
||||
/* ノードを探索 */
|
||||
const index = find(n0, 2);
|
||||
console.log(`連結リスト内で値が 2 のノードのインデックス = ${index}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* File: list.ts
|
||||
* Created Time: 2022-12-10
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* リストを初期化 */
|
||||
const nums: number[] = [1, 3, 2, 5, 4];
|
||||
console.log(`リスト nums = ${nums}`);
|
||||
|
||||
/* 要素にアクセス */
|
||||
const num: number = nums[1];
|
||||
console.log(`インデックス 1 の要素にアクセスすると、num = ${num}`);
|
||||
|
||||
/* 要素を更新 */
|
||||
nums[1] = 0;
|
||||
console.log(`インデックス 1 の要素を 0 に更新すると、nums = ${nums}`);
|
||||
|
||||
/* リストを空にする */
|
||||
nums.length = 0;
|
||||
console.log(`リストを空にすると nums = ${nums}`);
|
||||
|
||||
/* 末尾に要素を追加 */
|
||||
nums.push(1);
|
||||
nums.push(3);
|
||||
nums.push(2);
|
||||
nums.push(5);
|
||||
nums.push(4);
|
||||
console.log(`要素を追加すると nums = ${nums}`);
|
||||
|
||||
/* 中間に要素を挿入 */
|
||||
nums.splice(3, 0, 6);
|
||||
console.log(`インデックス 3 に数字 6 を挿入すると、nums = ${nums}`);
|
||||
|
||||
/* 要素を削除 */
|
||||
nums.splice(3, 1);
|
||||
console.log(`インデックス 3 の要素を削除すると、nums = ${nums}`);
|
||||
|
||||
/* インデックスでリストを走査 */
|
||||
let count = 0;
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
count += nums[i];
|
||||
}
|
||||
/* リスト要素を直接走査 */
|
||||
count = 0;
|
||||
for (const x of nums) {
|
||||
count += x;
|
||||
}
|
||||
|
||||
/* 2 つのリストを連結する */
|
||||
const nums1: number[] = [6, 8, 7, 10, 9];
|
||||
nums.push(...nums1);
|
||||
console.log(`リスト nums1 を nums の後ろに連結すると、nums = ${nums}`);
|
||||
|
||||
/* リストをソート */
|
||||
nums.sort((a, b) => a - b);
|
||||
console.log(`リストをソートすると nums = ${nums}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,141 @@
|
||||
/**
|
||||
* File: my_list.ts
|
||||
* Created Time: 2022-12-11
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* リストクラス */
|
||||
class MyList {
|
||||
private arr: Array<number>; // 配列（リスト要素を格納）
|
||||
private _capacity: number = 10; // リスト容量
|
||||
private _size: number = 0; // リストの長さ（現在の要素数）
|
||||
private extendRatio: number = 2; // リスト拡張時の増加倍率
|
||||
|
||||
/* コンストラクタ */
|
||||
constructor() {
|
||||
this.arr = new Array(this._capacity);
|
||||
}
|
||||
|
||||
/* リストの長さを取得（現在の要素数） */
|
||||
public size(): number {
|
||||
return this._size;
|
||||
}
|
||||
|
||||
/* リスト容量を取得する */
|
||||
public capacity(): number {
|
||||
return this._capacity;
|
||||
}
|
||||
|
||||
/* 要素にアクセス */
|
||||
public get(index: number): number {
|
||||
// インデックスが範囲外なら例外を送出する。以下同様
|
||||
if (index < 0 || index >= this._size) throw new Error('インデックスが範囲外です');
|
||||
return this.arr[index];
|
||||
}
|
||||
|
||||
/* 要素を更新 */
|
||||
public set(index: number, num: number): void {
|
||||
if (index < 0 || index >= this._size) throw new Error('インデックスが範囲外です');
|
||||
this.arr[index] = num;
|
||||
}
|
||||
|
||||
/* 末尾に要素を追加 */
|
||||
public add(num: number): void {
|
||||
// 長さが容量に等しい場合は拡張が必要
|
||||
if (this._size === this._capacity) this.extendCapacity();
|
||||
// 新しい要素をリストの末尾に追加する
|
||||
this.arr[this._size] = num;
|
||||
this._size++;
|
||||
}
|
||||
|
||||
/* 中間に要素を挿入 */
|
||||
public insert(index: number, num: number): void {
|
||||
if (index < 0 || index >= this._size) throw new Error('インデックスが範囲外です');
|
||||
// 要素数が容量を超えると、拡張機構が発動する
|
||||
if (this._size === this._capacity) {
|
||||
this.extendCapacity();
|
||||
}
|
||||
// index 以降の要素をすべて 1 つ後ろへずらす
|
||||
for (let j = this._size - 1; j >= index; j--) {
|
||||
this.arr[j + 1] = this.arr[j];
|
||||
}
|
||||
// 要素数を更新
|
||||
this.arr[index] = num;
|
||||
this._size++;
|
||||
}
|
||||
|
||||
/* 要素を削除 */
|
||||
public remove(index: number): number {
|
||||
if (index < 0 || index >= this._size) throw new Error('インデックスが範囲外です');
|
||||
let num = this.arr[index];
|
||||
// インデックス index より後の要素をすべて 1 つ前に移動する
|
||||
for (let j = index; j < this._size - 1; j++) {
|
||||
this.arr[j] = this.arr[j + 1];
|
||||
}
|
||||
// 要素数を更新
|
||||
this._size--;
|
||||
// 削除された要素を返す
|
||||
return num;
|
||||
}
|
||||
|
||||
/* リストの拡張 */
|
||||
public extendCapacity(): void {
|
||||
// `size` の長さを持つ配列を新規作成し、元の配列を新しい配列にコピーする
|
||||
this.arr = this.arr.concat(
|
||||
new Array(this.capacity() * (this.extendRatio - 1))
|
||||
);
|
||||
// リストの容量を更新
|
||||
this._capacity = this.arr.length;
|
||||
}
|
||||
|
||||
/* リストを配列に変換する */
|
||||
public toArray(): number[] {
|
||||
let size = this.size();
|
||||
// 有効長の範囲内のリスト要素のみを変換
|
||||
const arr = new Array(size);
|
||||
for (let i = 0; i < size; i++) {
|
||||
arr[i] = this.get(i);
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* リストを初期化 */
|
||||
const nums = new MyList();
|
||||
/* 末尾に要素を追加 */
|
||||
nums.add(1);
|
||||
nums.add(3);
|
||||
nums.add(2);
|
||||
nums.add(5);
|
||||
nums.add(4);
|
||||
console.log(
|
||||
`リスト nums = ${nums.toArray()} ，容量 = ${nums.capacity()} ，長さ = ${nums.size()}`
|
||||
);
|
||||
|
||||
/* 中間に要素を挿入 */
|
||||
nums.insert(3, 6);
|
||||
console.log(`インデックス 3 に数字 6 を挿入すると ，nums = ${nums.toArray()}`);
|
||||
|
||||
/* 要素を削除 */
|
||||
nums.remove(3);
|
||||
console.log(`インデックス 3 の要素を削除すると，nums = ${nums.toArray()}`);
|
||||
|
||||
/* 要素にアクセス */
|
||||
const num = nums.get(1);
|
||||
console.log(`インデックス 1 の要素にアクセスすると、num = ${num}`);
|
||||
|
||||
/* 要素を更新 */
|
||||
nums.set(1, 0);
|
||||
console.log(`インデックス 1 の要素を 0 に更新すると ，nums = ${nums.toArray()}`);
|
||||
|
||||
/* 拡張機構をテストする */
|
||||
for (let i = 0; i < 10; i++) {
|
||||
// i = 5 のとき、リスト長が容量を超えるため、この時点で拡張機構が発動する
|
||||
nums.add(i);
|
||||
}
|
||||
console.log(
|
||||
`拡張後のリスト nums = ${nums.toArray()} ，容量 = ${nums.capacity()} ，長さ = ${nums.size()}`
|
||||
);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,65 @@
|
||||
/**
|
||||
* File: n_queens.ts
|
||||
* Created Time: 2023-05-13
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：N クイーン */
|
||||
function backtrack(
|
||||
row: number,
|
||||
n: number,
|
||||
state: string[][],
|
||||
res: string[][][],
|
||||
cols: boolean[],
|
||||
diags1: boolean[],
|
||||
diags2: boolean[]
|
||||
): void {
|
||||
// すべての行への配置が完了したら、解を記録する
|
||||
if (row === n) {
|
||||
res.push(state.map((row) => row.slice()));
|
||||
return;
|
||||
}
|
||||
// すべての列を走査
|
||||
for (let col = 0; col < n; col++) {
|
||||
// このマスに対応する主対角線と副対角線を計算
|
||||
const diag1 = row - col + n - 1;
|
||||
const diag2 = row + col;
|
||||
// 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない
|
||||
if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
|
||||
// 試行：そのマスにクイーンを置く
|
||||
state[row][col] = 'Q';
|
||||
cols[col] = diags1[diag1] = diags2[diag2] = true;
|
||||
// 次の行に配置する
|
||||
backtrack(row + 1, n, state, res, cols, diags1, diags2);
|
||||
// 戻す：そのマスを空きマスに戻す
|
||||
state[row][col] = '#';
|
||||
cols[col] = diags1[diag1] = diags2[diag2] = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* N クイーンを解く */
|
||||
function nQueens(n: number): string[][][] {
|
||||
// n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す
|
||||
const state = Array.from({ length: n }, () => Array(n).fill('#'));
|
||||
const cols = Array(n).fill(false); // 列にクイーンがあるか記録
|
||||
const diags1 = Array(2 * n - 1).fill(false); // 主対角線にクイーンがあるかを記録
|
||||
const diags2 = Array(2 * n - 1).fill(false); // 副対角線にクイーンがあるかを記録
|
||||
const res: string[][][] = [];
|
||||
|
||||
backtrack(0, n, state, res, cols, diags1, diags2);
|
||||
return res;
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
const n = 4;
|
||||
const res = nQueens(n);
|
||||
|
||||
console.log(`入力する盤面の縦横は ${n}`);
|
||||
console.log(`クイーンの配置方法は全部で ${res.length} 種`);
|
||||
res.forEach((state) => {
|
||||
console.log('--------------------');
|
||||
state.forEach((row) => console.log(row));
|
||||
});
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,49 @@
|
||||
/**
|
||||
* File: permutations_i.ts
|
||||
* Created Time: 2023-05-13
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：順列 I */
|
||||
function backtrack(
|
||||
state: number[],
|
||||
choices: number[],
|
||||
selected: boolean[],
|
||||
res: number[][]
|
||||
): void {
|
||||
// 状態の長さが要素数に等しければ、解を記録
|
||||
if (state.length === choices.length) {
|
||||
res.push([...state]);
|
||||
return;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
choices.forEach((choice, i) => {
|
||||
// 枝刈り：要素の重複選択を許可しない
|
||||
if (!selected[i]) {
|
||||
// 試行: 選択を行い、状態を更新
|
||||
selected[i] = true;
|
||||
state.push(choice);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, choices, selected, res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
selected[i] = false;
|
||||
state.pop();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/* 全順列 I */
|
||||
function permutationsI(nums: number[]): number[][] {
|
||||
const res: number[][] = [];
|
||||
backtrack([], nums, Array(nums.length).fill(false), res);
|
||||
return res;
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
const nums: number[] = [1, 2, 3];
|
||||
const res: number[][] = permutationsI(nums);
|
||||
|
||||
console.log(`入力配列 nums = ${JSON.stringify(nums)}`);
|
||||
console.log(`すべての順列 res = ${JSON.stringify(res)}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,51 @@
|
||||
/**
|
||||
* File: permutations_ii.ts
|
||||
* Created Time: 2023-05-13
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：順列 II */
|
||||
function backtrack(
|
||||
state: number[],
|
||||
choices: number[],
|
||||
selected: boolean[],
|
||||
res: number[][]
|
||||
): void {
|
||||
// 状態の長さが要素数に等しければ、解を記録
|
||||
if (state.length === choices.length) {
|
||||
res.push([...state]);
|
||||
return;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
const duplicated = new Set();
|
||||
choices.forEach((choice, i) => {
|
||||
// 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない
|
||||
if (!selected[i] && !duplicated.has(choice)) {
|
||||
// 試行: 選択を行い、状態を更新
|
||||
duplicated.add(choice); // 選択済みの要素値を記録
|
||||
selected[i] = true;
|
||||
state.push(choice);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, choices, selected, res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
selected[i] = false;
|
||||
state.pop();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/* 全順列 II */
|
||||
function permutationsII(nums: number[]): number[][] {
|
||||
const res: number[][] = [];
|
||||
backtrack([], nums, Array(nums.length).fill(false), res);
|
||||
return res;
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
const nums: number[] = [1, 2, 2];
|
||||
const res: number[][] = permutationsII(nums);
|
||||
|
||||
console.log(`入力配列 nums = ${JSON.stringify(nums)}`);
|
||||
console.log(`すべての順列 res = ${JSON.stringify(res)}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,36 @@
|
||||
/**
|
||||
* File: preorder_traversal_i_compact.ts
|
||||
* Created Time: 2023-05-09
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { type TreeNode } from '../modules/TreeNode';
|
||||
import { arrToTree } from '../modules/TreeNode';
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
|
||||
/* 前順走査：例題 1 */
|
||||
function preOrder(root: TreeNode | null, res: TreeNode[]): void {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
if (root.val === 7) {
|
||||
// 解を記録
|
||||
res.push(root);
|
||||
}
|
||||
preOrder(root.left, res);
|
||||
preOrder(root.right, res);
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
|
||||
console.log('\n二分木を初期化');
|
||||
printTree(root);
|
||||
|
||||
// 先行順走査
|
||||
const res: TreeNode[] = [];
|
||||
preOrder(root, res);
|
||||
|
||||
console.log('\n値が 7 のノードをすべて出力');
|
||||
console.log(res.map((node) => node.val));
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,47 @@
|
||||
/**
|
||||
* File: preorder_traversal_ii_compact.ts
|
||||
* Created Time: 2023-05-09
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { type TreeNode } from '../modules/TreeNode';
|
||||
import { arrToTree } from '../modules/TreeNode';
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
|
||||
/* 前順走査：例題 2 */
|
||||
function preOrder(
|
||||
root: TreeNode | null,
|
||||
path: TreeNode[],
|
||||
res: TreeNode[][]
|
||||
): void {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
// 試す
|
||||
path.push(root);
|
||||
if (root.val === 7) {
|
||||
// 解を記録
|
||||
res.push([...path]);
|
||||
}
|
||||
preOrder(root.left, path, res);
|
||||
preOrder(root.right, path, res);
|
||||
// バックトラック
|
||||
path.pop();
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
|
||||
console.log('\n二分木を初期化');
|
||||
printTree(root);
|
||||
|
||||
// 先行順走査
|
||||
const path: TreeNode[] = [];
|
||||
const res: TreeNode[][] = [];
|
||||
preOrder(root, path, res);
|
||||
|
||||
console.log('\nすべての根ノードからノード 7 への経路を出力');
|
||||
res.forEach((path) => {
|
||||
console.log(path.map((node) => node.val));
|
||||
});
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,48 @@
|
||||
/**
|
||||
* File: preorder_traversal_iii_compact.ts
|
||||
* Created Time: 2023-05-09
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { type TreeNode } from '../modules/TreeNode';
|
||||
import { arrToTree } from '../modules/TreeNode';
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
|
||||
/* 前順走査：例題 3 */
|
||||
function preOrder(
|
||||
root: TreeNode | null,
|
||||
path: TreeNode[],
|
||||
res: TreeNode[][]
|
||||
): void {
|
||||
// 枝刈り
|
||||
if (root === null || root.val === 3) {
|
||||
return;
|
||||
}
|
||||
// 試す
|
||||
path.push(root);
|
||||
if (root.val === 7) {
|
||||
// 解を記録
|
||||
res.push([...path]);
|
||||
}
|
||||
preOrder(root.left, path, res);
|
||||
preOrder(root.right, path, res);
|
||||
// バックトラック
|
||||
path.pop();
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
|
||||
console.log('\n二分木を初期化');
|
||||
printTree(root);
|
||||
|
||||
// 先行順走査
|
||||
const path: TreeNode[] = [];
|
||||
const res: TreeNode[][] = [];
|
||||
preOrder(root, path, res);
|
||||
|
||||
console.log('\nすべての根ノードからノード 7 への経路を出力，経路に値が 3 のノードを含まない');
|
||||
res.forEach((path) => {
|
||||
console.log(path.map((node) => node.val));
|
||||
});
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,75 @@
|
||||
/**
|
||||
* File: preorder_traversal_iii_template.ts
|
||||
* Created Time: 2023-05-09
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { type TreeNode } from '../modules/TreeNode';
|
||||
import { arrToTree } from '../modules/TreeNode';
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
|
||||
/* 現在の状態が解かどうかを判定 */
|
||||
function isSolution(state: TreeNode[]): boolean {
|
||||
return state && state[state.length - 1]?.val === 7;
|
||||
}
|
||||
|
||||
/* 解を記録 */
|
||||
function recordSolution(state: TreeNode[], res: TreeNode[][]): void {
|
||||
res.push([...state]);
|
||||
}
|
||||
|
||||
/* 現在の状態で、この選択が有効かどうかを判定 */
|
||||
function isValid(state: TreeNode[], choice: TreeNode): boolean {
|
||||
return choice !== null && choice.val !== 3;
|
||||
}
|
||||
|
||||
/* 状態を更新 */
|
||||
function makeChoice(state: TreeNode[], choice: TreeNode): void {
|
||||
state.push(choice);
|
||||
}
|
||||
|
||||
/* 状態を元に戻す */
|
||||
function undoChoice(state: TreeNode[]): void {
|
||||
state.pop();
|
||||
}
|
||||
|
||||
/* バックトラッキング：例題 3 */
|
||||
function backtrack(
|
||||
state: TreeNode[],
|
||||
choices: TreeNode[],
|
||||
res: TreeNode[][]
|
||||
): void {
|
||||
// 解かどうかを確認
|
||||
if (isSolution(state)) {
|
||||
// 解を記録
|
||||
recordSolution(state, res);
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
for (const choice of choices) {
|
||||
// 枝刈り：選択が妥当かを確認する
|
||||
if (isValid(state, choice)) {
|
||||
// 試行: 選択を行い、状態を更新
|
||||
makeChoice(state, choice);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, [choice.left, choice.right], res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
undoChoice(state);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Driver Code
|
||||
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
|
||||
console.log('\n二分木を初期化');
|
||||
printTree(root);
|
||||
|
||||
// バックトラッキング法
|
||||
const res: TreeNode[][] = [];
|
||||
backtrack([], [root], res);
|
||||
|
||||
console.log('\nすべての根ノードからノード 7 への経路を出力，経路に値が 3 のノードを含まないことを条件とする');
|
||||
res.forEach((path) => {
|
||||
console.log(path.map((node) => node.val));
|
||||
});
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,54 @@
|
||||
/**
|
||||
* File: subset_sum_i.ts
|
||||
* Created Time: 2023-07-30
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：部分和 I */
|
||||
function backtrack(
|
||||
state: number[],
|
||||
target: number,
|
||||
choices: number[],
|
||||
start: number,
|
||||
res: number[][]
|
||||
): void {
|
||||
// 部分集合の和が target に等しければ、解を記録
|
||||
if (target === 0) {
|
||||
res.push([...state]);
|
||||
return;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
|
||||
for (let i = start; i < choices.length; i++) {
|
||||
// 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
|
||||
// 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
|
||||
if (target - choices[i] < 0) {
|
||||
break;
|
||||
}
|
||||
// 試す：選択を行い、target と start を更新
|
||||
state.push(choices[i]);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, target - choices[i], choices, i, res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
state.pop();
|
||||
}
|
||||
}
|
||||
|
||||
/* 部分和 I を解く */
|
||||
function subsetSumI(nums: number[], target: number): number[][] {
|
||||
const state = []; // 状態（部分集合）
|
||||
nums.sort((a, b) => a - b); // nums をソート
|
||||
const start = 0; // 開始点を走査
|
||||
const res = []; // 結果リスト（部分集合のリスト）
|
||||
backtrack(state, target, nums, start, res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums = [3, 4, 5];
|
||||
const target = 9;
|
||||
const res = subsetSumI(nums, target);
|
||||
console.log(`入力配列 nums = ${JSON.stringify(nums)}, target = ${target}`);
|
||||
console.log(`合計が ${target} に等しいすべての部分集合 res = ${JSON.stringify(res)}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* File: subset_sum_i_naive.ts
|
||||
* Created Time: 2023-07-30
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：部分和 I */
|
||||
function backtrack(
|
||||
state: number[],
|
||||
target: number,
|
||||
total: number,
|
||||
choices: number[],
|
||||
res: number[][]
|
||||
): void {
|
||||
// 部分集合の和が target に等しければ、解を記録
|
||||
if (total === target) {
|
||||
res.push([...state]);
|
||||
return;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
for (let i = 0; i < choices.length; i++) {
|
||||
// 枝刈り：部分和が target を超える場合はその選択をスキップする
|
||||
if (total + choices[i] > target) {
|
||||
continue;
|
||||
}
|
||||
// 試行：選択を行い、要素と total を更新する
|
||||
state.push(choices[i]);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, target, total + choices[i], choices, res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
state.pop();
|
||||
}
|
||||
}
|
||||
|
||||
/* 部分和 I を解く（重複部分集合を含む） */
|
||||
function subsetSumINaive(nums: number[], target: number): number[][] {
|
||||
const state = []; // 状態（部分集合）
|
||||
const total = 0; // 部分和
|
||||
const res = []; // 結果リスト（部分集合のリスト）
|
||||
backtrack(state, target, total, nums, res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums = [3, 4, 5];
|
||||
const target = 9;
|
||||
const res = subsetSumINaive(nums, target);
|
||||
console.log(`入力配列 nums = ${JSON.stringify(nums)}, target = ${target}`);
|
||||
console.log(`合計が ${target} に等しいすべての部分集合 res = ${JSON.stringify(res)}`);
|
||||
console.log('この方法で出力される結果には重複する集合が含まれます');
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* File: subset_sum_ii.ts
|
||||
* Created Time: 2023-07-30
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：部分和 II */
|
||||
function backtrack(
|
||||
state: number[],
|
||||
target: number,
|
||||
choices: number[],
|
||||
start: number,
|
||||
res: number[][]
|
||||
): void {
|
||||
// 部分集合の和が target に等しければ、解を記録
|
||||
if (target === 0) {
|
||||
res.push([...state]);
|
||||
return;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
|
||||
// 枝刈り 3: start から走査し、同じ要素の重複選択を避ける
|
||||
for (let i = start; i < choices.length; i++) {
|
||||
// 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
|
||||
// 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
|
||||
if (target - choices[i] < 0) {
|
||||
break;
|
||||
}
|
||||
// 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする
|
||||
if (i > start && choices[i] === choices[i - 1]) {
|
||||
continue;
|
||||
}
|
||||
// 試す：選択を行い、target と start を更新
|
||||
state.push(choices[i]);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, target - choices[i], choices, i + 1, res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
state.pop();
|
||||
}
|
||||
}
|
||||
|
||||
/* 部分和 II を解く */
|
||||
function subsetSumII(nums: number[], target: number): number[][] {
|
||||
const state = []; // 状態（部分集合）
|
||||
nums.sort((a, b) => a - b); // nums をソート
|
||||
const start = 0; // 開始点を走査
|
||||
const res = []; // 結果リスト（部分集合のリスト）
|
||||
backtrack(state, target, nums, start, res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums = [4, 4, 5];
|
||||
const target = 9;
|
||||
const res = subsetSumII(nums, target);
|
||||
console.log(`入力配列 nums = ${JSON.stringify(nums)}, target = ${target}`);
|
||||
console.log(`合計が ${target} に等しいすべての部分集合 res = ${JSON.stringify(res)}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,72 @@
|
||||
/**
|
||||
* File: iteration.ts
|
||||
* Created Time: 2023-08-28
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
|
||||
/* for ループ */
|
||||
function forLoop(n: number): number {
|
||||
let res = 0;
|
||||
// 1, 2, ..., n-1, n を順に加算する
|
||||
for (let i = 1; i <= n; i++) {
|
||||
res += i;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* while ループ */
|
||||
function whileLoop(n: number): number {
|
||||
let res = 0;
|
||||
let i = 1; // 条件変数を初期化する
|
||||
// 1, 2, ..., n-1, n を順に加算する
|
||||
while (i <= n) {
|
||||
res += i;
|
||||
i++; // 条件変数を更新する
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* while ループ（2回更新） */
|
||||
function whileLoopII(n: number): number {
|
||||
let res = 0;
|
||||
let i = 1; // 条件変数を初期化する
|
||||
// 1, 4, 10, ... を順に加算する
|
||||
while (i <= n) {
|
||||
res += i;
|
||||
// 条件変数を更新する
|
||||
i++;
|
||||
i *= 2;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 二重 for ループ */
|
||||
function nestedForLoop(n: number): string {
|
||||
let res = '';
|
||||
// i = 1, 2, ..., n-1, n とループする
|
||||
for (let i = 1; i <= n; i++) {
|
||||
// j = 1, 2, ..., n-1, n とループする
|
||||
for (let j = 1; j <= n; j++) {
|
||||
res += `(${i}, ${j}), `;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const n = 5;
|
||||
let res: number;
|
||||
|
||||
res = forLoop(n);
|
||||
console.log(`for ループの合計結果 res = ${res}`);
|
||||
|
||||
res = whileLoop(n);
|
||||
console.log(`while ループの合計結果 res = ${res}`);
|
||||
|
||||
res = whileLoopII(n);
|
||||
console.log(`while ループ（2 回更新）の合計結果 res = ${res}`);
|
||||
|
||||
const resStr = nestedForLoop(n);
|
||||
console.log(`二重 for ループの走査結果 ${resStr}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,70 @@
|
||||
/**
|
||||
* File: recursion.ts
|
||||
* Created Time: 2023-08-28
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
|
||||
/* 再帰 */
|
||||
function recur(n: number): number {
|
||||
// 終了条件
|
||||
if (n === 1) return 1;
|
||||
// 再帰：再帰呼び出し
|
||||
const res = recur(n - 1);
|
||||
// 帰りがけ：結果を返す
|
||||
return n + res;
|
||||
}
|
||||
|
||||
/* 反復で再帰を模擬する */
|
||||
function forLoopRecur(n: number): number {
|
||||
// 明示的なスタックを使ってシステムコールスタックを模擬する
|
||||
const stack: number[] = [];
|
||||
let res: number = 0;
|
||||
// 再帰：再帰呼び出し
|
||||
for (let i = n; i > 0; i--) {
|
||||
// 「スタックへのプッシュ」で「再帰」を模擬する
|
||||
stack.push(i);
|
||||
}
|
||||
// 帰りがけ：結果を返す
|
||||
while (stack.length) {
|
||||
// 「スタックから取り出す操作」で「帰り」をシミュレート
|
||||
res += stack.pop();
|
||||
}
|
||||
// res = 1+2+3+...+n
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 末尾再帰 */
|
||||
function tailRecur(n: number, res: number): number {
|
||||
// 終了条件
|
||||
if (n === 0) return res;
|
||||
// 末尾再帰呼び出し
|
||||
return tailRecur(n - 1, res + n);
|
||||
}
|
||||
|
||||
/* フィボナッチ数列：再帰 */
|
||||
function fib(n: number): number {
|
||||
// 終了条件 f(1) = 0, f(2) = 1
|
||||
if (n === 1 || n === 2) return n - 1;
|
||||
// f(n) = f(n-1) + f(n-2) を再帰的に呼び出す
|
||||
const res = fib(n - 1) + fib(n - 2);
|
||||
// 結果 f(n) を返す
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const n = 5;
|
||||
let res: number;
|
||||
|
||||
res = recur(n);
|
||||
console.log(`再帰関数の合計結果 res = ${res}`);
|
||||
|
||||
res = forLoopRecur(n);
|
||||
console.log(`反復で再帰をシミュレートした合計結果 res = ${res}`);
|
||||
|
||||
res = tailRecur(n, 0);
|
||||
console.log(`末尾再帰関数の合計結果 res = ${res}`);
|
||||
|
||||
res = fib(n);
|
||||
console.log(`フィボナッチ数列の第 ${n} 項は ${res}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,103 @@
|
||||
/**
|
||||
* File: space_complexity.ts
|
||||
* Created Time: 2023-02-05
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { ListNode } from '../modules/ListNode';
|
||||
import { TreeNode } from '../modules/TreeNode';
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
|
||||
/* 関数 */
|
||||
function constFunc(): number {
|
||||
// 何らかの処理を行う
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* 定数階 */
|
||||
function constant(n: number): void {
|
||||
// 定数、変数、オブジェクトは O(1) の空間を占める
|
||||
const a = 0;
|
||||
const b = 0;
|
||||
const nums = new Array(10000);
|
||||
const node = new ListNode(0);
|
||||
// ループ内の変数は O(1) の空間を占める
|
||||
for (let i = 0; i < n; i++) {
|
||||
const c = 0;
|
||||
}
|
||||
// ループ内の関数は O(1) の空間を占める
|
||||
for (let i = 0; i < n; i++) {
|
||||
constFunc();
|
||||
}
|
||||
}
|
||||
|
||||
/* 線形階 */
|
||||
function linear(n: number): void {
|
||||
// 長さ n の配列は O(n) の空間を使用
|
||||
const nums = new Array(n);
|
||||
// 長さ n のリストは O(n) の空間を使用
|
||||
const nodes: ListNode[] = [];
|
||||
for (let i = 0; i < n; i++) {
|
||||
nodes.push(new ListNode(i));
|
||||
}
|
||||
// 長さ n のハッシュテーブルは O(n) の空間を使用
|
||||
const map = new Map();
|
||||
for (let i = 0; i < n; i++) {
|
||||
map.set(i, i.toString());
|
||||
}
|
||||
}
|
||||
|
||||
/* 線形時間（再帰実装） */
|
||||
function linearRecur(n: number): void {
|
||||
console.log(`再帰 n = ${n}`);
|
||||
if (n === 1) return;
|
||||
linearRecur(n - 1);
|
||||
}
|
||||
|
||||
/* 二乗階 */
|
||||
function quadratic(n: number): void {
|
||||
// 行列は O(n^2) の空間を使用する
|
||||
const numMatrix = Array(n)
|
||||
.fill(null)
|
||||
.map(() => Array(n).fill(null));
|
||||
// 二次元リストは O(n^2) の空間を使用
|
||||
const numList = [];
|
||||
for (let i = 0; i < n; i++) {
|
||||
const tmp = [];
|
||||
for (let j = 0; j < n; j++) {
|
||||
tmp.push(0);
|
||||
}
|
||||
numList.push(tmp);
|
||||
}
|
||||
}
|
||||
|
||||
/* 二次時間（再帰実装） */
|
||||
function quadraticRecur(n: number): number {
|
||||
if (n <= 0) return 0;
|
||||
const nums = new Array(n);
|
||||
console.log(`再帰 n = ${n} における nums の長さ = ${nums.length}`);
|
||||
return quadraticRecur(n - 1);
|
||||
}
|
||||
|
||||
/* 指数時間（完全二分木の構築） */
|
||||
function buildTree(n: number): TreeNode | null {
|
||||
if (n === 0) return null;
|
||||
const root = new TreeNode(0);
|
||||
root.left = buildTree(n - 1);
|
||||
root.right = buildTree(n - 1);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const n = 5;
|
||||
// 定数階
|
||||
constant(n);
|
||||
// 線形階
|
||||
linear(n);
|
||||
linearRecur(n);
|
||||
// 二乗階
|
||||
quadratic(n);
|
||||
quadraticRecur(n);
|
||||
// 指数オーダー
|
||||
const root = buildTree(n);
|
||||
printTree(root);
|
||||
@@ -0,0 +1,157 @@
|
||||
/**
|
||||
* File: time_complexity.ts
|
||||
* Created Time: 2023-01-02
|
||||
* Author: RiverTwilight (contact@rene.wang)
|
||||
*/
|
||||
|
||||
/* 定数階 */
|
||||
function constant(n: number): number {
|
||||
let count = 0;
|
||||
const size = 100000;
|
||||
for (let i = 0; i < size; i++) count++;
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 線形階 */
|
||||
function linear(n: number): number {
|
||||
let count = 0;
|
||||
for (let i = 0; i < n; i++) count++;
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 線形時間（配列を走査） */
|
||||
function arrayTraversal(nums: number[]): number {
|
||||
let count = 0;
|
||||
// ループ回数は配列長に比例する
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 二乗階 */
|
||||
function quadratic(n: number): number {
|
||||
let count = 0;
|
||||
// ループ回数はデータサイズ n の二乗に比例する
|
||||
for (let i = 0; i < n; i++) {
|
||||
for (let j = 0; j < n; j++) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 二次時間（バブルソート） */
|
||||
function bubbleSort(nums: number[]): number {
|
||||
let count = 0; // カウンタ
|
||||
// 外側のループ：未ソート区間は [0, i]
|
||||
for (let i = nums.length - 1; i > 0; i--) {
|
||||
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
|
||||
for (let j = 0; j < i; j++) {
|
||||
if (nums[j] > nums[j + 1]) {
|
||||
// nums[j] と nums[j + 1] を交換
|
||||
let tmp = nums[j];
|
||||
nums[j] = nums[j + 1];
|
||||
nums[j + 1] = tmp;
|
||||
count += 3; // 要素交換には 3 回の単位操作が含まれる
|
||||
}
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 指数時間（ループ実装） */
|
||||
function exponential(n: number): number {
|
||||
let count = 0,
|
||||
base = 1;
|
||||
// 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する
|
||||
for (let i = 0; i < n; i++) {
|
||||
for (let j = 0; j < base; j++) {
|
||||
count++;
|
||||
}
|
||||
base *= 2;
|
||||
}
|
||||
// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 指数時間（再帰実装） */
|
||||
function expRecur(n: number): number {
|
||||
if (n === 1) return 1;
|
||||
return expRecur(n - 1) + expRecur(n - 1) + 1;
|
||||
}
|
||||
|
||||
/* 対数時間（ループ実装） */
|
||||
function logarithmic(n: number): number {
|
||||
let count = 0;
|
||||
while (n > 1) {
|
||||
n = n / 2;
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 対数時間（再帰実装） */
|
||||
function logRecur(n: number): number {
|
||||
if (n <= 1) return 0;
|
||||
return logRecur(n / 2) + 1;
|
||||
}
|
||||
|
||||
/* 線形対数時間 */
|
||||
function linearLogRecur(n: number): number {
|
||||
if (n <= 1) return 1;
|
||||
let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
|
||||
for (let i = 0; i < n; i++) {
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 階乗時間（再帰実装） */
|
||||
function factorialRecur(n: number): number {
|
||||
if (n === 0) return 1;
|
||||
let count = 0;
|
||||
// 1個から n 個に分裂
|
||||
for (let i = 0; i < n; i++) {
|
||||
count += factorialRecur(n - 1);
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
// n を変えて実行し、各計算量で操作回数がどう変化するかを確認できる
|
||||
const n = 8;
|
||||
console.log('入力データサイズ n = ' + n);
|
||||
|
||||
let count = constant(n);
|
||||
console.log('定数時間の操作回数 = ' + count);
|
||||
|
||||
count = linear(n);
|
||||
console.log('線形時間の操作回数 = ' + count);
|
||||
count = arrayTraversal(new Array(n));
|
||||
console.log('線形時間（配列の走査）の操作回数 = ' + count);
|
||||
|
||||
count = quadratic(n);
|
||||
console.log('二乗時間の操作回数 = ' + count);
|
||||
var nums = new Array(n);
|
||||
for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
|
||||
count = bubbleSort(nums);
|
||||
console.log('二乗時間（バブルソート）の操作回数 = ' + count);
|
||||
|
||||
count = exponential(n);
|
||||
console.log('指数時間（ループ実装）の操作回数 = ' + count);
|
||||
count = expRecur(n);
|
||||
console.log('指数時間（再帰実装）の操作回数 = ' + count);
|
||||
|
||||
count = logarithmic(n);
|
||||
console.log('対数時間（ループ実装）の操作回数 = ' + count);
|
||||
count = logRecur(n);
|
||||
console.log('対数時間（再帰実装）の操作回数 = ' + count);
|
||||
|
||||
count = linearLogRecur(n);
|
||||
console.log('線形対数時間（再帰実装）の操作回数 = ' + count);
|
||||
|
||||
count = factorialRecur(n);
|
||||
console.log('階乗時間（再帰実装）の操作回数 = ' + count);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,45 @@
|
||||
/**
|
||||
* File: worst_best_time_complexity.ts
|
||||
* Created Time: 2023-01-05
|
||||
* Author: RiverTwilight (contact@rene.wang)
|
||||
*/
|
||||
|
||||
/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */
|
||||
function randomNumbers(n: number): number[] {
|
||||
const nums = Array(n);
|
||||
// 配列 nums = { 1, 2, 3, ..., n } を生成
|
||||
for (let i = 0; i < n; i++) {
|
||||
nums[i] = i + 1;
|
||||
}
|
||||
// 配列要素をランダムにシャッフル
|
||||
for (let i = 0; i < n; i++) {
|
||||
const r = Math.floor(Math.random() * (i + 1));
|
||||
const temp = nums[i];
|
||||
nums[i] = nums[r];
|
||||
nums[r] = temp;
|
||||
}
|
||||
return nums;
|
||||
}
|
||||
|
||||
/* 配列 nums 内で数値 1 のインデックスを探す */
|
||||
function findOne(nums: number[]): number {
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
// 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる
|
||||
// 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる
|
||||
if (nums[i] === 1) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
for (let i = 0; i < 10; i++) {
|
||||
const n = 100;
|
||||
const nums = randomNumbers(n);
|
||||
const index = findOne(nums);
|
||||
console.log('\n配列 [ 1, 2, ..., n ] をシャッフルした後 = [' + nums.join(', ') + ']');
|
||||
console.log('数字 1 のインデックスは ' + index);
|
||||
}
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,41 @@
|
||||
/**
|
||||
* File: binary_search_recur.ts
|
||||
* Created Time: 2023-07-30
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
/* 二分探索：問題 f(i, j) */
|
||||
function dfs(nums: number[], target: number, i: number, j: number): number {
|
||||
// 区間が空なら対象要素は存在しないので -1 を返す
|
||||
if (i > j) {
|
||||
return -1;
|
||||
}
|
||||
// 中点インデックス m を計算
|
||||
const m = i + ((j - i) >> 1);
|
||||
if (nums[m] < target) {
|
||||
// 部分問題 f(m+1, j) を再帰的に解く
|
||||
return dfs(nums, target, m + 1, j);
|
||||
} else if (nums[m] > target) {
|
||||
// 部分問題 f(i, m-1) を再帰的に解く
|
||||
return dfs(nums, target, i, m - 1);
|
||||
} else {
|
||||
// 目標要素が見つかったらそのインデックスを返す
|
||||
return m;
|
||||
}
|
||||
}
|
||||
|
||||
/* 二分探索 */
|
||||
function binarySearch(nums: number[], target: number): number {
|
||||
const n = nums.length;
|
||||
// 問題 f(0, n-1) を解く
|
||||
return dfs(nums, target, 0, n - 1);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const target = 6;
|
||||
const nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
|
||||
// 二分探索（両閉区間）
|
||||
const index = binarySearch(nums, target);
|
||||
console.log(`対象要素 6 のインデックス = ${index}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* File: build_tree.ts
|
||||
* Created Time: 2023-07-30
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
import { TreeNode } from '../modules/TreeNode';
|
||||
|
||||
/* 二分木を構築：分割統治 */
|
||||
function dfs(
|
||||
preorder: number[],
|
||||
inorderMap: Map<number, number>,
|
||||
i: number,
|
||||
l: number,
|
||||
r: number
|
||||
): TreeNode | null {
|
||||
// 部分木区間が空なら終了する
|
||||
if (r - l < 0) return null;
|
||||
// ルートノードを初期化する
|
||||
const root: TreeNode = new TreeNode(preorder[i]);
|
||||
// m を求めて左右部分木を分割する
|
||||
const m = inorderMap.get(preorder[i]);
|
||||
// 部分問題：左部分木を構築する
|
||||
root.left = dfs(preorder, inorderMap, i + 1, l, m - 1);
|
||||
// 部分問題：右部分木を構築する
|
||||
root.right = dfs(preorder, inorderMap, i + 1 + m - l, m + 1, r);
|
||||
// 根ノードを返す
|
||||
return root;
|
||||
}
|
||||
|
||||
/* 二分木を構築 */
|
||||
function buildTree(preorder: number[], inorder: number[]): TreeNode | null {
|
||||
// inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する
|
||||
let inorderMap = new Map<number, number>();
|
||||
for (let i = 0; i < inorder.length; i++) {
|
||||
inorderMap.set(inorder[i], i);
|
||||
}
|
||||
const root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const preorder = [3, 9, 2, 1, 7];
|
||||
const inorder = [9, 3, 1, 2, 7];
|
||||
console.log('前順走査 = ' + JSON.stringify(preorder));
|
||||
console.log('中順走査 = ' + JSON.stringify(inorder));
|
||||
const root = buildTree(preorder, inorder);
|
||||
console.log('構築した二分木：');
|
||||
printTree(root);
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* File: hanota.ts
|
||||
* Created Time: 2023-07-30
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
/* 円盤を 1 枚移動 */
|
||||
function move(src: number[], tar: number[]): void {
|
||||
// src の上から円盤を1枚取り出す
|
||||
const pan = src.pop();
|
||||
// 円盤を tar の上に置く
|
||||
tar.push(pan);
|
||||
}
|
||||
|
||||
/* ハノイの塔の問題 f(i) を解く */
|
||||
function dfs(i: number, src: number[], buf: number[], tar: number[]): void {
|
||||
// src に円盤が 1 枚だけ残っている場合は、そのまま tar へ移す
|
||||
if (i === 1) {
|
||||
move(src, tar);
|
||||
return;
|
||||
}
|
||||
// 部分問題 f(i-1)：src の上部 i-1 枚の円盤を tar を補助にして buf へ移す
|
||||
dfs(i - 1, src, tar, buf);
|
||||
// 部分問題 f(1)：src に残る 1 枚の円盤を tar に移す
|
||||
move(src, tar);
|
||||
// 部分問題 f(i-1)：buf の上部 i-1 枚の円盤を src を補助にして tar へ移す
|
||||
dfs(i - 1, buf, src, tar);
|
||||
}
|
||||
|
||||
/* ハノイの塔を解く */
|
||||
function solveHanota(A: number[], B: number[], C: number[]): void {
|
||||
const n = A.length;
|
||||
// A の上から n 枚の円盤を B を介して C へ移す
|
||||
dfs(n, A, B, C);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
// リスト末尾が柱の頂上
|
||||
const A = [5, 4, 3, 2, 1];
|
||||
const B = [];
|
||||
const C = [];
|
||||
console.log('初期状態：');
|
||||
console.log(`A = ${JSON.stringify(A)}`);
|
||||
console.log(`B = ${JSON.stringify(B)}`);
|
||||
console.log(`C = ${JSON.stringify(C)}`);
|
||||
|
||||
solveHanota(A, B, C);
|
||||
|
||||
console.log('円盤の移動完了後：');
|
||||
console.log(`A = ${JSON.stringify(A)}`);
|
||||
console.log(`B = ${JSON.stringify(B)}`);
|
||||
console.log(`C = ${JSON.stringify(C)}`);
|
||||
@@ -0,0 +1,41 @@
|
||||
/**
|
||||
* File: climbing_stairs_backtrack.ts
|
||||
* Created Time: 2023-07-26
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング */
|
||||
function backtrack(
|
||||
choices: number[],
|
||||
state: number,
|
||||
n: number,
|
||||
res: Map<0, any>
|
||||
): void {
|
||||
// 第 n 段に到達したら、方法数を 1 増やす
|
||||
if (state === n) res.set(0, res.get(0) + 1);
|
||||
// すべての選択肢を走査
|
||||
for (const choice of choices) {
|
||||
// 枝刈り: 第 n 段を超えないようにする
|
||||
if (state + choice > n) continue;
|
||||
// 試行: 選択を行い、状態を更新
|
||||
backtrack(choices, state + choice, n, res);
|
||||
// バックトラック
|
||||
}
|
||||
}
|
||||
|
||||
/* 階段登り：バックトラッキング */
|
||||
function climbingStairsBacktrack(n: number): number {
|
||||
const choices = [1, 2]; // 1 段または 2 段上ることを選べる
|
||||
const state = 0; // 第 0 段から上り始める
|
||||
const res = new Map();
|
||||
res.set(0, 0); // res[0] を使って方法数を記録する
|
||||
backtrack(choices, state, n, res);
|
||||
return res.get(0);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const n = 9;
|
||||
const res = climbingStairsBacktrack(n);
|
||||
console.log(`${n} 段の階段を登る方法は ${res} 通り`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* File: climbing_stairs_constraint_dp.ts
|
||||
* Created Time: 2023-08-23
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
|
||||
/* 制約付き階段登り：動的計画法 */
|
||||
function climbingStairsConstraintDP(n: number): number {
|
||||
if (n === 1 || n === 2) {
|
||||
return 1;
|
||||
}
|
||||
// 部分問題の解を保存するために dp テーブルを初期化
|
||||
const dp = Array.from({ length: n + 1 }, () => new Array(3));
|
||||
// 初期状態：最小部分問題の解をあらかじめ設定
|
||||
dp[1][1] = 1;
|
||||
dp[1][2] = 0;
|
||||
dp[2][1] = 0;
|
||||
dp[2][2] = 1;
|
||||
// 状態遷移：小さい部分問題から大きい部分問題へ順に解く
|
||||
for (let i = 3; i <= n; i++) {
|
||||
dp[i][1] = dp[i - 1][2];
|
||||
dp[i][2] = dp[i - 2][1] + dp[i - 2][2];
|
||||
}
|
||||
return dp[n][1] + dp[n][2];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const n = 9;
|
||||
const res = climbingStairsConstraintDP(n);
|
||||
console.log(`${n} 段の階段を登る方法は ${res} 通り`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,26 @@
|
||||
/**
|
||||
* File: climbing_stairs_dfs.ts
|
||||
* Created Time: 2023-07-26
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
/* 検索 */
|
||||
function dfs(i: number): number {
|
||||
// dp[1] と dp[2] は既知なので返す
|
||||
if (i === 1 || i === 2) return i;
|
||||
// dp[i] = dp[i-1] + dp[i-2]
|
||||
const count = dfs(i - 1) + dfs(i - 2);
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 階段登り：探索 */
|
||||
function climbingStairsDFS(n: number): number {
|
||||
return dfs(n);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const n = 9;
|
||||
const res = climbingStairsDFS(n);
|
||||
console.log(`${n} 段の階段を登る方法は ${res} 通り`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* File: climbing_stairs_dfs_mem.ts
|
||||
* Created Time: 2023-07-26
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
/* メモ化探索 */
|
||||
function dfs(i: number, mem: number[]): number {
|
||||
// dp[1] と dp[2] は既知なので返す
|
||||
if (i === 1 || i === 2) return i;
|
||||
// dp[i] の記録があれば、それをそのまま返す
|
||||
if (mem[i] != -1) return mem[i];
|
||||
// dp[i] = dp[i-1] + dp[i-2]
|
||||
const count = dfs(i - 1, mem) + dfs(i - 2, mem);
|
||||
// dp[i] を記録する
|
||||
mem[i] = count;
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 階段登り：メモ化探索 */
|
||||
function climbingStairsDFSMem(n: number): number {
|
||||
// mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す
|
||||
const mem = new Array(n + 1).fill(-1);
|
||||
return dfs(n, mem);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const n = 9;
|
||||
const res = climbingStairsDFSMem(n);
|
||||
console.log(`${n} 段の階段を登る方法は ${res} 通り`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,42 @@
|
||||
/**
|
||||
* File: climbing_stairs_dp.ts
|
||||
* Created Time: 2023-07-26
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
/* 階段登り：動的計画法 */
|
||||
function climbingStairsDP(n: number): number {
|
||||
if (n === 1 || n === 2) return n;
|
||||
// 部分問題の解を保存するために dp テーブルを初期化
|
||||
const dp = new Array(n + 1).fill(-1);
|
||||
// 初期状態：最小部分問題の解をあらかじめ設定
|
||||
dp[1] = 1;
|
||||
dp[2] = 2;
|
||||
// 状態遷移：小さい部分問題から大きい部分問題へ順に解く
|
||||
for (let i = 3; i <= n; i++) {
|
||||
dp[i] = dp[i - 1] + dp[i - 2];
|
||||
}
|
||||
return dp[n];
|
||||
}
|
||||
|
||||
/* 階段登り：空間最適化した動的計画法 */
|
||||
function climbingStairsDPComp(n: number): number {
|
||||
if (n === 1 || n === 2) return n;
|
||||
let a = 1,
|
||||
b = 2;
|
||||
for (let i = 3; i <= n; i++) {
|
||||
const tmp = b;
|
||||
b = a + b;
|
||||
a = tmp;
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const n = 9;
|
||||
let res = climbingStairsDP(n);
|
||||
console.log(`${n} 段の階段を登る方法は ${res} 通り`);
|
||||
res = climbingStairsDPComp(n);
|
||||
console.log(`${n} 段の階段を登る方法は ${res} 通り`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,68 @@
|
||||
/**
|
||||
* File: coin_change.ts
|
||||
* Created Time: 2023-08-23
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
|
||||
/* コイン両替：動的計画法 */
|
||||
function coinChangeDP(coins: Array<number>, amt: number): number {
|
||||
const n = coins.length;
|
||||
const MAX = amt + 1;
|
||||
// dp テーブルを初期化
|
||||
const dp = Array.from({ length: n + 1 }, () =>
|
||||
Array.from({ length: amt + 1 }, () => 0)
|
||||
);
|
||||
// 状態遷移：先頭行と先頭列
|
||||
for (let a = 1; a <= amt; a++) {
|
||||
dp[0][a] = MAX;
|
||||
}
|
||||
// 状態遷移: 残りの行と列
|
||||
for (let i = 1; i <= n; i++) {
|
||||
for (let a = 1; a <= amt; a++) {
|
||||
if (coins[i - 1] > a) {
|
||||
// 目標金額を超えるなら硬貨 i は選ばない
|
||||
dp[i][a] = dp[i - 1][a];
|
||||
} else {
|
||||
// 硬貨 i を選ばない場合と選ぶ場合の小さい方
|
||||
dp[i][a] = Math.min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[n][amt] !== MAX ? dp[n][amt] : -1;
|
||||
}
|
||||
|
||||
/* コイン交換：空間最適化後の動的計画法 */
|
||||
function coinChangeDPComp(coins: Array<number>, amt: number): number {
|
||||
const n = coins.length;
|
||||
const MAX = amt + 1;
|
||||
// dp テーブルを初期化
|
||||
const dp = Array.from({ length: amt + 1 }, () => MAX);
|
||||
dp[0] = 0;
|
||||
// 状態遷移
|
||||
for (let i = 1; i <= n; i++) {
|
||||
for (let a = 1; a <= amt; a++) {
|
||||
if (coins[i - 1] > a) {
|
||||
// 目標金額を超えるなら硬貨 i は選ばない
|
||||
dp[a] = dp[a];
|
||||
} else {
|
||||
// 硬貨 i を選ばない場合と選ぶ場合の小さい方
|
||||
dp[a] = Math.min(dp[a], dp[a - coins[i - 1]] + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[amt] !== MAX ? dp[amt] : -1;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const coins = [1, 2, 5];
|
||||
const amt = 4;
|
||||
|
||||
// 動的計画法
|
||||
let res = coinChangeDP(coins, amt);
|
||||
console.log(`目標金額を作るのに必要な最小コイン枚数は ${res}`);
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
res = coinChangeDPComp(coins, amt);
|
||||
console.log(`目標金額を作るのに必要な最小コイン枚数は ${res}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* File: coin_change_ii.ts
|
||||
* Created Time: 2023-08-23
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
|
||||
/* コイン両替 II：動的計画法 */
|
||||
function coinChangeIIDP(coins: Array<number>, amt: number): number {
|
||||
const n = coins.length;
|
||||
// dp テーブルを初期化
|
||||
const dp = Array.from({ length: n + 1 }, () =>
|
||||
Array.from({ length: amt + 1 }, () => 0)
|
||||
);
|
||||
// 先頭列を初期化する
|
||||
for (let i = 0; i <= n; i++) {
|
||||
dp[i][0] = 1;
|
||||
}
|
||||
// 状態遷移
|
||||
for (let i = 1; i <= n; i++) {
|
||||
for (let a = 1; a <= amt; a++) {
|
||||
if (coins[i - 1] > a) {
|
||||
// 目標金額を超えるなら硬貨 i は選ばない
|
||||
dp[i][a] = dp[i - 1][a];
|
||||
} else {
|
||||
// コイン i を選ばない場合と選ぶ場合の和
|
||||
dp[i][a] = dp[i - 1][a] + dp[i][a - coins[i - 1]];
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[n][amt];
|
||||
}
|
||||
|
||||
/* コイン両替 II：空間最適化した動的計画法 */
|
||||
function coinChangeIIDPComp(coins: Array<number>, amt: number): number {
|
||||
const n = coins.length;
|
||||
// dp テーブルを初期化
|
||||
const dp = Array.from({ length: amt + 1 }, () => 0);
|
||||
dp[0] = 1;
|
||||
// 状態遷移
|
||||
for (let i = 1; i <= n; i++) {
|
||||
for (let a = 1; a <= amt; a++) {
|
||||
if (coins[i - 1] > a) {
|
||||
// 目標金額を超えるなら硬貨 i は選ばない
|
||||
dp[a] = dp[a];
|
||||
} else {
|
||||
// コイン i を選ばない場合と選ぶ場合の和
|
||||
dp[a] = dp[a] + dp[a - coins[i - 1]];
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[amt];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const coins = [1, 2, 5];
|
||||
const amt = 5;
|
||||
|
||||
// 動的計画法
|
||||
let res = coinChangeIIDP(coins, amt);
|
||||
console.log(`目標金額を作るコインの組み合わせ数は ${res}`);
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
res = coinChangeIIDPComp(coins, amt);
|
||||
console.log(`目標金額を作るコインの組み合わせ数は ${res}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,148 @@
|
||||
/**
|
||||
* File: edit_distance.ts
|
||||
* Created Time: 2023-08-23
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
|
||||
/* 編集距離：総当たり探索 */
|
||||
function editDistanceDFS(s: string, t: string, i: number, j: number): number {
|
||||
// s と t がともに空なら 0 を返す
|
||||
if (i === 0 && j === 0) return 0;
|
||||
|
||||
// s が空なら t の長さを返す
|
||||
if (i === 0) return j;
|
||||
|
||||
// t が空なら s の長さを返す
|
||||
if (j === 0) return i;
|
||||
|
||||
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
|
||||
if (s.charAt(i - 1) === t.charAt(j - 1))
|
||||
return editDistanceDFS(s, t, i - 1, j - 1);
|
||||
|
||||
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
|
||||
const insert = editDistanceDFS(s, t, i, j - 1);
|
||||
const del = editDistanceDFS(s, t, i - 1, j);
|
||||
const replace = editDistanceDFS(s, t, i - 1, j - 1);
|
||||
// 最小編集回数を返す
|
||||
return Math.min(insert, del, replace) + 1;
|
||||
}
|
||||
|
||||
/* 編集距離：メモ化探索 */
|
||||
function editDistanceDFSMem(
|
||||
s: string,
|
||||
t: string,
|
||||
mem: Array<Array<number>>,
|
||||
i: number,
|
||||
j: number
|
||||
): number {
|
||||
// s と t がともに空なら 0 を返す
|
||||
if (i === 0 && j === 0) return 0;
|
||||
|
||||
// s が空なら t の長さを返す
|
||||
if (i === 0) return j;
|
||||
|
||||
// t が空なら s の長さを返す
|
||||
if (j === 0) return i;
|
||||
|
||||
// 記録済みなら、それをそのまま返す
|
||||
if (mem[i][j] !== -1) return mem[i][j];
|
||||
|
||||
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
|
||||
if (s.charAt(i - 1) === t.charAt(j - 1))
|
||||
return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
|
||||
|
||||
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
|
||||
const insert = editDistanceDFSMem(s, t, mem, i, j - 1);
|
||||
const del = editDistanceDFSMem(s, t, mem, i - 1, j);
|
||||
const replace = editDistanceDFSMem(s, t, mem, i - 1, j - 1);
|
||||
// 最小編集回数を記録して返す
|
||||
mem[i][j] = Math.min(insert, del, replace) + 1;
|
||||
return mem[i][j];
|
||||
}
|
||||
|
||||
/* 編集距離：動的計画法 */
|
||||
function editDistanceDP(s: string, t: string): number {
|
||||
const n = s.length,
|
||||
m = t.length;
|
||||
const dp = Array.from({ length: n + 1 }, () =>
|
||||
Array.from({ length: m + 1 }, () => 0)
|
||||
);
|
||||
// 状態遷移：先頭行と先頭列
|
||||
for (let i = 1; i <= n; i++) {
|
||||
dp[i][0] = i;
|
||||
}
|
||||
for (let j = 1; j <= m; j++) {
|
||||
dp[0][j] = j;
|
||||
}
|
||||
// 状態遷移: 残りの行と列
|
||||
for (let i = 1; i <= n; i++) {
|
||||
for (let j = 1; j <= m; j++) {
|
||||
if (s.charAt(i - 1) === t.charAt(j - 1)) {
|
||||
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
|
||||
dp[i][j] = dp[i - 1][j - 1];
|
||||
} else {
|
||||
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
|
||||
dp[i][j] =
|
||||
Math.min(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1]) + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[n][m];
|
||||
}
|
||||
|
||||
/* 編集距離：空間最適化した動的計画法 */
|
||||
function editDistanceDPComp(s: string, t: string): number {
|
||||
const n = s.length,
|
||||
m = t.length;
|
||||
const dp = new Array(m + 1).fill(0);
|
||||
// 状態遷移：先頭行
|
||||
for (let j = 1; j <= m; j++) {
|
||||
dp[j] = j;
|
||||
}
|
||||
// 状態遷移：残りの行
|
||||
for (let i = 1; i <= n; i++) {
|
||||
// 状態遷移：先頭列
|
||||
let leftup = dp[0]; // dp[i-1, j-1] を一時保存する
|
||||
dp[0] = i;
|
||||
// 状態遷移：残りの列
|
||||
for (let j = 1; j <= m; j++) {
|
||||
const temp = dp[j];
|
||||
if (s.charAt(i - 1) === t.charAt(j - 1)) {
|
||||
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
|
||||
dp[j] = leftup;
|
||||
} else {
|
||||
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
|
||||
dp[j] = Math.min(dp[j - 1], dp[j], leftup) + 1;
|
||||
}
|
||||
leftup = temp; // 次の反復の dp[i-1, j-1] に更新する
|
||||
}
|
||||
}
|
||||
return dp[m];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const s = 'bag';
|
||||
const t = 'pack';
|
||||
const n = s.length,
|
||||
m = t.length;
|
||||
|
||||
// 全探索
|
||||
let res = editDistanceDFS(s, t, n, m);
|
||||
console.log(`${s} を ${t} に変更するには最小で ${res} 回の編集が必要`);
|
||||
|
||||
// メモ化探索
|
||||
const mem = Array.from({ length: n + 1 }, () =>
|
||||
Array.from({ length: m + 1 }, () => -1)
|
||||
);
|
||||
res = editDistanceDFSMem(s, t, mem, n, m);
|
||||
console.log(`${s} を ${t} に変更するには最小で ${res} 回の編集が必要`);
|
||||
|
||||
// 動的計画法
|
||||
res = editDistanceDP(s, t);
|
||||
console.log(`${s} を ${t} に変更するには最小で ${res} 回の編集が必要`);
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
res = editDistanceDPComp(s, t);
|
||||
console.log(`${s} を ${t} に変更するには最小で ${res} 回の編集が必要`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,134 @@
|
||||
/**
|
||||
* File: knapsack.ts
|
||||
* Created Time: 2023-08-23
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
|
||||
/* 0-1 ナップサック：総当たり探索 */
|
||||
function knapsackDFS(
|
||||
wgt: Array<number>,
|
||||
val: Array<number>,
|
||||
i: number,
|
||||
c: number
|
||||
): number {
|
||||
// すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す
|
||||
if (i === 0 || c === 0) {
|
||||
return 0;
|
||||
}
|
||||
// ナップサック容量を超える場合は、入れない選択しかできない
|
||||
if (wgt[i - 1] > c) {
|
||||
return knapsackDFS(wgt, val, i - 1, c);
|
||||
}
|
||||
// 品物 i を入れない場合と入れる場合の最大価値を計算する
|
||||
const no = knapsackDFS(wgt, val, i - 1, c);
|
||||
const yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
|
||||
// 2つの案のうち価値が大きいほうを返す
|
||||
return Math.max(no, yes);
|
||||
}
|
||||
|
||||
/* 0-1 ナップサック：メモ化探索 */
|
||||
function knapsackDFSMem(
|
||||
wgt: Array<number>,
|
||||
val: Array<number>,
|
||||
mem: Array<Array<number>>,
|
||||
i: number,
|
||||
c: number
|
||||
): number {
|
||||
// すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す
|
||||
if (i === 0 || c === 0) {
|
||||
return 0;
|
||||
}
|
||||
// 既に記録があればそのまま返す
|
||||
if (mem[i][c] !== -1) {
|
||||
return mem[i][c];
|
||||
}
|
||||
// ナップサック容量を超える場合は、入れない選択しかできない
|
||||
if (wgt[i - 1] > c) {
|
||||
return knapsackDFSMem(wgt, val, mem, i - 1, c);
|
||||
}
|
||||
// 品物 i を入れない場合と入れる場合の最大価値を計算する
|
||||
const no = knapsackDFSMem(wgt, val, mem, i - 1, c);
|
||||
const yes =
|
||||
knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
|
||||
// 2 つの案のうち価値が大きい方を記録して返す
|
||||
mem[i][c] = Math.max(no, yes);
|
||||
return mem[i][c];
|
||||
}
|
||||
|
||||
/* 0-1 ナップサック：動的計画法 */
|
||||
function knapsackDP(
|
||||
wgt: Array<number>,
|
||||
val: Array<number>,
|
||||
cap: number
|
||||
): number {
|
||||
const n = wgt.length;
|
||||
// dp テーブルを初期化
|
||||
const dp = Array.from({ length: n + 1 }, () =>
|
||||
Array.from({ length: cap + 1 }, () => 0)
|
||||
);
|
||||
// 状態遷移
|
||||
for (let i = 1; i <= n; i++) {
|
||||
for (let c = 1; c <= cap; c++) {
|
||||
if (wgt[i - 1] > c) {
|
||||
// ナップサック容量を超えるなら品物 i は選ばない
|
||||
dp[i][c] = dp[i - 1][c];
|
||||
} else {
|
||||
// 品物 i を選ばない場合と選ぶ場合の大きい方
|
||||
dp[i][c] = Math.max(
|
||||
dp[i - 1][c],
|
||||
dp[i - 1][c - wgt[i - 1]] + val[i - 1]
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[n][cap];
|
||||
}
|
||||
|
||||
/* 0-1 ナップサック：空間最適化後の動的計画法 */
|
||||
function knapsackDPComp(
|
||||
wgt: Array<number>,
|
||||
val: Array<number>,
|
||||
cap: number
|
||||
): number {
|
||||
const n = wgt.length;
|
||||
// dp テーブルを初期化
|
||||
const dp = Array(cap + 1).fill(0);
|
||||
// 状態遷移
|
||||
for (let i = 1; i <= n; i++) {
|
||||
// 逆順に走査する
|
||||
for (let c = cap; c >= 1; c--) {
|
||||
if (wgt[i - 1] <= c) {
|
||||
// 品物 i を選ばない場合と選ぶ場合の大きい方
|
||||
dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[cap];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const wgt = [10, 20, 30, 40, 50];
|
||||
const val = [50, 120, 150, 210, 240];
|
||||
const cap = 50;
|
||||
const n = wgt.length;
|
||||
|
||||
// 全探索
|
||||
let res = knapsackDFS(wgt, val, n, cap);
|
||||
console.log(`ナップサック容量を超えない最大価値は ${res}`);
|
||||
|
||||
// メモ化探索
|
||||
const mem = Array.from({ length: n + 1 }, () =>
|
||||
Array.from({ length: cap + 1 }, () => -1)
|
||||
);
|
||||
res = knapsackDFSMem(wgt, val, mem, n, cap);
|
||||
console.log(`ナップサック容量を超えない最大価値は ${res}`);
|
||||
|
||||
// 動的計画法
|
||||
res = knapsackDP(wgt, val, cap);
|
||||
console.log(`ナップサック容量を超えない最大価値は ${res}`);
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
res = knapsackDPComp(wgt, val, cap);
|
||||
console.log(`ナップサック容量を超えない最大価値は ${res}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,51 @@
|
||||
/**
|
||||
* File: min_cost_climbing_stairs_dp.ts
|
||||
* Created Time: 2023-08-23
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
|
||||
/* 階段登りの最小コスト：動的計画法 */
|
||||
function minCostClimbingStairsDP(cost: Array<number>): number {
|
||||
const n = cost.length - 1;
|
||||
if (n === 1 || n === 2) {
|
||||
return cost[n];
|
||||
}
|
||||
// 部分問題の解を保存するために dp テーブルを初期化
|
||||
const dp = new Array(n + 1);
|
||||
// 初期状態：最小部分問題の解をあらかじめ設定
|
||||
dp[1] = cost[1];
|
||||
dp[2] = cost[2];
|
||||
// 状態遷移：小さい部分問題から大きい部分問題へ順に解く
|
||||
for (let i = 3; i <= n; i++) {
|
||||
dp[i] = Math.min(dp[i - 1], dp[i - 2]) + cost[i];
|
||||
}
|
||||
return dp[n];
|
||||
}
|
||||
|
||||
/* 階段昇りの最小コスト：空間最適化後の動的計画法 */
|
||||
function minCostClimbingStairsDPComp(cost: Array<number>): number {
|
||||
const n = cost.length - 1;
|
||||
if (n === 1 || n === 2) {
|
||||
return cost[n];
|
||||
}
|
||||
let a = cost[1],
|
||||
b = cost[2];
|
||||
for (let i = 3; i <= n; i++) {
|
||||
const tmp = b;
|
||||
b = Math.min(a, tmp) + cost[i];
|
||||
a = tmp;
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const cost = [0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1];
|
||||
console.log(`入力された階段のコスト一覧：${cost}`);
|
||||
|
||||
let res = minCostClimbingStairsDP(cost);
|
||||
console.log(`階段を登り切るための最小コスト：${res}`);
|
||||
|
||||
res = minCostClimbingStairsDPComp(cost);
|
||||
console.log(`階段を登り切るための最小コスト：${res}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,132 @@
|
||||
/**
|
||||
* File: min_path_sum.ts
|
||||
* Created Time: 2023-08-23
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
|
||||
/* 最小経路和：全探索 */
|
||||
function minPathSumDFS(
|
||||
grid: Array<Array<number>>,
|
||||
i: number,
|
||||
j: number
|
||||
): number {
|
||||
// 左上のセルなら探索を終了する
|
||||
if (i === 0 && j == 0) {
|
||||
return grid[0][0];
|
||||
}
|
||||
// 行または列のインデックスが範囲外なら、コスト +∞ を返す
|
||||
if (i < 0 || j < 0) {
|
||||
return Infinity;
|
||||
}
|
||||
// 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する
|
||||
const up = minPathSumDFS(grid, i - 1, j);
|
||||
const left = minPathSumDFS(grid, i, j - 1);
|
||||
// 左上隅から (i, j) までの最小経路コストを返す
|
||||
return Math.min(left, up) + grid[i][j];
|
||||
}
|
||||
|
||||
/* 最小経路和：メモ化探索 */
|
||||
function minPathSumDFSMem(
|
||||
grid: Array<Array<number>>,
|
||||
mem: Array<Array<number>>,
|
||||
i: number,
|
||||
j: number
|
||||
): number {
|
||||
// 左上のセルなら探索を終了する
|
||||
if (i === 0 && j === 0) {
|
||||
return grid[0][0];
|
||||
}
|
||||
// 行または列のインデックスが範囲外なら、コスト +∞ を返す
|
||||
if (i < 0 || j < 0) {
|
||||
return Infinity;
|
||||
}
|
||||
// 既に記録があればそのまま返す
|
||||
if (mem[i][j] != -1) {
|
||||
return mem[i][j];
|
||||
}
|
||||
// 左と上のセルからの最小経路コスト
|
||||
const up = minPathSumDFSMem(grid, mem, i - 1, j);
|
||||
const left = minPathSumDFSMem(grid, mem, i, j - 1);
|
||||
// 左上から (i, j) までの最小経路コストを記録して返す
|
||||
mem[i][j] = Math.min(left, up) + grid[i][j];
|
||||
return mem[i][j];
|
||||
}
|
||||
|
||||
/* 最小経路和：動的計画法 */
|
||||
function minPathSumDP(grid: Array<Array<number>>): number {
|
||||
const n = grid.length,
|
||||
m = grid[0].length;
|
||||
// dp テーブルを初期化
|
||||
const dp = Array.from({ length: n }, () =>
|
||||
Array.from({ length: m }, () => 0)
|
||||
);
|
||||
dp[0][0] = grid[0][0];
|
||||
// 状態遷移：先頭行
|
||||
for (let j = 1; j < m; j++) {
|
||||
dp[0][j] = dp[0][j - 1] + grid[0][j];
|
||||
}
|
||||
// 状態遷移：先頭列
|
||||
for (let i = 1; i < n; i++) {
|
||||
dp[i][0] = dp[i - 1][0] + grid[i][0];
|
||||
}
|
||||
// 状態遷移: 残りの行と列
|
||||
for (let i = 1; i < n; i++) {
|
||||
for (let j: number = 1; j < m; j++) {
|
||||
dp[i][j] = Math.min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
|
||||
}
|
||||
}
|
||||
return dp[n - 1][m - 1];
|
||||
}
|
||||
|
||||
/* 最小経路和：空間最適化後の動的計画法 */
|
||||
function minPathSumDPComp(grid: Array<Array<number>>): number {
|
||||
const n = grid.length,
|
||||
m = grid[0].length;
|
||||
// dp テーブルを初期化
|
||||
const dp = new Array(m);
|
||||
// 状態遷移：先頭行
|
||||
dp[0] = grid[0][0];
|
||||
for (let j = 1; j < m; j++) {
|
||||
dp[j] = dp[j - 1] + grid[0][j];
|
||||
}
|
||||
// 状態遷移：残りの行
|
||||
for (let i = 1; i < n; i++) {
|
||||
// 状態遷移：先頭列
|
||||
dp[0] = dp[0] + grid[i][0];
|
||||
// 状態遷移：残りの列
|
||||
for (let j = 1; j < m; j++) {
|
||||
dp[j] = Math.min(dp[j - 1], dp[j]) + grid[i][j];
|
||||
}
|
||||
}
|
||||
return dp[m - 1];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const grid = [
|
||||
[1, 3, 1, 5],
|
||||
[2, 2, 4, 2],
|
||||
[5, 3, 2, 1],
|
||||
[4, 3, 5, 2],
|
||||
];
|
||||
const n = grid.length,
|
||||
m = grid[0].length;
|
||||
// 全探索
|
||||
let res = minPathSumDFS(grid, n - 1, m - 1);
|
||||
console.log(`左上から右下までの最小経路和は ${res}`);
|
||||
|
||||
// メモ化探索
|
||||
const mem = Array.from({ length: n }, () =>
|
||||
Array.from({ length: m }, () => -1)
|
||||
);
|
||||
res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
|
||||
console.log(`左上から右下までの最小経路和は ${res}`);
|
||||
|
||||
// 動的計画法
|
||||
res = minPathSumDP(grid);
|
||||
console.log(`左上から右下までの最小経路和は ${res}`);
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
res = minPathSumDPComp(grid);
|
||||
console.log(`左上から右下までの最小経路和は ${res}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,73 @@
|
||||
/**
|
||||
* File: unbounded_knapsack.ts
|
||||
* Created Time: 2023-08-23
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
|
||||
/* 完全ナップサック問題：動的計画法 */
|
||||
function unboundedKnapsackDP(
|
||||
wgt: Array<number>,
|
||||
val: Array<number>,
|
||||
cap: number
|
||||
): number {
|
||||
const n = wgt.length;
|
||||
// dp テーブルを初期化
|
||||
const dp = Array.from({ length: n + 1 }, () =>
|
||||
Array.from({ length: cap + 1 }, () => 0)
|
||||
);
|
||||
// 状態遷移
|
||||
for (let i = 1; i <= n; i++) {
|
||||
for (let c = 1; c <= cap; c++) {
|
||||
if (wgt[i - 1] > c) {
|
||||
// ナップサック容量を超えるなら品物 i は選ばない
|
||||
dp[i][c] = dp[i - 1][c];
|
||||
} else {
|
||||
// 品物 i を選ばない場合と選ぶ場合の大きい方
|
||||
dp[i][c] = Math.max(
|
||||
dp[i - 1][c],
|
||||
dp[i][c - wgt[i - 1]] + val[i - 1]
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[n][cap];
|
||||
}
|
||||
|
||||
/* 完全ナップサック問題：空間最適化後の動的計画法 */
|
||||
function unboundedKnapsackDPComp(
|
||||
wgt: Array<number>,
|
||||
val: Array<number>,
|
||||
cap: number
|
||||
): number {
|
||||
const n = wgt.length;
|
||||
// dp テーブルを初期化
|
||||
const dp = Array.from({ length: cap + 1 }, () => 0);
|
||||
// 状態遷移
|
||||
for (let i = 1; i <= n; i++) {
|
||||
for (let c = 1; c <= cap; c++) {
|
||||
if (wgt[i - 1] > c) {
|
||||
// ナップサック容量を超えるなら品物 i は選ばない
|
||||
dp[c] = dp[c];
|
||||
} else {
|
||||
// 品物 i を選ばない場合と選ぶ場合の大きい方
|
||||
dp[c] = Math.max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[cap];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const wgt = [1, 2, 3];
|
||||
const val = [5, 11, 15];
|
||||
const cap = 4;
|
||||
|
||||
// 動的計画法
|
||||
let res = unboundedKnapsackDP(wgt, val, cap);
|
||||
console.log(`ナップサック容量を超えない最大価値は ${res}`);
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
res = unboundedKnapsackDPComp(wgt, val, cap);
|
||||
console.log(`ナップサック容量を超えない最大価値は ${res}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,140 @@
|
||||
/**
|
||||
* File: graph_adjacency_list.ts
|
||||
* Created Time: 2023-02-09
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { Vertex } from '../modules/Vertex';
|
||||
|
||||
/* 隣接リストに基づく無向グラフクラス */
|
||||
class GraphAdjList {
|
||||
// 隣接リスト。key は頂点、value はその頂点に隣接する全頂点
|
||||
adjList: Map<Vertex, Vertex[]>;
|
||||
|
||||
/* コンストラクタ */
|
||||
constructor(edges: Vertex[][]) {
|
||||
this.adjList = new Map();
|
||||
// すべての頂点と辺を追加
|
||||
for (const edge of edges) {
|
||||
this.addVertex(edge[0]);
|
||||
this.addVertex(edge[1]);
|
||||
this.addEdge(edge[0], edge[1]);
|
||||
}
|
||||
}
|
||||
|
||||
/* 頂点数を取得 */
|
||||
size(): number {
|
||||
return this.adjList.size;
|
||||
}
|
||||
|
||||
/* 辺を追加 */
|
||||
addEdge(vet1: Vertex, vet2: Vertex): void {
|
||||
if (
|
||||
!this.adjList.has(vet1) ||
|
||||
!this.adjList.has(vet2) ||
|
||||
vet1 === vet2
|
||||
) {
|
||||
throw new Error('Illegal Argument Exception');
|
||||
}
|
||||
// 辺 vet1 - vet2 を追加
|
||||
this.adjList.get(vet1).push(vet2);
|
||||
this.adjList.get(vet2).push(vet1);
|
||||
}
|
||||
|
||||
/* 辺を削除 */
|
||||
removeEdge(vet1: Vertex, vet2: Vertex): void {
|
||||
if (
|
||||
!this.adjList.has(vet1) ||
|
||||
!this.adjList.has(vet2) ||
|
||||
vet1 === vet2 ||
|
||||
this.adjList.get(vet1).indexOf(vet2) === -1
|
||||
) {
|
||||
throw new Error('Illegal Argument Exception');
|
||||
}
|
||||
// 辺 vet1 - vet2 を削除
|
||||
this.adjList.get(vet1).splice(this.adjList.get(vet1).indexOf(vet2), 1);
|
||||
this.adjList.get(vet2).splice(this.adjList.get(vet2).indexOf(vet1), 1);
|
||||
}
|
||||
|
||||
/* 頂点を追加 */
|
||||
addVertex(vet: Vertex): void {
|
||||
if (this.adjList.has(vet)) return;
|
||||
// 隣接リストに新しいリストを追加
|
||||
this.adjList.set(vet, []);
|
||||
}
|
||||
|
||||
/* 頂点を削除 */
|
||||
removeVertex(vet: Vertex): void {
|
||||
if (!this.adjList.has(vet)) {
|
||||
throw new Error('Illegal Argument Exception');
|
||||
}
|
||||
// 隣接リストから頂点 vet に対応するリストを削除
|
||||
this.adjList.delete(vet);
|
||||
// 他の頂点のリストを走査し、vet を含むすべての辺を削除
|
||||
for (const set of this.adjList.values()) {
|
||||
const index: number = set.indexOf(vet);
|
||||
if (index > -1) {
|
||||
set.splice(index, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 隣接リストを出力 */
|
||||
print(): void {
|
||||
console.log('隣接リスト =');
|
||||
for (const [key, value] of this.adjList.entries()) {
|
||||
const tmp = [];
|
||||
for (const vertex of value) {
|
||||
tmp.push(vertex.val);
|
||||
}
|
||||
console.log(key.val + ': ' + tmp.join());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
if (import.meta.url.endsWith(process.argv[1])) {
|
||||
/* 無向グラフを初期化 */
|
||||
const v0 = new Vertex(1),
|
||||
v1 = new Vertex(3),
|
||||
v2 = new Vertex(2),
|
||||
v3 = new Vertex(5),
|
||||
v4 = new Vertex(4);
|
||||
const edges = [
|
||||
[v0, v1],
|
||||
[v1, v2],
|
||||
[v2, v3],
|
||||
[v0, v3],
|
||||
[v2, v4],
|
||||
[v3, v4],
|
||||
];
|
||||
const graph = new GraphAdjList(edges);
|
||||
console.log('\n初期化後、グラフは');
|
||||
graph.print();
|
||||
|
||||
/* 辺を追加 */
|
||||
// 頂点 1, 2 は v0, v2
|
||||
graph.addEdge(v0, v2);
|
||||
console.log('\n辺 1-2 を追加した後、グラフは');
|
||||
graph.print();
|
||||
|
||||
/* 辺を削除 */
|
||||
// 頂点 1, 3 は v0, v1
|
||||
graph.removeEdge(v0, v1);
|
||||
console.log('\n辺 1-3 を削除した後、グラフは');
|
||||
graph.print();
|
||||
|
||||
/* 頂点を追加 */
|
||||
const v5 = new Vertex(6);
|
||||
graph.addVertex(v5);
|
||||
console.log('\n頂点 6 を追加した後、グラフは');
|
||||
graph.print();
|
||||
|
||||
/* 頂点を削除 */
|
||||
// 頂点 3 は v1
|
||||
graph.removeVertex(v1);
|
||||
console.log('\n頂点 3 を削除した後、グラフは');
|
||||
graph.print();
|
||||
}
|
||||
|
||||
export { GraphAdjList };
|
||||
@@ -0,0 +1,134 @@
|
||||
/**
|
||||
* File: graph_adjacency_matrix.ts
|
||||
* Created Time: 2023-02-09
|
||||
* Author: Zhuo Qinyue (1403450829@qq.com)
|
||||
*/
|
||||
|
||||
/* 隣接行列に基づく無向グラフクラス */
|
||||
class GraphAdjMat {
|
||||
vertices: number[]; // 頂点リスト。要素は「頂点値」、インデックスは「頂点インデックス」を表す
|
||||
adjMat: number[][]; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応
|
||||
|
||||
/* コンストラクタ */
|
||||
constructor(vertices: number[], edges: number[][]) {
|
||||
this.vertices = [];
|
||||
this.adjMat = [];
|
||||
// 頂点を追加
|
||||
for (const val of vertices) {
|
||||
this.addVertex(val);
|
||||
}
|
||||
// 辺を追加
|
||||
// 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
|
||||
for (const e of edges) {
|
||||
this.addEdge(e[0], e[1]);
|
||||
}
|
||||
}
|
||||
|
||||
/* 頂点数を取得 */
|
||||
size(): number {
|
||||
return this.vertices.length;
|
||||
}
|
||||
|
||||
/* 頂点を追加 */
|
||||
addVertex(val: number): void {
|
||||
const n: number = this.size();
|
||||
// 頂点リストに新しい頂点の値を追加
|
||||
this.vertices.push(val);
|
||||
// 隣接行列に 1 行追加
|
||||
const newRow: number[] = [];
|
||||
for (let j: number = 0; j < n; j++) {
|
||||
newRow.push(0);
|
||||
}
|
||||
this.adjMat.push(newRow);
|
||||
// 隣接行列に 1 列追加
|
||||
for (const row of this.adjMat) {
|
||||
row.push(0);
|
||||
}
|
||||
}
|
||||
|
||||
/* 頂点を削除 */
|
||||
removeVertex(index: number): void {
|
||||
if (index >= this.size()) {
|
||||
throw new RangeError('Index Out Of Bounds Exception');
|
||||
}
|
||||
// 頂点リストから index の頂点を削除する
|
||||
this.vertices.splice(index, 1);
|
||||
|
||||
// 隣接行列で index 行を削除する
|
||||
this.adjMat.splice(index, 1);
|
||||
// 隣接行列で index 列を削除する
|
||||
for (const row of this.adjMat) {
|
||||
row.splice(index, 1);
|
||||
}
|
||||
}
|
||||
|
||||
/* 辺を追加 */
|
||||
// 引数 i, j は vertices の要素インデックスに対応する
|
||||
addEdge(i: number, j: number): void {
|
||||
// インデックスの範囲外と等値の処理
|
||||
if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
|
||||
throw new RangeError('Index Out Of Bounds Exception');
|
||||
}
|
||||
// 無向グラフでは、隣接行列は主対角線に関して対称であり、(i, j) === (j, i) を満たす
|
||||
this.adjMat[i][j] = 1;
|
||||
this.adjMat[j][i] = 1;
|
||||
}
|
||||
|
||||
/* 辺を削除 */
|
||||
// 引数 i, j は vertices の要素インデックスに対応する
|
||||
removeEdge(i: number, j: number): void {
|
||||
// インデックスの範囲外と等値の処理
|
||||
if (i < 0 || j < 0 || i >= this.size() || j >= this.size() || i === j) {
|
||||
throw new RangeError('Index Out Of Bounds Exception');
|
||||
}
|
||||
this.adjMat[i][j] = 0;
|
||||
this.adjMat[j][i] = 0;
|
||||
}
|
||||
|
||||
/* 隣接行列を出力 */
|
||||
print(): void {
|
||||
console.log('頂点リスト = ', this.vertices);
|
||||
console.log('隣接行列 =', this.adjMat);
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 無向グラフを初期化 */
|
||||
// edges の要素は頂点インデックス、すなわち vertices の要素インデックスに対応する点に注意
|
||||
const vertices: number[] = [1, 3, 2, 5, 4];
|
||||
const edges: number[][] = [
|
||||
[0, 1],
|
||||
[1, 2],
|
||||
[2, 3],
|
||||
[0, 3],
|
||||
[2, 4],
|
||||
[3, 4],
|
||||
];
|
||||
const graph: GraphAdjMat = new GraphAdjMat(vertices, edges);
|
||||
console.log('\n初期化後、グラフは');
|
||||
graph.print();
|
||||
|
||||
/* 辺を追加 */
|
||||
// 頂点 1, 2 のインデックスはそれぞれ 0, 2
|
||||
graph.addEdge(0, 2);
|
||||
console.log('\n辺 1-2 を追加した後、グラフは');
|
||||
graph.print();
|
||||
|
||||
/* 辺を削除 */
|
||||
// 頂点 1, 3 のインデックスはそれぞれ 0, 1
|
||||
graph.removeEdge(0, 1);
|
||||
console.log('\n辺 1-3 を削除した後、グラフは');
|
||||
graph.print();
|
||||
|
||||
/* 頂点を追加 */
|
||||
graph.addVertex(6);
|
||||
console.log('\n頂点 6 を追加した後、グラフは');
|
||||
graph.print();
|
||||
|
||||
/* 頂点を削除 */
|
||||
// 頂点 3 のインデックスは 1
|
||||
graph.removeVertex(1);
|
||||
console.log('\n頂点 3 を削除した後、グラフは');
|
||||
graph.print();
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
* File: graph_bfs.ts
|
||||
* Created Time: 2023-02-21
|
||||
* Author: Zhuo Qinyue (1403450829@qq.com)
|
||||
*/
|
||||
|
||||
import { GraphAdjList } from './graph_adjacency_list';
|
||||
import { Vertex } from '../modules/Vertex';
|
||||
|
||||
/* 幅優先探索 */
|
||||
// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする
|
||||
function graphBFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {
|
||||
// 頂点の走査順序
|
||||
const res: Vertex[] = [];
|
||||
// 訪問済み頂点を記録するためのハッシュ集合
|
||||
const visited: Set<Vertex> = new Set();
|
||||
visited.add(startVet);
|
||||
// BFS の実装にキューを用いる
|
||||
const que = [startVet];
|
||||
// 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す
|
||||
while (que.length) {
|
||||
const vet = que.shift(); // 先頭の頂点をデキュー
|
||||
res.push(vet); // 訪問した頂点を記録
|
||||
// この頂点のすべての隣接頂点を走査
|
||||
for (const adjVet of graph.adjList.get(vet) ?? []) {
|
||||
if (visited.has(adjVet)) {
|
||||
continue; // 訪問済みの頂点をスキップ
|
||||
}
|
||||
que.push(adjVet); // 未訪問のものだけをキューに入れる
|
||||
visited.add(adjVet); // この頂点を訪問済みにする
|
||||
}
|
||||
}
|
||||
// 頂点の走査順を返す
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 無向グラフを初期化 */
|
||||
const v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
||||
const edges = [
|
||||
[v[0], v[1]],
|
||||
[v[0], v[3]],
|
||||
[v[1], v[2]],
|
||||
[v[1], v[4]],
|
||||
[v[2], v[5]],
|
||||
[v[3], v[4]],
|
||||
[v[3], v[6]],
|
||||
[v[4], v[5]],
|
||||
[v[4], v[7]],
|
||||
[v[5], v[8]],
|
||||
[v[6], v[7]],
|
||||
[v[7], v[8]],
|
||||
];
|
||||
const graph = new GraphAdjList(edges);
|
||||
console.log('\n初期化後、グラフは');
|
||||
graph.print();
|
||||
|
||||
/* 幅優先探索 */
|
||||
const res = graphBFS(graph, v[0]);
|
||||
console.log('\n幅優先探索（BFS）の頂点列は');
|
||||
console.log(Vertex.vetsToVals(res));
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* File: graph_dfs.ts
|
||||
* Created Time: 2023-02-21
|
||||
* Author: Zhuo Qinyue (1403450829@qq.com)
|
||||
*/
|
||||
|
||||
import { Vertex } from '../modules/Vertex';
|
||||
import { GraphAdjList } from './graph_adjacency_list';
|
||||
|
||||
/* 深さ優先走査の補助関数 */
|
||||
function dfs(
|
||||
graph: GraphAdjList,
|
||||
visited: Set<Vertex>,
|
||||
res: Vertex[],
|
||||
vet: Vertex
|
||||
): void {
|
||||
res.push(vet); // 訪問した頂点を記録
|
||||
visited.add(vet); // この頂点を訪問済みにする
|
||||
// この頂点のすべての隣接頂点を走査
|
||||
for (const adjVet of graph.adjList.get(vet)) {
|
||||
if (visited.has(adjVet)) {
|
||||
continue; // 訪問済みの頂点をスキップ
|
||||
}
|
||||
// 隣接頂点を再帰的に訪問
|
||||
dfs(graph, visited, res, adjVet);
|
||||
}
|
||||
}
|
||||
|
||||
/* 深さ優先探索 */
|
||||
// グラフを隣接リストで表し、指定した頂点の隣接頂点をすべて取得できるようにする
|
||||
function graphDFS(graph: GraphAdjList, startVet: Vertex): Vertex[] {
|
||||
// 頂点の走査順序
|
||||
const res: Vertex[] = [];
|
||||
// 訪問済み頂点を記録するためのハッシュ集合
|
||||
const visited: Set<Vertex> = new Set();
|
||||
dfs(graph, visited, res, startVet);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 無向グラフを初期化 */
|
||||
const v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6]);
|
||||
const edges = [
|
||||
[v[0], v[1]],
|
||||
[v[0], v[3]],
|
||||
[v[1], v[2]],
|
||||
[v[2], v[5]],
|
||||
[v[4], v[5]],
|
||||
[v[5], v[6]],
|
||||
];
|
||||
const graph = new GraphAdjList(edges);
|
||||
console.log('\n初期化後、グラフは');
|
||||
graph.print();
|
||||
|
||||
/* 深さ優先探索 */
|
||||
const res = graphDFS(graph, v[0]);
|
||||
console.log('\n深さ優先探索（DFS）の頂点列は');
|
||||
console.log(Vertex.vetsToVals(res));
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* File: coin_change_greedy.ts
|
||||
* Created Time: 2023-09-02
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* コイン交換：貪欲法 */
|
||||
function coinChangeGreedy(coins: number[], amt: number): number {
|
||||
// coins 配列はソート済みと仮定する
|
||||
let i = coins.length - 1;
|
||||
let count = 0;
|
||||
// 残額がなくなるまで貪欲選択を繰り返す
|
||||
while (amt > 0) {
|
||||
// 残額以下で最も近い硬貨を見つける
|
||||
while (i > 0 && coins[i] > amt) {
|
||||
i--;
|
||||
}
|
||||
// coins[i] を選択する
|
||||
amt -= coins[i];
|
||||
count++;
|
||||
}
|
||||
// 実行可能な解が見つからなければ -1 を返す
|
||||
return amt === 0 ? count : -1;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
// 貪欲法：大域最適解を保証できる
|
||||
let coins: number[] = [1, 5, 10, 20, 50, 100];
|
||||
let amt: number = 186;
|
||||
let res: number = coinChangeGreedy(coins, amt);
|
||||
console.log(`\ncoins = ${coins}, amt = ${amt}`);
|
||||
console.log(`金額 ${amt} を作るのに必要な最小硬貨枚数は ${res}`);
|
||||
|
||||
// 貪欲法：大域最適解を保証できない
|
||||
coins = [1, 20, 50];
|
||||
amt = 60;
|
||||
res = coinChangeGreedy(coins, amt);
|
||||
console.log(`\ncoins = ${coins}, amt = ${amt}`);
|
||||
console.log(`金額 ${amt} を作るのに必要な最小硬貨枚数は ${res}`);
|
||||
console.log('実際に必要な最小枚数は 3 ，つまり 20 + 20 + 20');
|
||||
|
||||
// 貪欲法：大域最適解を保証できない
|
||||
coins = [1, 49, 50];
|
||||
amt = 98;
|
||||
res = coinChangeGreedy(coins, amt);
|
||||
console.log(`\ncoins = ${coins}, amt = ${amt}`);
|
||||
console.log(`金額 ${amt} を作るのに必要な最小硬貨枚数は ${res}`);
|
||||
console.log('実際に必要な最小枚数は 2 ，つまり 49 + 49');
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* File: fractional_knapsack.ts
|
||||
* Created Time: 2023-09-02
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* 品物 */
|
||||
class Item {
|
||||
w: number; // 品物の重さ
|
||||
v: number; // 品物の価値
|
||||
|
||||
constructor(w: number, v: number) {
|
||||
this.w = w;
|
||||
this.v = v;
|
||||
}
|
||||
}
|
||||
|
||||
/* 分数ナップサック：貪欲法 */
|
||||
function fractionalKnapsack(wgt: number[], val: number[], cap: number): number {
|
||||
// 重さと価値の 2 属性を持つ品物リストを作成
|
||||
const items: Item[] = wgt.map((w, i) => new Item(w, val[i]));
|
||||
// 単位価値 item.v / item.w の高い順にソートする
|
||||
items.sort((a, b) => b.v / b.w - a.v / a.w);
|
||||
// 貪欲選択を繰り返す
|
||||
let res = 0;
|
||||
for (const item of items) {
|
||||
if (item.w <= cap) {
|
||||
// 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる
|
||||
res += item.v;
|
||||
cap -= item.w;
|
||||
} else {
|
||||
// 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる
|
||||
res += (item.v / item.w) * cap;
|
||||
// 残り容量がないため、ループを抜ける
|
||||
break;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const wgt: number[] = [10, 20, 30, 40, 50];
|
||||
const val: number[] = [50, 120, 150, 210, 240];
|
||||
const cap: number = 50;
|
||||
|
||||
// 貪欲法
|
||||
const res: number = fractionalKnapsack(wgt, val, cap);
|
||||
console.log(`ナップサック容量を超えない最大価値は ${res}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,36 @@
|
||||
/**
|
||||
* File: max_capacity.ts
|
||||
* Created Time: 2023-09-02
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* 最大容量：貪欲法 */
|
||||
function maxCapacity(ht: number[]): number {
|
||||
// i, j を初期化し、それぞれ配列の両端に置く
|
||||
let i = 0,
|
||||
j = ht.length - 1;
|
||||
// 初期の最大容量は 0
|
||||
let res = 0;
|
||||
// 2 枚の板が出会うまで貪欲選択を繰り返す
|
||||
while (i < j) {
|
||||
// 最大容量を更新する
|
||||
const cap: number = Math.min(ht[i], ht[j]) * (j - i);
|
||||
res = Math.max(res, cap);
|
||||
// 短い方を内側へ動かす
|
||||
if (ht[i] < ht[j]) {
|
||||
i += 1;
|
||||
} else {
|
||||
j -= 1;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const ht: number[] = [3, 8, 5, 2, 7, 7, 3, 4];
|
||||
|
||||
// 貪欲法
|
||||
const res: number = maxCapacity(ht);
|
||||
console.log(`最大容量は ${res}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,35 @@
|
||||
/**
|
||||
* File: max_product_cutting.ts
|
||||
* Created Time: 2023-09-02
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* 最大切断積：貪欲法 */
|
||||
function maxProductCutting(n: number): number {
|
||||
// n <= 3 のときは、必ず 1 を切り出す
|
||||
if (n <= 3) {
|
||||
return 1 * (n - 1);
|
||||
}
|
||||
// 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする
|
||||
let a: number = Math.floor(n / 3);
|
||||
let b: number = n % 3;
|
||||
if (b === 1) {
|
||||
// 余りが 1 のときは、1 * 3 を 2 * 2 に変える
|
||||
return Math.pow(3, a - 1) * 2 * 2;
|
||||
}
|
||||
if (b === 2) {
|
||||
// 余りが 2 のときは、そのままにする
|
||||
return Math.pow(3, a) * 2;
|
||||
}
|
||||
// 余りが 0 のときは、そのままにする
|
||||
return Math.pow(3, a);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
let n: number = 58;
|
||||
|
||||
// 貪欲法
|
||||
let res: number = maxProductCutting(n);
|
||||
console.log(`最大分割積は ${res}`);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,134 @@
|
||||
/**
|
||||
* File: array_hash_map.ts
|
||||
* Created Time: 2022-12-20
|
||||
* Author: Daniel (better.sunjian@gmail.com)
|
||||
*/
|
||||
|
||||
/* キーと値の組 Number -> String */
|
||||
class Pair {
|
||||
public key: number;
|
||||
public val: string;
|
||||
|
||||
constructor(key: number, val: string) {
|
||||
this.key = key;
|
||||
this.val = val;
|
||||
}
|
||||
}
|
||||
|
||||
/* 配列ベースのハッシュテーブル */
|
||||
class ArrayHashMap {
|
||||
private readonly buckets: (Pair | null)[];
|
||||
|
||||
constructor() {
|
||||
// 100 個のバケットを含む配列を初期化
|
||||
this.buckets = 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 pair = this.buckets[index];
|
||||
if (pair === null) return null;
|
||||
return pair.val;
|
||||
}
|
||||
|
||||
/* 追加操作 */
|
||||
public set(key: number, val: string) {
|
||||
let index = this.hashFunc(key);
|
||||
this.buckets[index] = new Pair(key, val);
|
||||
}
|
||||
|
||||
/* 削除操作 */
|
||||
public delete(key: number) {
|
||||
let index = this.hashFunc(key);
|
||||
// null に設定し、削除を表す
|
||||
this.buckets[index] = null;
|
||||
}
|
||||
|
||||
/* すべてのキーと値のペアを取得 */
|
||||
public entries(): (Pair | null)[] {
|
||||
let arr: (Pair | null)[] = [];
|
||||
for (let i = 0; i < this.buckets.length; i++) {
|
||||
if (this.buckets[i]) {
|
||||
arr.push(this.buckets[i]);
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
||||
/* すべてのキーを取得 */
|
||||
public keys(): (number | undefined)[] {
|
||||
let arr: (number | undefined)[] = [];
|
||||
for (let i = 0; i < this.buckets.length; i++) {
|
||||
if (this.buckets[i]) {
|
||||
arr.push(this.buckets[i].key);
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
||||
/* すべての値を取得 */
|
||||
public values(): (string | undefined)[] {
|
||||
let arr: (string | undefined)[] = [];
|
||||
for (let i = 0; i < this.buckets.length; i++) {
|
||||
if (this.buckets[i]) {
|
||||
arr.push(this.buckets[i].val);
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
|
||||
/* ハッシュテーブルを出力 */
|
||||
public print() {
|
||||
let pairSet = this.entries();
|
||||
for (const pair of pairSet) {
|
||||
console.info(`${pair.key} -> ${pair.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('\n10583 を削除した後，ハッシュテーブルは\nKey -> Value');
|
||||
map.print();
|
||||
|
||||
/* ハッシュテーブルを走査 */
|
||||
console.info('\nキーと値の組 Key->Value を走査');
|
||||
for (const pair of map.entries()) {
|
||||
if (!pair) continue;
|
||||
console.info(pair.key + ' -> ' + pair.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 {};
|
||||
@@ -0,0 +1,46 @@
|
||||
/**
|
||||
* 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('\n10583 を削除した後，ハッシュテーブルは\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);
|
||||
}
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,146 @@
|
||||
/**
|
||||
* File: hash_map_chaining.ts
|
||||
* Created Time: 2023-08-06
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
/* キーと値の組 Number -> String */
|
||||
class Pair {
|
||||
key: number;
|
||||
val: string;
|
||||
constructor(key: number, val: string) {
|
||||
this.key = key;
|
||||
this.val = val;
|
||||
}
|
||||
}
|
||||
|
||||
/* チェイン法ハッシュテーブル */
|
||||
class HashMapChaining {
|
||||
#size: number; // キーと値のペア数
|
||||
#capacity: number; // ハッシュテーブル容量
|
||||
#loadThres: number; // リサイズを発動する負荷率のしきい値
|
||||
#extendRatio: number; // 拡張倍率
|
||||
#buckets: Pair[][]; // バケット配列
|
||||
|
||||
/* コンストラクタ */
|
||||
constructor() {
|
||||
this.#size = 0;
|
||||
this.#capacity = 4;
|
||||
this.#loadThres = 2.0 / 3.0;
|
||||
this.#extendRatio = 2;
|
||||
this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);
|
||||
}
|
||||
|
||||
/* ハッシュ関数 */
|
||||
#hashFunc(key: number): number {
|
||||
return key % this.#capacity;
|
||||
}
|
||||
|
||||
/* 負荷率 */
|
||||
#loadFactor(): number {
|
||||
return this.#size / this.#capacity;
|
||||
}
|
||||
|
||||
/* 検索操作 */
|
||||
get(key: number): string | null {
|
||||
const index = this.#hashFunc(key);
|
||||
const bucket = this.#buckets[index];
|
||||
// バケットを走査し、key が見つかれば対応する val を返す
|
||||
for (const pair of bucket) {
|
||||
if (pair.key === key) {
|
||||
return pair.val;
|
||||
}
|
||||
}
|
||||
// key が見つからない場合は null を返す
|
||||
return null;
|
||||
}
|
||||
|
||||
/* 追加操作 */
|
||||
put(key: number, val: string): void {
|
||||
// 負荷率がしきい値を超えたら、リサイズを実行
|
||||
if (this.#loadFactor() > this.#loadThres) {
|
||||
this.#extend();
|
||||
}
|
||||
const index = this.#hashFunc(key);
|
||||
const bucket = this.#buckets[index];
|
||||
// バケットを走査し、指定した key が見つかれば対応する val を更新して返す
|
||||
for (const pair of bucket) {
|
||||
if (pair.key === key) {
|
||||
pair.val = val;
|
||||
return;
|
||||
}
|
||||
}
|
||||
// その key が存在しなければ、キーと値のペアを末尾に追加
|
||||
const pair = new Pair(key, val);
|
||||
bucket.push(pair);
|
||||
this.#size++;
|
||||
}
|
||||
|
||||
/* 削除操作 */
|
||||
remove(key: number): void {
|
||||
const index = this.#hashFunc(key);
|
||||
let bucket = this.#buckets[index];
|
||||
// バケットを走査してキーと値のペアを削除
|
||||
for (let i = 0; i < bucket.length; i++) {
|
||||
if (bucket[i].key === key) {
|
||||
bucket.splice(i, 1);
|
||||
this.#size--;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ハッシュテーブルを拡張 */
|
||||
#extend(): void {
|
||||
// 元のハッシュテーブルを一時保存
|
||||
const bucketsTmp = this.#buckets;
|
||||
// リサイズ後の新しいハッシュテーブルを初期化
|
||||
this.#capacity *= this.#extendRatio;
|
||||
this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);
|
||||
this.#size = 0;
|
||||
// キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す
|
||||
for (const bucket of bucketsTmp) {
|
||||
for (const pair of bucket) {
|
||||
this.put(pair.key, pair.val);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ハッシュテーブルを出力 */
|
||||
print(): void {
|
||||
for (const bucket of this.#buckets) {
|
||||
let res = [];
|
||||
for (const pair of bucket) {
|
||||
res.push(pair.key + ' -> ' + pair.val);
|
||||
}
|
||||
console.log(res);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* ハッシュテーブルを初期化 */
|
||||
const map = new HashMapChaining();
|
||||
|
||||
/* 追加操作 */
|
||||
// ハッシュテーブルにキーと値のペア (key, value) を追加
|
||||
map.put(12836, 'シャオハー');
|
||||
map.put(15937, 'シャオルオ');
|
||||
map.put(16750, 'シャオスワン');
|
||||
map.put(13276, 'シャオファー');
|
||||
map.put(10583, 'シャオヤー');
|
||||
console.log('\n追加完了後，ハッシュテーブルは\nKey -> Value');
|
||||
map.print();
|
||||
|
||||
/* 検索操作 */
|
||||
// キー key をハッシュテーブルに渡し、値 value を取得
|
||||
const name = map.get(13276);
|
||||
console.log('\n学籍番号 13276 を入力し，見つかった氏名 ' + name);
|
||||
|
||||
/* 削除操作 */
|
||||
// ハッシュテーブルからキーと値のペア (key, value) を削除
|
||||
map.remove(12836);
|
||||
console.log('\n12836 を削除した後，ハッシュテーブルは\nKey -> Value');
|
||||
map.print();
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,182 @@
|
||||
/**
|
||||
* File: hash_map_open_addressing.ts
|
||||
* Created Time: 2023-08-06
|
||||
* Author: yuan0221 (yl1452491917@gmail.com), krahets (krahets@163.com)
|
||||
*/
|
||||
|
||||
/* キーと値の組 Number -> String */
|
||||
class Pair {
|
||||
key: number;
|
||||
val: string;
|
||||
|
||||
constructor(key: number, val: string) {
|
||||
this.key = key;
|
||||
this.val = val;
|
||||
}
|
||||
}
|
||||
|
||||
/* オープンアドレス法ハッシュテーブル */
|
||||
class HashMapOpenAddressing {
|
||||
private size: number; // キーと値のペア数
|
||||
private capacity: number; // ハッシュテーブル容量
|
||||
private loadThres: number; // リサイズを発動する負荷率のしきい値
|
||||
private extendRatio: number; // 拡張倍率
|
||||
private buckets: Array<Pair | null>; // バケット配列
|
||||
private TOMBSTONE: Pair; // 削除済みマーク
|
||||
|
||||
/* コンストラクタ */
|
||||
constructor() {
|
||||
this.size = 0; // キーと値のペア数
|
||||
this.capacity = 4; // ハッシュテーブル容量
|
||||
this.loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値
|
||||
this.extendRatio = 2; // 拡張倍率
|
||||
this.buckets = Array(this.capacity).fill(null); // バケット配列
|
||||
this.TOMBSTONE = new Pair(-1, '-1'); // 削除済みマーク
|
||||
}
|
||||
|
||||
/* ハッシュ関数 */
|
||||
private hashFunc(key: number): number {
|
||||
return key % this.capacity;
|
||||
}
|
||||
|
||||
/* 負荷率 */
|
||||
private loadFactor(): number {
|
||||
return this.size / this.capacity;
|
||||
}
|
||||
|
||||
/* key に対応するバケットインデックスを探す */
|
||||
private findBucket(key: number): number {
|
||||
let index = this.hashFunc(key);
|
||||
let firstTombstone = -1;
|
||||
// 線形プロービングを行い、空バケットに達したら終了
|
||||
while (this.buckets[index] !== null) {
|
||||
// key が見つかったら、対応するバケットのインデックスを返す
|
||||
if (this.buckets[index]!.key === key) {
|
||||
// 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動
|
||||
if (firstTombstone !== -1) {
|
||||
this.buckets[firstTombstone] = this.buckets[index];
|
||||
this.buckets[index] = this.TOMBSTONE;
|
||||
return firstTombstone; // 移動後のバケットインデックスを返す
|
||||
}
|
||||
return index; // バケットのインデックスを返す
|
||||
}
|
||||
// 最初に見つかった削除マークを記録
|
||||
if (
|
||||
firstTombstone === -1 &&
|
||||
this.buckets[index] === this.TOMBSTONE
|
||||
) {
|
||||
firstTombstone = index;
|
||||
}
|
||||
// バケットのインデックスを計算し、末尾を越えたら先頭に戻る
|
||||
index = (index + 1) % this.capacity;
|
||||
}
|
||||
// key が存在しない場合は追加位置のインデックスを返す
|
||||
return firstTombstone === -1 ? index : firstTombstone;
|
||||
}
|
||||
|
||||
/* 検索操作 */
|
||||
get(key: number): string | null {
|
||||
// key に対応するバケットインデックスを探す
|
||||
const index = this.findBucket(key);
|
||||
// キーと値の組が見つかったら、対応する val を返す
|
||||
if (
|
||||
this.buckets[index] !== null &&
|
||||
this.buckets[index] !== this.TOMBSTONE
|
||||
) {
|
||||
return this.buckets[index]!.val;
|
||||
}
|
||||
// キーと値の組が存在しなければ null を返す
|
||||
return null;
|
||||
}
|
||||
|
||||
/* 追加操作 */
|
||||
put(key: number, val: string): void {
|
||||
// 負荷率がしきい値を超えたら、リサイズを実行
|
||||
if (this.loadFactor() > this.loadThres) {
|
||||
this.extend();
|
||||
}
|
||||
// key に対応するバケットインデックスを探す
|
||||
const index = this.findBucket(key);
|
||||
// キーと値の組が見つかったら、val を上書きして返す
|
||||
if (
|
||||
this.buckets[index] !== null &&
|
||||
this.buckets[index] !== this.TOMBSTONE
|
||||
) {
|
||||
this.buckets[index]!.val = val;
|
||||
return;
|
||||
}
|
||||
// キーと値の組が存在しない場合は、その組を追加する
|
||||
this.buckets[index] = new Pair(key, val);
|
||||
this.size++;
|
||||
}
|
||||
|
||||
/* 削除操作 */
|
||||
remove(key: number): void {
|
||||
// key に対応するバケットインデックスを探す
|
||||
const index = this.findBucket(key);
|
||||
// キーと値の組が見つかったら、削除マーカーで上書きする
|
||||
if (
|
||||
this.buckets[index] !== null &&
|
||||
this.buckets[index] !== this.TOMBSTONE
|
||||
) {
|
||||
this.buckets[index] = this.TOMBSTONE;
|
||||
this.size--;
|
||||
}
|
||||
}
|
||||
|
||||
/* ハッシュテーブルを拡張 */
|
||||
private extend(): void {
|
||||
// 元のハッシュテーブルを一時保存
|
||||
const bucketsTmp = this.buckets;
|
||||
// リサイズ後の新しいハッシュテーブルを初期化
|
||||
this.capacity *= this.extendRatio;
|
||||
this.buckets = Array(this.capacity).fill(null);
|
||||
this.size = 0;
|
||||
// キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す
|
||||
for (const pair of bucketsTmp) {
|
||||
if (pair !== null && pair !== this.TOMBSTONE) {
|
||||
this.put(pair.key, pair.val);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ハッシュテーブルを出力 */
|
||||
print(): void {
|
||||
for (const pair of this.buckets) {
|
||||
if (pair === null) {
|
||||
console.log('null');
|
||||
} else if (pair === this.TOMBSTONE) {
|
||||
console.log('TOMBSTONE');
|
||||
} else {
|
||||
console.log(pair.key + ' -> ' + pair.val);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
// ハッシュテーブルを初期化
|
||||
const hashmap = new HashMapOpenAddressing();
|
||||
|
||||
// 追加操作
|
||||
// ハッシュテーブルにキーと値の組 (key, val) を追加する
|
||||
hashmap.put(12836, 'シャオハー');
|
||||
hashmap.put(15937, 'シャオルオ');
|
||||
hashmap.put(16750, 'シャオスワン');
|
||||
hashmap.put(13276, 'シャオファー');
|
||||
hashmap.put(10583, 'シャオヤー');
|
||||
console.log('\n追加完了後，ハッシュテーブルは\nKey -> Value');
|
||||
hashmap.print();
|
||||
|
||||
// 検索操作
|
||||
// ハッシュテーブルにキー key を入力し、値 val を得る
|
||||
const name = hashmap.get(13276);
|
||||
console.log('\n学籍番号 13276 を入力し，見つかった氏名 ' + name);
|
||||
|
||||
// 削除操作
|
||||
// ハッシュテーブルからキーと値の組 (key, val) を削除する
|
||||
hashmap.remove(16750);
|
||||
console.log('\n16750 を削除した後，ハッシュテーブルは\nKey -> Value');
|
||||
hashmap.print();
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* File: simple_hash.ts
|
||||
* Created Time: 2023-08-06
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
/* 加算ハッシュ */
|
||||
function addHash(key: string): number {
|
||||
let hash = 0;
|
||||
const MODULUS = 1000000007;
|
||||
for (const c of key) {
|
||||
hash = (hash + c.charCodeAt(0)) % MODULUS;
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
/* 乗算ハッシュ */
|
||||
function mulHash(key: string): number {
|
||||
let hash = 0;
|
||||
const MODULUS = 1000000007;
|
||||
for (const c of key) {
|
||||
hash = (31 * hash + c.charCodeAt(0)) % MODULUS;
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
/* XOR ハッシュ */
|
||||
function xorHash(key: string): number {
|
||||
let hash = 0;
|
||||
const MODULUS = 1000000007;
|
||||
for (const c of key) {
|
||||
hash ^= c.charCodeAt(0);
|
||||
}
|
||||
return hash % MODULUS;
|
||||
}
|
||||
|
||||
/* 回転ハッシュ */
|
||||
function rotHash(key: string): number {
|
||||
let hash = 0;
|
||||
const MODULUS = 1000000007;
|
||||
for (const c of key) {
|
||||
hash = ((hash << 4) ^ (hash >> 28) ^ c.charCodeAt(0)) % MODULUS;
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const key = 'Hello アルゴリズム';
|
||||
|
||||
let hash = addHash(key);
|
||||
console.log('加算ハッシュ値は ' + hash);
|
||||
|
||||
hash = mulHash(key);
|
||||
console.log('乗算ハッシュ値は ' + hash);
|
||||
|
||||
hash = xorHash(key);
|
||||
console.log('XOR ハッシュ値は ' + hash);
|
||||
|
||||
hash = rotHash(key);
|
||||
console.log('回転ハッシュ値は ' + hash);
|
||||
@@ -0,0 +1,155 @@
|
||||
/**
|
||||
* File: my_heap.ts
|
||||
* Created Time: 2023-02-07
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { printHeap } from '../modules/PrintUtil';
|
||||
|
||||
/* 最大ヒープクラス */
|
||||
class MaxHeap {
|
||||
private maxHeap: number[];
|
||||
/* コンストラクタ。空のヒープを作成するか、入力リストからヒープを構築する */
|
||||
constructor(nums?: number[]) {
|
||||
// リスト要素をそのままヒープに追加
|
||||
this.maxHeap = nums === undefined ? [] : [...nums];
|
||||
// 葉ノード以外のすべてのノードをヒープ化
|
||||
for (let i = this.parent(this.size() - 1); i >= 0; i--) {
|
||||
this.siftDown(i);
|
||||
}
|
||||
}
|
||||
|
||||
/* 左子ノードのインデックスを取得 */
|
||||
private left(i: number): number {
|
||||
return 2 * i + 1;
|
||||
}
|
||||
|
||||
/* 右子ノードのインデックスを取得 */
|
||||
private right(i: number): number {
|
||||
return 2 * i + 2;
|
||||
}
|
||||
|
||||
/* 親ノードのインデックスを取得 */
|
||||
private parent(i: number): number {
|
||||
return Math.floor((i - 1) / 2); // 切り捨て除算
|
||||
}
|
||||
|
||||
/* 要素を交換 */
|
||||
private swap(i: number, j: number): void {
|
||||
const tmp = this.maxHeap[i];
|
||||
this.maxHeap[i] = this.maxHeap[j];
|
||||
this.maxHeap[j] = tmp;
|
||||
}
|
||||
|
||||
/* ヒープのサイズを取得 */
|
||||
public size(): number {
|
||||
return this.maxHeap.length;
|
||||
}
|
||||
|
||||
/* ヒープが空かどうかを判定 */
|
||||
public isEmpty(): boolean {
|
||||
return this.size() === 0;
|
||||
}
|
||||
|
||||
/* ヒープ先頭要素にアクセス */
|
||||
public peek(): number {
|
||||
return this.maxHeap[0];
|
||||
}
|
||||
|
||||
/* 要素をヒープに追加 */
|
||||
public push(val: number): void {
|
||||
// ノードを追加
|
||||
this.maxHeap.push(val);
|
||||
// 下から上へヒープ化
|
||||
this.siftUp(this.size() - 1);
|
||||
}
|
||||
|
||||
/* ノード i から始めて、下から上へヒープ化 */
|
||||
private siftUp(i: number): void {
|
||||
while (true) {
|
||||
// ノード i の親ノードを取得
|
||||
const p = this.parent(i);
|
||||
// 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了
|
||||
if (p < 0 || this.maxHeap[i] <= this.maxHeap[p]) break;
|
||||
// 2 つのノードを交換
|
||||
this.swap(i, p);
|
||||
// ループで下から上へヒープ化
|
||||
i = p;
|
||||
}
|
||||
}
|
||||
|
||||
/* 要素をヒープから取り出す */
|
||||
public pop(): number {
|
||||
// 空判定の処理
|
||||
if (this.isEmpty()) throw new RangeError('Heap is empty.');
|
||||
// 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
|
||||
this.swap(0, this.size() - 1);
|
||||
// ノードを削除
|
||||
const val = this.maxHeap.pop();
|
||||
// 上から下へヒープ化
|
||||
this.siftDown(0);
|
||||
// ヒープ先頭要素を返す
|
||||
return val;
|
||||
}
|
||||
|
||||
/* ノード i から始めて、上から下へヒープ化 */
|
||||
private siftDown(i: number): void {
|
||||
while (true) {
|
||||
// ノード i, l, r のうち値が最大のノードを ma とする
|
||||
const l = this.left(i),
|
||||
r = this.right(i);
|
||||
let ma = i;
|
||||
if (l < this.size() && this.maxHeap[l] > this.maxHeap[ma]) ma = l;
|
||||
if (r < this.size() && this.maxHeap[r] > this.maxHeap[ma]) ma = r;
|
||||
// ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
|
||||
if (ma === i) break;
|
||||
// 2 つのノードを交換
|
||||
this.swap(i, ma);
|
||||
// ループで上から下へヒープ化
|
||||
i = ma;
|
||||
}
|
||||
}
|
||||
|
||||
/* ヒープ（二分木）を出力 */
|
||||
public print(): void {
|
||||
printHeap(this.maxHeap);
|
||||
}
|
||||
|
||||
/* ヒープから要素を取り出す */
|
||||
public getMaxHeap(): number[] {
|
||||
return this.maxHeap;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
if (import.meta.url.endsWith(process.argv[1])) {
|
||||
/* 最大ヒープを初期化 */
|
||||
const maxHeap = new MaxHeap([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2]);
|
||||
console.log('\nリストを入力してヒープを構築した後');
|
||||
maxHeap.print();
|
||||
|
||||
/* ヒープ頂点の要素を取得 */
|
||||
let peek = maxHeap.peek();
|
||||
console.log(`\nヒープの先頭要素は ${peek}`);
|
||||
|
||||
/* 要素をヒープに追加 */
|
||||
const val = 7;
|
||||
maxHeap.push(val);
|
||||
console.log(`\n要素 ${val} をヒープに追加した後`);
|
||||
maxHeap.print();
|
||||
|
||||
/* ヒープ頂点の要素を取り出す */
|
||||
peek = maxHeap.pop();
|
||||
console.log(`\nヒープの先頭要素 ${peek} を取り出した後`);
|
||||
maxHeap.print();
|
||||
|
||||
/* ヒープのサイズを取得 */
|
||||
const size = maxHeap.size();
|
||||
console.log(`\nヒープの要素数は ${size}`);
|
||||
|
||||
/* ヒープが空かどうかを判定 */
|
||||
const isEmpty = maxHeap.isEmpty();
|
||||
console.log(`\nヒープが空かどうか ${isEmpty}`);
|
||||
}
|
||||
|
||||
export { MaxHeap };
|
||||
@@ -0,0 +1,58 @@
|
||||
/**
|
||||
* File: top_k.ts
|
||||
* Created Time: 2023-08-13
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { MaxHeap } from './my_heap';
|
||||
|
||||
/* 要素をヒープに追加 */
|
||||
function pushMinHeap(maxHeap: MaxHeap, val: number): void {
|
||||
// 要素を反転する
|
||||
maxHeap.push(-val);
|
||||
}
|
||||
|
||||
/* 要素をヒープから取り出す */
|
||||
function popMinHeap(maxHeap: MaxHeap): number {
|
||||
// 要素を反転する
|
||||
return -maxHeap.pop();
|
||||
}
|
||||
|
||||
/* ヒープ先頭要素にアクセス */
|
||||
function peekMinHeap(maxHeap: MaxHeap): number {
|
||||
// 要素を反転する
|
||||
return -maxHeap.peek();
|
||||
}
|
||||
|
||||
/* ヒープから要素を取り出す */
|
||||
function getMinHeap(maxHeap: MaxHeap): number[] {
|
||||
// 要素を反転する
|
||||
return maxHeap.getMaxHeap().map((num: number) => -num);
|
||||
}
|
||||
|
||||
/* ヒープに基づいて配列中の最大の k 個の要素を探す */
|
||||
function topKHeap(nums: number[], k: number): number[] {
|
||||
// 最小ヒープを初期化する
|
||||
// 注意: ヒープ内の全要素を反転し、最大ヒープで最小ヒープをシミュレートする
|
||||
const maxHeap = new MaxHeap([]);
|
||||
// 配列の先頭 k 個の要素をヒープに追加
|
||||
for (let i = 0; i < k; i++) {
|
||||
pushMinHeap(maxHeap, nums[i]);
|
||||
}
|
||||
// k+1 番目の要素から開始し、ヒープ長を k に保つ
|
||||
for (let i = k; i < nums.length; i++) {
|
||||
// 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する
|
||||
if (nums[i] > peekMinHeap(maxHeap)) {
|
||||
popMinHeap(maxHeap);
|
||||
pushMinHeap(maxHeap, nums[i]);
|
||||
}
|
||||
}
|
||||
// ヒープ内の要素を返す
|
||||
return getMinHeap(maxHeap);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums = [1, 7, 6, 3, 2];
|
||||
const k = 3;
|
||||
const res = topKHeap(nums, k);
|
||||
console.log(`最大の ${k} 個の要素は`, res);
|
||||
@@ -0,0 +1,65 @@
|
||||
/**
|
||||
* File: binary_search.ts
|
||||
* Created Time: 2022-12-27
|
||||
* Author: Daniel (better.sunjian@gmail.com)
|
||||
*/
|
||||
|
||||
/* 二分探索（両閉区間） */
|
||||
function binarySearch(nums: number[], target: number): number {
|
||||
// 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す
|
||||
let i = 0,
|
||||
j = nums.length - 1;
|
||||
// ループし、探索区間が空になったら終了する（i > j で空）
|
||||
while (i <= j) {
|
||||
// 中点インデックス m を計算
|
||||
const m = Math.floor(i + (j - i) / 2);
|
||||
if (nums[m] < target) {
|
||||
// この場合、target は区間 [m+1, j] にある
|
||||
i = m + 1;
|
||||
} else if (nums[m] > target) {
|
||||
// この場合、target は区間 [i, m-1] にある
|
||||
j = m - 1;
|
||||
} else {
|
||||
// 目標要素が見つかったらそのインデックスを返す
|
||||
return m;
|
||||
}
|
||||
}
|
||||
return -1; // 目標要素が見つからなければ -1 を返す
|
||||
}
|
||||
|
||||
/* 二分探索（左閉右開区間） */
|
||||
function binarySearchLCRO(nums: number[], target: number): number {
|
||||
// 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す
|
||||
let i = 0,
|
||||
j = nums.length;
|
||||
// ループし、探索区間が空になったら終了する（i = j で空）
|
||||
while (i < j) {
|
||||
// 中点インデックス m を計算
|
||||
const m = Math.floor(i + (j - i) / 2);
|
||||
if (nums[m] < target) {
|
||||
// この場合、target は区間 [m+1, j) にある
|
||||
i = m + 1;
|
||||
} else if (nums[m] > target) {
|
||||
// この場合、target は区間 [i, m) にある
|
||||
j = m;
|
||||
} else {
|
||||
// 目標要素が見つかったらそのインデックスを返す
|
||||
return m;
|
||||
}
|
||||
}
|
||||
return -1; // 目標要素が見つからなければ -1 を返す
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const target = 6;
|
||||
const nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
|
||||
|
||||
/* 二分探索（両閉区間） */
|
||||
let index = binarySearch(nums, target);
|
||||
console.info('対象要素 6 のインデックス = %d', index);
|
||||
|
||||
/* 二分探索（左閉右開区間） */
|
||||
index = binarySearchLCRO(nums, target);
|
||||
console.info('対象要素 6 のインデックス = %d', index);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,46 @@
|
||||
/**
|
||||
* File: binary_search_edge.ts
|
||||
* Created Time: 2023-08-22
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
import { binarySearchInsertion } from './binary_search_insertion';
|
||||
|
||||
/* 最も左の target を二分探索 */
|
||||
function binarySearchLeftEdge(nums: Array<number>, target: number): number {
|
||||
// target の挿入位置を探すのと等価
|
||||
const i = binarySearchInsertion(nums, target);
|
||||
// target が見つからなければ、-1 を返す
|
||||
if (i === nums.length || nums[i] !== target) {
|
||||
return -1;
|
||||
}
|
||||
// target が見つかったら、インデックス i を返す
|
||||
return i;
|
||||
}
|
||||
|
||||
/* 最も右の target を二分探索 */
|
||||
function binarySearchRightEdge(nums: Array<number>, target: number): number {
|
||||
// 最左の target + 1 を探す問題に変換する
|
||||
const i = binarySearchInsertion(nums, target + 1);
|
||||
// j は最も右の target を指し、i は target より大きい最初の要素を指す
|
||||
const j = i - 1;
|
||||
// target が見つからなければ、-1 を返す
|
||||
if (j === -1 || nums[j] !== target) {
|
||||
return -1;
|
||||
}
|
||||
// target が見つかったら、インデックス j を返す
|
||||
return j;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
// 重複要素を含む配列
|
||||
let nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
|
||||
console.log('\n配列 nums = ' + nums);
|
||||
// 二分探索で左端と右端を探す
|
||||
for (const target of [6, 7]) {
|
||||
let index = binarySearchLeftEdge(nums, target);
|
||||
console.log('一番左の要素 ' + target + ' のインデックスは ' + index);
|
||||
index = binarySearchRightEdge(nums, target);
|
||||
console.log('一番右の要素 ' + target + ' のインデックスは ' + index);
|
||||
}
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,65 @@
|
||||
/**
|
||||
* File: binary_search_insertion.ts
|
||||
* Created Time: 2023-08-22
|
||||
* Author: Gaofer Chou (gaofer-chou@qq.com)
|
||||
*/
|
||||
|
||||
/* 二分探索で挿入位置を探す（重複要素なし） */
|
||||
function binarySearchInsertionSimple(
|
||||
nums: Array<number>,
|
||||
target: number
|
||||
): number {
|
||||
let i = 0,
|
||||
j = nums.length - 1; // 両閉区間 [0, n-1] を初期化
|
||||
while (i <= j) {
|
||||
const m = Math.floor(i + (j - i) / 2); // 中点インデックス m を計算し、Math.floor() で切り捨てる
|
||||
if (nums[m] < target) {
|
||||
i = m + 1; // target は区間 [m+1, j] にある
|
||||
} else if (nums[m] > target) {
|
||||
j = m - 1; // target は区間 [i, m-1] にある
|
||||
} else {
|
||||
return m; // target が見つかったら、挿入位置 m を返す
|
||||
}
|
||||
}
|
||||
// target が見つからなければ、挿入位置 i を返す
|
||||
return i;
|
||||
}
|
||||
|
||||
/* 二分探索で挿入位置を探す（重複要素あり） */
|
||||
function binarySearchInsertion(nums: Array<number>, target: number): number {
|
||||
let i = 0,
|
||||
j = nums.length - 1; // 両閉区間 [0, n-1] を初期化
|
||||
while (i <= j) {
|
||||
const m = Math.floor(i + (j - i) / 2); // 中点インデックス m を計算し、Math.floor() で切り捨てる
|
||||
if (nums[m] < target) {
|
||||
i = m + 1; // target は区間 [m+1, j] にある
|
||||
} else if (nums[m] > target) {
|
||||
j = m - 1; // target は区間 [i, m-1] にある
|
||||
} else {
|
||||
j = m - 1; // target より小さい最初の要素は区間 [i, m-1] にある
|
||||
}
|
||||
}
|
||||
// 挿入位置 i を返す
|
||||
return i;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
// 重複要素のない配列
|
||||
let nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
|
||||
console.log('\n配列 nums = ' + nums);
|
||||
// 二分探索で挿入位置を探す
|
||||
for (const target of [6, 9]) {
|
||||
const index = binarySearchInsertionSimple(nums, target);
|
||||
console.log('要素 ' + target + ' の挿入位置のインデックスは ' + index);
|
||||
}
|
||||
|
||||
// 重複要素を含む配列
|
||||
nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
|
||||
console.log('\n配列 nums = ' + nums);
|
||||
// 二分探索で挿入位置を探す
|
||||
for (const target of [2, 6, 20]) {
|
||||
const index = binarySearchInsertion(nums, target);
|
||||
console.log('要素 ' + target + ' の挿入位置のインデックスは ' + index);
|
||||
}
|
||||
|
||||
export { binarySearchInsertion };
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* File: hashing_search.ts
|
||||
* Created Time: 2022-12-29
|
||||
* Author: Zhuo Qinyue (1403450829@qq.com)
|
||||
*/
|
||||
|
||||
import { ListNode, arrToLinkedList } from '../modules/ListNode';
|
||||
|
||||
/* ハッシュ探索（配列） */
|
||||
function hashingSearchArray(map: Map<number, number>, target: number): number {
|
||||
// ハッシュテーブルの key: 目標要素、value: インデックス
|
||||
// ハッシュテーブルにこの key がなければ -1 を返す
|
||||
return map.has(target) ? (map.get(target) as number) : -1;
|
||||
}
|
||||
|
||||
/* ハッシュ探索（連結リスト） */
|
||||
function hashingSearchLinkedList(
|
||||
map: Map<number, ListNode>,
|
||||
target: number
|
||||
): ListNode | null {
|
||||
// ハッシュテーブルの key: 目標ノード値、value: ノードオブジェクト
|
||||
// ハッシュテーブルにこの key がなければ null を返す
|
||||
return map.has(target) ? (map.get(target) as ListNode) : null;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const target = 3;
|
||||
|
||||
/* ハッシュ探索（配列） */
|
||||
const nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
|
||||
// ハッシュテーブルを初期化
|
||||
const map = new Map();
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
map.set(nums[i], i); // key: 要素、value: インデックス
|
||||
}
|
||||
const index = hashingSearchArray(map, target);
|
||||
console.log('対象要素 3 のインデックス = ' + index);
|
||||
|
||||
/* ハッシュ探索（連結リスト） */
|
||||
let head = arrToLinkedList(nums);
|
||||
// ハッシュテーブルを初期化
|
||||
const map1 = new Map();
|
||||
while (head != null) {
|
||||
map1.set(head.val, head); // key: ノード値、value: ノード
|
||||
head = head.next;
|
||||
}
|
||||
const node = hashingSearchLinkedList(map1, target);
|
||||
console.log('対象ノード値 3 に対応するノードオブジェクトは', node);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* File: linear_search.ts
|
||||
* Created Time: 2023-01-07
|
||||
* Author: Daniel (better.sunjian@gmail.com)
|
||||
*/
|
||||
|
||||
import { ListNode, arrToLinkedList } from '../modules/ListNode';
|
||||
|
||||
/* 線形探索（配列） */
|
||||
function linearSearchArray(nums: number[], target: number): number {
|
||||
// 配列を走査
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
// 目標要素が見つかったらそのインデックスを返す
|
||||
if (nums[i] === target) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
// 目標要素が見つからなければ -1 を返す
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* 線形探索（連結リスト） */
|
||||
function linearSearchLinkedList(
|
||||
head: ListNode | null,
|
||||
target: number
|
||||
): ListNode | null {
|
||||
// 連結リストを走査
|
||||
while (head) {
|
||||
// 対象ノードが見つかったら、それを返す
|
||||
if (head.val === target) {
|
||||
return head;
|
||||
}
|
||||
head = head.next;
|
||||
}
|
||||
// 対象ノードが見つからない場合は null を返す
|
||||
return null;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const target = 3;
|
||||
|
||||
/* 配列で線形探索を行う */
|
||||
const nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
|
||||
const index = linearSearchArray(nums, target);
|
||||
console.log('対象要素 3 のインデックス =', index);
|
||||
|
||||
/* 連結リストで線形探索を行う */
|
||||
const head = arrToLinkedList(nums);
|
||||
const node = linearSearchLinkedList(head, target);
|
||||
console.log('対象ノード値 3 に対応するノードオブジェクトは', node);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,49 @@
|
||||
/**
|
||||
* File: two_sum.ts
|
||||
* Created Time: 2022-12-15
|
||||
* Author: gyt95 (gytkwan@gmail.com)
|
||||
*/
|
||||
|
||||
/* 方法 1：総当たり列挙 */
|
||||
function twoSumBruteForce(nums: number[], target: number): number[] {
|
||||
const n = nums.length;
|
||||
// 2重ループのため、時間計算量は O(n^2)
|
||||
for (let i = 0; i < n; i++) {
|
||||
for (let j = i + 1; j < n; j++) {
|
||||
if (nums[i] + nums[j] === target) {
|
||||
return [i, j];
|
||||
}
|
||||
}
|
||||
}
|
||||
return [];
|
||||
}
|
||||
|
||||
/* 方法 2：補助ハッシュテーブル */
|
||||
function twoSumHashTable(nums: number[], target: number): number[] {
|
||||
// 補助ハッシュテーブルを使用し、空間計算量は O(n)
|
||||
let m: Map<number, number> = new Map();
|
||||
// 単一ループで、時間計算量は O(n)
|
||||
for (let i = 0; i < nums.length; i++) {
|
||||
let index = m.get(target - nums[i]);
|
||||
if (index !== undefined) {
|
||||
return [index, i];
|
||||
} else {
|
||||
m.set(nums[i], i);
|
||||
}
|
||||
}
|
||||
return [];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
// 方法 1
|
||||
const nums = [2, 7, 11, 15],
|
||||
target = 13;
|
||||
|
||||
let res = twoSumBruteForce(nums, target);
|
||||
console.log('方法1 res = ', res);
|
||||
|
||||
// 方法 2
|
||||
res = twoSumHashTable(nums, target);
|
||||
console.log('方法2 res = ', res);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,51 @@
|
||||
/**
|
||||
* File: bubble_sort.ts
|
||||
* Created Time: 2022-12-12
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* バブルソート */
|
||||
function bubbleSort(nums: number[]): void {
|
||||
// 外側のループ：未ソート区間は [0, i]
|
||||
for (let i = nums.length - 1; i > 0; i--) {
|
||||
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
|
||||
for (let j = 0; j < i; j++) {
|
||||
if (nums[j] > nums[j + 1]) {
|
||||
// nums[j] と nums[j + 1] を交換
|
||||
let tmp = nums[j];
|
||||
nums[j] = nums[j + 1];
|
||||
nums[j + 1] = tmp;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* バブルソート（フラグ最適化） */
|
||||
function bubbleSortWithFlag(nums: number[]): void {
|
||||
// 外側のループ：未ソート区間は [0, i]
|
||||
for (let i = nums.length - 1; i > 0; i--) {
|
||||
let flag = false; // フラグを初期化する
|
||||
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
|
||||
for (let j = 0; j < i; j++) {
|
||||
if (nums[j] > nums[j + 1]) {
|
||||
// nums[j] と nums[j + 1] を交換
|
||||
let tmp = nums[j];
|
||||
nums[j] = nums[j + 1];
|
||||
nums[j + 1] = tmp;
|
||||
flag = true; // 交換する要素を記録
|
||||
}
|
||||
}
|
||||
if (!flag) break; // このバブル処理で要素交換が一度もなければそのまま終了
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums = [4, 1, 3, 1, 5, 2];
|
||||
bubbleSort(nums);
|
||||
console.log('バブルソート完了後 nums =', nums);
|
||||
|
||||
const nums1 = [4, 1, 3, 1, 5, 2];
|
||||
bubbleSortWithFlag(nums1);
|
||||
console.log('バブルソート完了後 nums =', nums1);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,41 @@
|
||||
/**
|
||||
* File: bucket_sort.ts
|
||||
* Created Time: 2023-04-08
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* バケットソート */
|
||||
function bucketSort(nums: number[]): void {
|
||||
// k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする
|
||||
const k = nums.length / 2;
|
||||
const buckets: number[][] = [];
|
||||
for (let i = 0; i < k; i++) {
|
||||
buckets.push([]);
|
||||
}
|
||||
// 1. 配列要素を各バケットに振り分ける
|
||||
for (const num of nums) {
|
||||
// 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する
|
||||
const i = Math.floor(num * k);
|
||||
// num をバケット i に追加
|
||||
buckets[i].push(num);
|
||||
}
|
||||
// 2. 各バケットをソートする
|
||||
for (const bucket of buckets) {
|
||||
// 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい
|
||||
bucket.sort((a, b) => a - b);
|
||||
}
|
||||
// 3. バケットを走査して結果を結合
|
||||
let i = 0;
|
||||
for (const bucket of buckets) {
|
||||
for (const num of bucket) {
|
||||
nums[i++] = num;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37];
|
||||
bucketSort(nums);
|
||||
console.log('バケットソート完了後 nums =', nums);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,67 @@
|
||||
/**
|
||||
* File: counting_sort.ts
|
||||
* Created Time: 2023-04-08
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* 計数ソート */
|
||||
// 簡易実装のため、オブジェクトのソートには使えない
|
||||
function countingSortNaive(nums: number[]): void {
|
||||
// 1. 配列の最大要素 m を求める
|
||||
let m: number = Math.max(...nums);
|
||||
// 2. 各数値の出現回数を数える
|
||||
// counter[num] は num の出現回数を表す
|
||||
const counter: number[] = new Array<number>(m + 1).fill(0);
|
||||
for (const num of nums) {
|
||||
counter[num]++;
|
||||
}
|
||||
// 3. counter を走査し、各要素を元の配列 nums に書き戻す
|
||||
let i = 0;
|
||||
for (let num = 0; num < m + 1; num++) {
|
||||
for (let j = 0; j < counter[num]; j++, i++) {
|
||||
nums[i] = num;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 計数ソート */
|
||||
// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである
|
||||
function countingSort(nums: number[]): void {
|
||||
// 1. 配列の最大要素 m を求める
|
||||
let m: number = Math.max(...nums);
|
||||
// 2. 各数値の出現回数を数える
|
||||
// counter[num] は num の出現回数を表す
|
||||
const counter: number[] = new Array<number>(m + 1).fill(0);
|
||||
for (const num of nums) {
|
||||
counter[num]++;
|
||||
}
|
||||
// 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する
|
||||
// つまり counter[num]-1 は、num が res に最後に現れるインデックス
|
||||
for (let i = 0; i < m; i++) {
|
||||
counter[i + 1] += counter[i];
|
||||
}
|
||||
// 4. nums を逆順に走査し、各要素を結果配列 res に格納する
|
||||
// 結果を記録するための配列 res を初期化
|
||||
const n = nums.length;
|
||||
const res: number[] = new Array<number>(n);
|
||||
for (let i = n - 1; i >= 0; i--) {
|
||||
const num = nums[i];
|
||||
res[counter[num] - 1] = num; // num を対応するインデックスに配置
|
||||
counter[num]--; // 累積和を 1 減らして、次に num を配置するインデックスを得る
|
||||
}
|
||||
// 結果配列 res で元の配列 nums を上書きする
|
||||
for (let i = 0; i < n; i++) {
|
||||
nums[i] = res[i];
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
|
||||
countingSortNaive(nums);
|
||||
console.log('カウントソート（オブジェクトはソート不可）完了後 nums =', nums);
|
||||
|
||||
const nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
|
||||
countingSort(nums1);
|
||||
console.log('計数ソート完了後 nums1 =', nums1);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,51 @@
|
||||
/**
|
||||
* File: heap_sort.ts
|
||||
* Created Time: 2023-06-04
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* ヒープの長さは n。ノード i から下方向にヒープ化 */
|
||||
function siftDown(nums: number[], n: number, i: number): void {
|
||||
while (true) {
|
||||
// ノード i, l, r のうち値が最大のノードを ma とする
|
||||
let l = 2 * i + 1;
|
||||
let r = 2 * i + 2;
|
||||
let ma = i;
|
||||
if (l < n && nums[l] > nums[ma]) {
|
||||
ma = l;
|
||||
}
|
||||
if (r < n && nums[r] > nums[ma]) {
|
||||
ma = r;
|
||||
}
|
||||
// ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
|
||||
if (ma === i) {
|
||||
break;
|
||||
}
|
||||
// 2 つのノードを交換
|
||||
[nums[i], nums[ma]] = [nums[ma], nums[i]];
|
||||
// ループで上から下へヒープ化
|
||||
i = ma;
|
||||
}
|
||||
}
|
||||
|
||||
/* ヒープソート */
|
||||
function heapSort(nums: number[]): void {
|
||||
// ヒープ構築：葉ノード以外のすべてのノードをヒープ化する
|
||||
for (let i = Math.floor(nums.length / 2) - 1; i >= 0; i--) {
|
||||
siftDown(nums, nums.length, i);
|
||||
}
|
||||
// ヒープから最大要素を取り出し、n-1 回繰り返す
|
||||
for (let i = nums.length - 1; i > 0; i--) {
|
||||
// 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
|
||||
[nums[0], nums[i]] = [nums[i], nums[0]];
|
||||
// 根ノードを起点に、上から下へヒープ化
|
||||
siftDown(nums, i, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums: number[] = [4, 1, 3, 1, 5, 2];
|
||||
heapSort(nums);
|
||||
console.log('ヒープソート完了後 nums =', nums);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,27 @@
|
||||
/**
|
||||
* File: insertion_sort.ts
|
||||
* Created Time: 2022-12-12
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* 挿入ソート */
|
||||
function insertionSort(nums: number[]): void {
|
||||
// 外側ループ：整列済み区間は [0, i-1]
|
||||
for (let i = 1; i < nums.length; i++) {
|
||||
const base = nums[i];
|
||||
let j = i - 1;
|
||||
// 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する
|
||||
while (j >= 0 && nums[j] > base) {
|
||||
nums[j + 1] = nums[j]; // nums[j] を 1 つ右へ移動する
|
||||
j--;
|
||||
}
|
||||
nums[j + 1] = base; // base を正しい位置に配置する
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums = [4, 1, 3, 1, 5, 2];
|
||||
insertionSort(nums);
|
||||
console.log('挿入ソート完了後 nums =', nums);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,54 @@
|
||||
/**
|
||||
* File: merge_sort.ts
|
||||
* Created Time: 2022-12-12
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* 左部分配列と右部分配列をマージ */
|
||||
function merge(nums: number[], left: number, mid: number, right: number): void {
|
||||
// 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]
|
||||
// マージ結果を格納する一時配列 tmp を作成
|
||||
const tmp = new Array(right - left + 1);
|
||||
// 左右の部分配列の開始インデックスを初期化する
|
||||
let i = left,
|
||||
j = mid + 1,
|
||||
k = 0;
|
||||
// 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする
|
||||
while (i <= mid && j <= right) {
|
||||
if (nums[i] <= nums[j]) {
|
||||
tmp[k++] = nums[i++];
|
||||
} else {
|
||||
tmp[k++] = nums[j++];
|
||||
}
|
||||
}
|
||||
// 左右の部分配列の残り要素を一時配列にコピーする
|
||||
while (i <= mid) {
|
||||
tmp[k++] = nums[i++];
|
||||
}
|
||||
while (j <= right) {
|
||||
tmp[k++] = nums[j++];
|
||||
}
|
||||
// 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする
|
||||
for (k = 0; k < tmp.length; k++) {
|
||||
nums[left + k] = tmp[k];
|
||||
}
|
||||
}
|
||||
|
||||
/* マージソート */
|
||||
function mergeSort(nums: number[], left: number, right: number): void {
|
||||
// 終了条件
|
||||
if (left >= right) return; // 部分配列の長さが 1 になったら再帰を終了
|
||||
// 分割フェーズ
|
||||
let mid = Math.floor(left + (right - left) / 2); // 中点を計算
|
||||
mergeSort(nums, left, mid); // 左部分配列を再帰処理
|
||||
mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理
|
||||
// マージフェーズ
|
||||
merge(nums, left, mid, right);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums = [7, 3, 2, 6, 0, 1, 5, 4];
|
||||
mergeSort(nums, 0, nums.length - 1);
|
||||
console.log('マージソート完了後 nums =', nums);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,180 @@
|
||||
/**
|
||||
* File: quick_sort.ts
|
||||
* Created Time: 2022-12-12
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* クイックソートクラス */
|
||||
class QuickSort {
|
||||
/* 要素の交換 */
|
||||
swap(nums: number[], i: number, j: number): void {
|
||||
let tmp = nums[i];
|
||||
nums[i] = nums[j];
|
||||
nums[j] = tmp;
|
||||
}
|
||||
|
||||
/* 番兵分割 */
|
||||
partition(nums: number[], left: number, right: number): number {
|
||||
// nums[left] を基準値とする
|
||||
let i = left,
|
||||
j = right;
|
||||
while (i < j) {
|
||||
while (i < j && nums[j] >= nums[left]) {
|
||||
j -= 1; // 右から左へ基準値未満の最初の要素を探す
|
||||
}
|
||||
while (i < j && nums[i] <= nums[left]) {
|
||||
i += 1; // 左から右へ基準値より大きい最初の要素を探す
|
||||
}
|
||||
// 要素の交換
|
||||
this.swap(nums, i, j); // この 2 つの要素を交換
|
||||
}
|
||||
this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
|
||||
return i; // 基準値のインデックスを返す
|
||||
}
|
||||
|
||||
/* クイックソート */
|
||||
quickSort(nums: number[], left: number, right: number): void {
|
||||
// 部分配列の長さが 1 なら再帰を終了する
|
||||
if (left >= right) {
|
||||
return;
|
||||
}
|
||||
// 番兵分割
|
||||
const pivot = this.partition(nums, left, right);
|
||||
// 左右の部分配列を再帰処理
|
||||
this.quickSort(nums, left, pivot - 1);
|
||||
this.quickSort(nums, pivot + 1, right);
|
||||
}
|
||||
}
|
||||
|
||||
/* クイックソートクラス（中央値ピボット最適化） */
|
||||
class QuickSortMedian {
|
||||
/* 要素の交換 */
|
||||
swap(nums: number[], i: number, j: number): void {
|
||||
let tmp = nums[i];
|
||||
nums[i] = nums[j];
|
||||
nums[j] = tmp;
|
||||
}
|
||||
|
||||
/* 3つの候補要素の中央値を選ぶ */
|
||||
medianThree(
|
||||
nums: number[],
|
||||
left: number,
|
||||
mid: number,
|
||||
right: number
|
||||
): number {
|
||||
let l = nums[left],
|
||||
m = nums[mid],
|
||||
r = nums[right];
|
||||
// m は l と r の間
|
||||
if ((l <= m && m <= r) || (r <= m && m <= l)) return mid;
|
||||
// l は m と r の間
|
||||
if ((m <= l && l <= r) || (r <= l && l <= m)) return left;
|
||||
return right;
|
||||
}
|
||||
|
||||
/* 番兵による分割処理（3 点中央値） */
|
||||
partition(nums: number[], left: number, right: number): number {
|
||||
// 3つの候補要素の中央値を選ぶ
|
||||
let med = this.medianThree(
|
||||
nums,
|
||||
left,
|
||||
Math.floor((left + right) / 2),
|
||||
right
|
||||
);
|
||||
// 中央値を配列の最左端に交換する
|
||||
this.swap(nums, left, med);
|
||||
// nums[left] を基準値とする
|
||||
let i = left,
|
||||
j = right;
|
||||
while (i < j) {
|
||||
while (i < j && nums[j] >= nums[left]) {
|
||||
j--; // 右から左へ基準値未満の最初の要素を探す
|
||||
}
|
||||
while (i < j && nums[i] <= nums[left]) {
|
||||
i++; // 左から右へ基準値より大きい最初の要素を探す
|
||||
}
|
||||
this.swap(nums, i, j); // この 2 つの要素を交換
|
||||
}
|
||||
this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
|
||||
return i; // 基準値のインデックスを返す
|
||||
}
|
||||
|
||||
/* クイックソート */
|
||||
quickSort(nums: number[], left: number, right: number): void {
|
||||
// 部分配列の長さが 1 なら再帰を終了する
|
||||
if (left >= right) {
|
||||
return;
|
||||
}
|
||||
// 番兵分割
|
||||
const pivot = this.partition(nums, left, right);
|
||||
// 左右の部分配列を再帰処理
|
||||
this.quickSort(nums, left, pivot - 1);
|
||||
this.quickSort(nums, pivot + 1, right);
|
||||
}
|
||||
}
|
||||
|
||||
/* クイックソートクラス（再帰深度最適化） */
|
||||
class QuickSortTailCall {
|
||||
/* 要素の交換 */
|
||||
swap(nums: number[], i: number, j: number): void {
|
||||
let tmp = nums[i];
|
||||
nums[i] = nums[j];
|
||||
nums[j] = tmp;
|
||||
}
|
||||
|
||||
/* 番兵分割 */
|
||||
partition(nums: number[], left: number, right: number): number {
|
||||
// nums[left] を基準値とする
|
||||
let i = left,
|
||||
j = right;
|
||||
while (i < j) {
|
||||
while (i < j && nums[j] >= nums[left]) {
|
||||
j--; // 右から左へ基準値未満の最初の要素を探す
|
||||
}
|
||||
while (i < j && nums[i] <= nums[left]) {
|
||||
i++; // 左から右へ基準値より大きい最初の要素を探す
|
||||
}
|
||||
this.swap(nums, i, j); // この 2 つの要素を交換
|
||||
}
|
||||
this.swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
|
||||
return i; // 基準値のインデックスを返す
|
||||
}
|
||||
|
||||
/* クイックソート（再帰深度最適化） */
|
||||
quickSort(nums: number[], left: number, right: number): void {
|
||||
// 部分配列の長さが 1 なら終了
|
||||
while (left < right) {
|
||||
// 番兵による分割処理
|
||||
let pivot = this.partition(nums, left, right);
|
||||
// 2 つの部分配列のうち短いほうにクイックソートを適用する
|
||||
if (pivot - left < right - pivot) {
|
||||
this.quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート
|
||||
left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]
|
||||
} else {
|
||||
this.quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート
|
||||
right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* クイックソート */
|
||||
const nums = [2, 4, 1, 0, 3, 5];
|
||||
const quickSort = new QuickSort();
|
||||
quickSort.quickSort(nums, 0, nums.length - 1);
|
||||
console.log('クイックソート完了後 nums =', nums);
|
||||
|
||||
/* クイックソート（中央値の基準値で最適化） */
|
||||
const nums1 = [2, 4, 1, 0, 3, 5];
|
||||
const quickSortMedian = new QuickSortMedian();
|
||||
quickSortMedian.quickSort(nums1, 0, nums1.length - 1);
|
||||
console.log('クイックソート（中央値ピボット最適化）完了後 nums =', nums1);
|
||||
|
||||
/* クイックソート（再帰深度最適化） */
|
||||
const nums2 = [2, 4, 1, 0, 3, 5];
|
||||
const quickSortTailCall = new QuickSortTailCall();
|
||||
quickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
|
||||
console.log('クイックソート（再帰深度最適化）完了後 nums =', nums2);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,63 @@
|
||||
/**
|
||||
* File: radix_sort.ts
|
||||
* Created Time: 2023-04-08
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* 要素 num の下から k 桁目を取得（exp = 10^(k-1)） */
|
||||
function digit(num: number, exp: number): number {
|
||||
// ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す
|
||||
return Math.floor(num / exp) % 10;
|
||||
}
|
||||
|
||||
/* 計数ソート（nums の k 桁目でソート） */
|
||||
function countingSortDigit(nums: number[], exp: number): void {
|
||||
// 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要
|
||||
const counter = new Array(10).fill(0);
|
||||
const n = nums.length;
|
||||
// 0~9 の各数字の出現回数を集計する
|
||||
for (let i = 0; i < n; i++) {
|
||||
const d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする
|
||||
counter[d]++; // 数字 d の出現回数を数える
|
||||
}
|
||||
// 累積和を求め、「出現回数」を「配列インデックス」に変換する
|
||||
for (let i = 1; i < 10; i++) {
|
||||
counter[i] += counter[i - 1];
|
||||
}
|
||||
// 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する
|
||||
const res = new Array(n).fill(0);
|
||||
for (let i = n - 1; i >= 0; i--) {
|
||||
const d = digit(nums[i], exp);
|
||||
const j = counter[d] - 1; // d の配列内インデックス j を取得する
|
||||
res[j] = nums[i]; // 現在の要素をインデックス j に格納する
|
||||
counter[d]--; // d の個数を 1 減らす
|
||||
}
|
||||
// 結果で元の配列 nums を上書きする
|
||||
for (let i = 0; i < n; i++) {
|
||||
nums[i] = res[i];
|
||||
}
|
||||
}
|
||||
|
||||
/* 基数ソート */
|
||||
function radixSort(nums: number[]): void {
|
||||
// 最大桁数の判定用に配列の最大要素を取得
|
||||
let m: number = Math.max(... nums);
|
||||
// 下位桁から上位桁の順に走査する
|
||||
for (let exp = 1; exp <= m; exp *= 10) {
|
||||
// 配列要素の k 桁目に対して計数ソートを行う
|
||||
// k = 1 -> exp = 1
|
||||
// k = 2 -> exp = 10
|
||||
// つまり exp = 10^(k-1)
|
||||
countingSortDigit(nums, exp);
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums = [
|
||||
10546151, 35663510, 42865989, 34862445, 81883077, 88906420, 72429244,
|
||||
30524779, 82060337, 63832996,
|
||||
];
|
||||
radixSort(nums);
|
||||
console.log('基数ソート完了後 nums =', nums);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,29 @@
|
||||
/**
|
||||
* File: selection_sort.ts
|
||||
* Created Time: 2023-06-04
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* 選択ソート */
|
||||
function selectionSort(nums: number[]): void {
|
||||
let n = nums.length;
|
||||
// 外側ループ：未整列区間は [i, n-1]
|
||||
for (let i = 0; i < n - 1; i++) {
|
||||
// 内側のループ：未ソート区間の最小要素を見つける
|
||||
let k = i;
|
||||
for (let j = i + 1; j < n; j++) {
|
||||
if (nums[j] < nums[k]) {
|
||||
k = j; // 最小要素のインデックスを記録
|
||||
}
|
||||
}
|
||||
// その最小要素を未整列区間の先頭要素と交換する
|
||||
[nums[i], nums[k]] = [nums[k], nums[i]];
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
const nums: number[] = [4, 1, 3, 1, 5, 2];
|
||||
selectionSort(nums);
|
||||
console.log('選択ソート完了後 nums =', nums);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,158 @@
|
||||
/**
|
||||
* File: array_deque.ts
|
||||
* Created Time: 2023-02-28
|
||||
* Author: Zhuo Qinyue (1403450829@qq.com)
|
||||
*/
|
||||
|
||||
/* 循環配列ベースの両端キュー */
|
||||
class ArrayDeque {
|
||||
private nums: number[]; // 両端キューの要素を格納する配列
|
||||
private front: number; // 先頭ポインタ。先頭要素を指す
|
||||
private queSize: number; // 両端キューの長さ
|
||||
|
||||
/* コンストラクタ */
|
||||
constructor(capacity: number) {
|
||||
this.nums = new Array(capacity);
|
||||
this.front = 0;
|
||||
this.queSize = 0;
|
||||
}
|
||||
|
||||
/* 両端キューの容量を取得 */
|
||||
capacity(): number {
|
||||
return this.nums.length;
|
||||
}
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
size(): number {
|
||||
return this.queSize;
|
||||
}
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
isEmpty(): boolean {
|
||||
return this.queSize === 0;
|
||||
}
|
||||
|
||||
/* 循環配列のインデックスを計算 */
|
||||
index(i: number): number {
|
||||
// 剰余演算により配列の先頭と末尾をつなげる
|
||||
// i が配列の末尾を越えたら先頭に戻る
|
||||
// i が配列の先頭を越えて前に出たら末尾に戻る
|
||||
return (i + this.capacity()) % this.capacity();
|
||||
}
|
||||
|
||||
/* キュー先頭にエンキュー */
|
||||
pushFirst(num: number): void {
|
||||
if (this.queSize === this.capacity()) {
|
||||
console.log('両端キューは満杯です');
|
||||
return;
|
||||
}
|
||||
// 先頭ポインタを左に 1 つ移動する
|
||||
// 剰余演算により、front が配列先頭を越えた後に末尾へ戻るようにする
|
||||
this.front = this.index(this.front - 1);
|
||||
// num をキュー先頭に追加
|
||||
this.nums[this.front] = num;
|
||||
this.queSize++;
|
||||
}
|
||||
|
||||
/* キュー末尾にエンキュー */
|
||||
pushLast(num: number): void {
|
||||
if (this.queSize === this.capacity()) {
|
||||
console.log('両端キューは満杯です');
|
||||
return;
|
||||
}
|
||||
// キュー末尾ポインタを計算し、末尾インデックス + 1 を指す
|
||||
const rear: number = this.index(this.front + this.queSize);
|
||||
// num をキュー末尾に追加
|
||||
this.nums[rear] = num;
|
||||
this.queSize++;
|
||||
}
|
||||
|
||||
/* キュー先頭からデキュー */
|
||||
popFirst(): number {
|
||||
const num: number = this.peekFirst();
|
||||
// 先頭ポインタを 1 つ後ろへ進める
|
||||
this.front = this.index(this.front + 1);
|
||||
this.queSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* キュー末尾からデキュー */
|
||||
popLast(): number {
|
||||
const num: number = this.peekLast();
|
||||
this.queSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
peekFirst(): number {
|
||||
if (this.isEmpty()) throw new Error('The Deque Is Empty.');
|
||||
return this.nums[this.front];
|
||||
}
|
||||
|
||||
/* キュー末尾の要素にアクセス */
|
||||
peekLast(): number {
|
||||
if (this.isEmpty()) throw new Error('The Deque Is Empty.');
|
||||
// 末尾要素のインデックスを計算
|
||||
const last = this.index(this.front + this.queSize - 1);
|
||||
return this.nums[last];
|
||||
}
|
||||
|
||||
/* 出力用の配列を返す */
|
||||
toArray(): number[] {
|
||||
// 有効長の範囲内のリスト要素のみを変換
|
||||
const res: number[] = [];
|
||||
for (let i = 0, j = this.front; i < this.queSize; i++, j++) {
|
||||
res[i] = this.nums[this.index(j)];
|
||||
}
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 両端キューを初期化 */
|
||||
const capacity = 5;
|
||||
const deque: ArrayDeque = new ArrayDeque(capacity);
|
||||
deque.pushLast(3);
|
||||
deque.pushLast(2);
|
||||
deque.pushLast(5);
|
||||
console.log('両端キュー deque = [' + deque.toArray() + ']');
|
||||
|
||||
/* 要素にアクセス */
|
||||
const peekFirst = deque.peekFirst();
|
||||
console.log('先頭要素 peekFirst = ' + peekFirst);
|
||||
const peekLast = deque.peekLast();
|
||||
console.log('末尾要素 peekLast = ' + peekLast);
|
||||
|
||||
/* 要素をエンキュー */
|
||||
deque.pushLast(4);
|
||||
console.log('要素 4 を末尾に追加後 deque = [' + deque.toArray() + ']');
|
||||
deque.pushFirst(1);
|
||||
console.log('要素 1 を先頭に追加後 deque = [' + deque.toArray() + ']');
|
||||
|
||||
/* 要素をデキュー */
|
||||
const popLast = deque.popLast();
|
||||
console.log(
|
||||
'末尾から取り出した要素 = ' +
|
||||
popLast +
|
||||
'、末尾から取り出し後 deque = [' +
|
||||
deque.toArray() +
|
||||
']'
|
||||
);
|
||||
const popFirst = deque.popFirst();
|
||||
console.log(
|
||||
'先頭から取り出した要素 = ' +
|
||||
popFirst +
|
||||
'、先頭から取り出し後 deque = [' +
|
||||
deque.toArray() +
|
||||
']'
|
||||
);
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
const size = deque.size();
|
||||
console.log('両端キューの長さ size = ' + size);
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
const isEmpty = deque.isEmpty();
|
||||
console.log('両端キューが空かどうか = ' + isEmpty);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,109 @@
|
||||
/**
|
||||
* File: array_queue.ts
|
||||
* Created Time: 2022-12-11
|
||||
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
|
||||
*/
|
||||
|
||||
/* 循環配列ベースのキュー */
|
||||
class ArrayQueue {
|
||||
private nums: number[]; // キュー要素を格納する配列
|
||||
private front: number; // 先頭ポインタ。先頭要素を指す
|
||||
private queSize: number; // キューの長さ
|
||||
|
||||
constructor(capacity: number) {
|
||||
this.nums = new Array(capacity);
|
||||
this.front = this.queSize = 0;
|
||||
}
|
||||
|
||||
/* キューの容量を取得 */
|
||||
get capacity(): number {
|
||||
return this.nums.length;
|
||||
}
|
||||
|
||||
/* キューの長さを取得 */
|
||||
get size(): number {
|
||||
return this.queSize;
|
||||
}
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
isEmpty(): boolean {
|
||||
return this.queSize === 0;
|
||||
}
|
||||
|
||||
/* エンキュー */
|
||||
push(num: number): void {
|
||||
if (this.size === this.capacity) {
|
||||
console.log('キューは満杯です');
|
||||
return;
|
||||
}
|
||||
// 末尾ポインタを計算し、末尾インデックス + 1 を指す
|
||||
// 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
|
||||
const rear = (this.front + this.queSize) % this.capacity;
|
||||
// num をキュー末尾に追加
|
||||
this.nums[rear] = num;
|
||||
this.queSize++;
|
||||
}
|
||||
|
||||
/* デキュー */
|
||||
pop(): number {
|
||||
const num = this.peek();
|
||||
// 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
|
||||
this.front = (this.front + 1) % this.capacity;
|
||||
this.queSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
peek(): number {
|
||||
if (this.isEmpty()) throw new Error('キューが空です');
|
||||
return this.nums[this.front];
|
||||
}
|
||||
|
||||
/* Array を返す */
|
||||
toArray(): number[] {
|
||||
// 有効長の範囲内のリスト要素のみを変換
|
||||
const arr = new Array(this.size);
|
||||
for (let i = 0, j = this.front; i < this.size; i++, j++) {
|
||||
arr[i] = this.nums[j % this.capacity];
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* キューを初期化 */
|
||||
const capacity = 10;
|
||||
const queue = new ArrayQueue(capacity);
|
||||
|
||||
/* 要素をエンキュー */
|
||||
queue.push(1);
|
||||
queue.push(3);
|
||||
queue.push(2);
|
||||
queue.push(5);
|
||||
queue.push(4);
|
||||
console.log('キュー queue =', queue.toArray());
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
const peek = queue.peek();
|
||||
console.log('先頭要素 peek = ' + peek);
|
||||
|
||||
/* 要素をデキュー */
|
||||
const pop = queue.pop();
|
||||
console.log('デキューした要素 pop = ' + pop + '，デキュー後 queue =', queue.toArray());
|
||||
|
||||
/* キューの長さを取得 */
|
||||
const size = queue.size;
|
||||
console.log('キューの長さ size = ' + size);
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
const isEmpty = queue.isEmpty();
|
||||
console.log('キューが空かどうか = ' + isEmpty);
|
||||
|
||||
/* 循環配列をテストする */
|
||||
for (let i = 0; i < 10; i++) {
|
||||
queue.push(i);
|
||||
queue.pop();
|
||||
console.log('第 ' + i + ' 回目のエンキュー + デキュー後 queue =', queue.toArray());
|
||||
}
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,77 @@
|
||||
/**
|
||||
* File: array_stack.ts
|
||||
* Created Time: 2022-12-08
|
||||
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
|
||||
*/
|
||||
|
||||
/* 配列ベースのスタック */
|
||||
class ArrayStack {
|
||||
private stack: number[];
|
||||
constructor() {
|
||||
this.stack = [];
|
||||
}
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
get size(): number {
|
||||
return this.stack.length;
|
||||
}
|
||||
|
||||
/* スタックが空かどうかを判定 */
|
||||
isEmpty(): boolean {
|
||||
return this.stack.length === 0;
|
||||
}
|
||||
|
||||
/* プッシュ */
|
||||
push(num: number): void {
|
||||
this.stack.push(num);
|
||||
}
|
||||
|
||||
/* ポップ */
|
||||
pop(): number | undefined {
|
||||
if (this.isEmpty()) throw new Error('スタックが空です');
|
||||
return this.stack.pop();
|
||||
}
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
top(): number | undefined {
|
||||
if (this.isEmpty()) throw new Error('スタックが空です');
|
||||
return this.stack[this.stack.length - 1];
|
||||
}
|
||||
|
||||
/* Array を返す */
|
||||
toArray() {
|
||||
return this.stack;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* スタックを初期化 */
|
||||
const stack = new ArrayStack();
|
||||
|
||||
/* 要素をプッシュ */
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
console.log('スタック stack = ');
|
||||
console.log(stack.toArray());
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
const top = stack.top();
|
||||
console.log('スタックトップ要素 top = ' + top);
|
||||
|
||||
/* 要素をポップ */
|
||||
const pop = stack.pop();
|
||||
console.log('ポップした要素 pop = ' + pop + '，ポップ後 stack = ');
|
||||
console.log(stack.toArray());
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
const size = stack.size;
|
||||
console.log('スタックの長さ size = ' + size);
|
||||
|
||||
/* 空かどうかを判定 */
|
||||
const isEmpty = stack.isEmpty();
|
||||
console.log('スタックが空かどうか = ' + isEmpty);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,46 @@
|
||||
/**
|
||||
* File: deque.ts
|
||||
* Created Time: 2023-01-17
|
||||
* Author: Zhuo Qinyue (1403450829@qq.com)
|
||||
*/
|
||||
|
||||
/* Driver Code */
|
||||
/* 両端キューを初期化 */
|
||||
// TypeScript には組み込みの両端キューがないため、Array を両端キューとして使う
|
||||
const deque: number[] = [];
|
||||
|
||||
/* 要素をエンキュー */
|
||||
deque.push(2);
|
||||
deque.push(5);
|
||||
deque.push(4);
|
||||
// 注意: 配列であるため、unshift() メソッドの時間計算量は O(n)
|
||||
deque.unshift(3);
|
||||
deque.unshift(1);
|
||||
console.log('両端キュー deque = ', deque);
|
||||
|
||||
/* 要素にアクセス */
|
||||
const peekFirst: number = deque[0];
|
||||
console.log('先頭要素 peekFirst = ' + peekFirst);
|
||||
const peekLast: number = deque[deque.length - 1];
|
||||
console.log('末尾要素 peekLast = ' + peekLast);
|
||||
|
||||
/* 要素をデキュー */
|
||||
// 注意: 配列であるため、shift() メソッドの時間計算量は O(n)
|
||||
const popFront: number = deque.shift() as number;
|
||||
console.log(
|
||||
'先頭からデキューした要素 popFront = ' + popFront + '，先頭からデキュー後 deque = ' + deque
|
||||
);
|
||||
const popBack: number = deque.pop() as number;
|
||||
console.log(
|
||||
'末尾からデキューした要素 popBack = ' + popBack + '，末尾からデキュー後 deque = ' + deque
|
||||
);
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
const size: number = deque.length;
|
||||
console.log('両端キューの長さ size = ' + size);
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
const isEmpty: boolean = size === 0;
|
||||
console.log('両端キューが空かどうか = ' + isEmpty);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,167 @@
|
||||
/**
|
||||
* File: linkedlist_deque.ts
|
||||
* Created Time: 2023-02-04
|
||||
* Author: Zhuo Qinyue (1403450829@qq.com)
|
||||
*/
|
||||
|
||||
/* 双方向連結リストノード */
|
||||
class ListNode {
|
||||
prev: ListNode; // 前駆ノードへの参照（ポインタ）
|
||||
next: ListNode; // 後継ノードへの参照（ポインタ）
|
||||
val: number; // ノード値
|
||||
|
||||
constructor(val: number) {
|
||||
this.val = val;
|
||||
this.next = null;
|
||||
this.prev = null;
|
||||
}
|
||||
}
|
||||
|
||||
/* 双方向連結リストベースの両端キュー */
|
||||
class LinkedListDeque {
|
||||
private front: ListNode; // 先頭ノード front
|
||||
private rear: ListNode; // 末尾ノード rear
|
||||
private queSize: number; // 両端キューの長さ
|
||||
|
||||
constructor() {
|
||||
this.front = null;
|
||||
this.rear = null;
|
||||
this.queSize = 0;
|
||||
}
|
||||
|
||||
/* 末尾へのエンキュー操作 */
|
||||
pushLast(val: number): void {
|
||||
const node: ListNode = new ListNode(val);
|
||||
// 連結リストが空なら、front と rear の両方を node に向ける
|
||||
if (this.queSize === 0) {
|
||||
this.front = node;
|
||||
this.rear = node;
|
||||
} else {
|
||||
// node を連結リストの末尾に追加
|
||||
this.rear.next = node;
|
||||
node.prev = this.rear;
|
||||
this.rear = node; // 末尾ノードを更新する
|
||||
}
|
||||
this.queSize++;
|
||||
}
|
||||
|
||||
/* 先頭へのエンキュー操作 */
|
||||
pushFirst(val: number): void {
|
||||
const node: ListNode = new ListNode(val);
|
||||
// 連結リストが空なら、front と rear の両方を node に向ける
|
||||
if (this.queSize === 0) {
|
||||
this.front = node;
|
||||
this.rear = node;
|
||||
} else {
|
||||
// node を連結リストの先頭に追加
|
||||
this.front.prev = node;
|
||||
node.next = this.front;
|
||||
this.front = node; // 先頭ノードを更新する
|
||||
}
|
||||
this.queSize++;
|
||||
}
|
||||
|
||||
/* キュー末尾からの取り出し */
|
||||
popLast(): number {
|
||||
if (this.queSize === 0) {
|
||||
return null;
|
||||
}
|
||||
const value: number = this.rear.val; // 末尾ノードの値を保存する
|
||||
// 末尾ノードを削除
|
||||
let temp: ListNode = this.rear.prev;
|
||||
if (temp !== null) {
|
||||
temp.next = null;
|
||||
this.rear.prev = null;
|
||||
}
|
||||
this.rear = temp; // 末尾ノードを更新する
|
||||
this.queSize--;
|
||||
return value;
|
||||
}
|
||||
|
||||
/* キュー先頭からの取り出し */
|
||||
popFirst(): number {
|
||||
if (this.queSize === 0) {
|
||||
return null;
|
||||
}
|
||||
const value: number = this.front.val; // 末尾ノードの値を保存する
|
||||
// 先頭ノードを削除
|
||||
let temp: ListNode = this.front.next;
|
||||
if (temp !== null) {
|
||||
temp.prev = null;
|
||||
this.front.next = null;
|
||||
}
|
||||
this.front = temp; // 先頭ノードを更新する
|
||||
this.queSize--;
|
||||
return value;
|
||||
}
|
||||
|
||||
/* キュー末尾の要素にアクセス */
|
||||
peekLast(): number {
|
||||
return this.queSize === 0 ? null : this.rear.val;
|
||||
}
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
peekFirst(): number {
|
||||
return this.queSize === 0 ? null : this.front.val;
|
||||
}
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
size(): number {
|
||||
return this.queSize;
|
||||
}
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
isEmpty(): boolean {
|
||||
return this.queSize === 0;
|
||||
}
|
||||
|
||||
/* 両端キューを出力する */
|
||||
print(): void {
|
||||
const arr: number[] = [];
|
||||
let temp: ListNode = this.front;
|
||||
while (temp !== null) {
|
||||
arr.push(temp.val);
|
||||
temp = temp.next;
|
||||
}
|
||||
console.log('[' + arr.join(', ') + ']');
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 両端キューを初期化 */
|
||||
const linkedListDeque: LinkedListDeque = new LinkedListDeque();
|
||||
linkedListDeque.pushLast(3);
|
||||
linkedListDeque.pushLast(2);
|
||||
linkedListDeque.pushLast(5);
|
||||
console.log('両端キュー linkedListDeque = ');
|
||||
linkedListDeque.print();
|
||||
|
||||
/* 要素にアクセス */
|
||||
const peekFirst: number = linkedListDeque.peekFirst();
|
||||
console.log('先頭要素 peekFirst = ' + peekFirst);
|
||||
const peekLast: number = linkedListDeque.peekLast();
|
||||
console.log('末尾要素 peekLast = ' + peekLast);
|
||||
|
||||
/* 要素をエンキュー */
|
||||
linkedListDeque.pushLast(4);
|
||||
console.log('要素 4 を末尾にエンキュー後 linkedListDeque = ');
|
||||
linkedListDeque.print();
|
||||
linkedListDeque.pushFirst(1);
|
||||
console.log('要素 1 を先頭にエンキュー後 linkedListDeque = ');
|
||||
linkedListDeque.print();
|
||||
|
||||
/* 要素をデキュー */
|
||||
const popLast: number = linkedListDeque.popLast();
|
||||
console.log('末尾からデキューした要素 = ' + popLast + '，末尾からデキュー後 linkedListDeque = ');
|
||||
linkedListDeque.print();
|
||||
const popFirst: number = linkedListDeque.popFirst();
|
||||
console.log('先頭から取り出した要素 = ' + popFirst + '，先頭を取り出した後の linkedListDeque = ');
|
||||
linkedListDeque.print();
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
const size: number = linkedListDeque.size();
|
||||
console.log('両端キューの長さ size = ' + size);
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
const isEmpty: boolean = linkedListDeque.isEmpty();
|
||||
console.log('両端キューが空かどうか = ' + isEmpty);
|
||||
@@ -0,0 +1,102 @@
|
||||
/**
|
||||
* File: linkedlist_queue.ts
|
||||
* Created Time: 2022-12-19
|
||||
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
|
||||
*/
|
||||
|
||||
import { ListNode } from '../modules/ListNode';
|
||||
|
||||
/* 連結リストベースのキュー */
|
||||
class LinkedListQueue {
|
||||
private front: ListNode | null; // 先頭ノード front
|
||||
private rear: ListNode | null; // 末尾ノード rear
|
||||
private queSize: number = 0;
|
||||
|
||||
constructor() {
|
||||
this.front = null;
|
||||
this.rear = null;
|
||||
}
|
||||
|
||||
/* キューの長さを取得 */
|
||||
get size(): number {
|
||||
return this.queSize;
|
||||
}
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
isEmpty(): boolean {
|
||||
return this.size === 0;
|
||||
}
|
||||
|
||||
/* エンキュー */
|
||||
push(num: number): void {
|
||||
// 末尾ノードの後ろに num を追加
|
||||
const node = new ListNode(num);
|
||||
// キューが空なら、先頭・末尾ノードをともにそのノードに設定
|
||||
if (!this.front) {
|
||||
this.front = node;
|
||||
this.rear = node;
|
||||
// キューが空でなければ、そのノードを末尾ノードの後ろに追加
|
||||
} else {
|
||||
this.rear!.next = node;
|
||||
this.rear = node;
|
||||
}
|
||||
this.queSize++;
|
||||
}
|
||||
|
||||
/* デキュー */
|
||||
pop(): number {
|
||||
const num = this.peek();
|
||||
if (!this.front) throw new Error('キューが空です');
|
||||
// 先頭ノードを削除
|
||||
this.front = this.front.next;
|
||||
this.queSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
peek(): number {
|
||||
if (this.size === 0) throw new Error('キューが空です');
|
||||
return this.front!.val;
|
||||
}
|
||||
|
||||
/* 連結リストを Array に変換して返す */
|
||||
toArray(): number[] {
|
||||
let node = this.front;
|
||||
const res = new Array<number>(this.size);
|
||||
for (let i = 0; i < res.length; i++) {
|
||||
res[i] = node!.val;
|
||||
node = node!.next;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* キューを初期化 */
|
||||
const queue = new LinkedListQueue();
|
||||
|
||||
/* 要素をエンキュー */
|
||||
queue.push(1);
|
||||
queue.push(3);
|
||||
queue.push(2);
|
||||
queue.push(5);
|
||||
queue.push(4);
|
||||
console.log('キュー queue = ' + queue.toArray());
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
const peek = queue.peek();
|
||||
console.log('先頭要素 peek = ' + peek);
|
||||
|
||||
/* 要素をデキュー */
|
||||
const pop = queue.pop();
|
||||
console.log('デキューした要素 pop = ' + pop + '，デキュー後の queue = ' + queue.toArray());
|
||||
|
||||
/* キューの長さを取得 */
|
||||
const size = queue.size;
|
||||
console.log('キューの長さ size = ' + size);
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
const isEmpty = queue.isEmpty();
|
||||
console.log('キューが空かどうか = ' + isEmpty);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,91 @@
|
||||
/**
|
||||
* File: linkedlist_stack.ts
|
||||
* Created Time: 2022-12-21
|
||||
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
|
||||
*/
|
||||
|
||||
import { ListNode } from '../modules/ListNode';
|
||||
|
||||
/* 連結リストベースのスタック */
|
||||
class LinkedListStack {
|
||||
private stackPeek: ListNode | null; // 先頭ノードをスタックトップとする
|
||||
private stkSize: number = 0; // スタックの長さ
|
||||
|
||||
constructor() {
|
||||
this.stackPeek = null;
|
||||
}
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
get size(): number {
|
||||
return this.stkSize;
|
||||
}
|
||||
|
||||
/* スタックが空かどうかを判定 */
|
||||
isEmpty(): boolean {
|
||||
return this.size === 0;
|
||||
}
|
||||
|
||||
/* プッシュ */
|
||||
push(num: number): void {
|
||||
const node = new ListNode(num);
|
||||
node.next = this.stackPeek;
|
||||
this.stackPeek = node;
|
||||
this.stkSize++;
|
||||
}
|
||||
|
||||
/* ポップ */
|
||||
pop(): number {
|
||||
const num = this.peek();
|
||||
if (!this.stackPeek) throw new Error('スタックが空です');
|
||||
this.stackPeek = this.stackPeek.next;
|
||||
this.stkSize--;
|
||||
return num;
|
||||
}
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
peek(): number {
|
||||
if (!this.stackPeek) throw new Error('スタックが空です');
|
||||
return this.stackPeek.val;
|
||||
}
|
||||
|
||||
/* 連結リストを Array に変換して返す */
|
||||
toArray(): number[] {
|
||||
let node = this.stackPeek;
|
||||
const res = new Array<number>(this.size);
|
||||
for (let i = res.length - 1; i >= 0; i--) {
|
||||
res[i] = node!.val;
|
||||
node = node!.next;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* スタックを初期化 */
|
||||
const stack = new LinkedListStack();
|
||||
|
||||
/* 要素をプッシュ */
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
console.log('スタック stack = ' + stack.toArray());
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
const peek = stack.peek();
|
||||
console.log('スタックトップ要素 peek = ' + peek);
|
||||
|
||||
/* 要素をポップ */
|
||||
const pop = stack.pop();
|
||||
console.log('ポップした要素 pop = ' + pop + '，ポップ後の stack = ' + stack.toArray());
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
const size = stack.size;
|
||||
console.log('スタックの長さ size = ' + size);
|
||||
|
||||
/* 空かどうかを判定 */
|
||||
const isEmpty = stack.isEmpty();
|
||||
console.log('スタックが空かどうか = ' + isEmpty);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* File: queue.ts
|
||||
* Created Time: 2022-12-05
|
||||
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
|
||||
*/
|
||||
|
||||
/* Driver Code */
|
||||
/* キューを初期化 */
|
||||
// TypeScript には組み込みのキューがないため、Array をキューとして使う
|
||||
const queue: number[] = [];
|
||||
|
||||
/* 要素をエンキュー */
|
||||
queue.push(1);
|
||||
queue.push(3);
|
||||
queue.push(2);
|
||||
queue.push(5);
|
||||
queue.push(4);
|
||||
console.log('キュー queue =', queue);
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
const peek = queue[0];
|
||||
console.log('先頭要素 peek =', peek);
|
||||
|
||||
/* 要素をデキュー */
|
||||
// 基盤が配列であるため、shift() メソッドの時間計算量は O(n)
|
||||
const pop = queue.shift();
|
||||
console.log('デキューした要素 pop =', pop, '，デキュー後の queue = ', queue);
|
||||
|
||||
/* キューの長さを取得 */
|
||||
const size = queue.length;
|
||||
console.log('キューの長さ size =', size);
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
const isEmpty = queue.length === 0;
|
||||
console.log('キューが空かどうか = ', isEmpty);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* File: stack.ts
|
||||
* Created Time: 2022-12-04
|
||||
* Author: S-N-O-R-L-A-X (snorlax.xu@outlook.com)
|
||||
*/
|
||||
|
||||
/* Driver Code */
|
||||
/* スタックを初期化 */
|
||||
// TypeScript には組み込みのスタッククラスがないため、Array をスタックとして使う
|
||||
const stack: number[] = [];
|
||||
|
||||
/* 要素をプッシュ */
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
console.log('スタック stack =', stack);
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
const peek = stack[stack.length - 1];
|
||||
console.log('スタックトップ要素 peek =', peek);
|
||||
|
||||
/* 要素をポップ */
|
||||
const pop = stack.pop();
|
||||
console.log('ポップした要素 pop =', pop);
|
||||
console.log('ポップ後の stack =', stack);
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
const size = stack.length;
|
||||
console.log('スタックの長さ size =', size);
|
||||
|
||||
/* 空かどうかを判定 */
|
||||
const isEmpty = stack.length === 0;
|
||||
console.log('スタックが空かどうか =', isEmpty);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,151 @@
|
||||
/**
|
||||
* File: array_binary_tree.js
|
||||
* Created Time: 2023-08-09
|
||||
* Author: yuan0221 (yl1452491917@gmail.com)
|
||||
*/
|
||||
|
||||
import { arrToTree } from '../modules/TreeNode';
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
|
||||
type Order = 'pre' | 'in' | 'post';
|
||||
|
||||
/* 配列表現による二分木クラス */
|
||||
class ArrayBinaryTree {
|
||||
#tree: (number | null)[];
|
||||
|
||||
/* コンストラクタ */
|
||||
constructor(arr: (number | null)[]) {
|
||||
this.#tree = arr;
|
||||
}
|
||||
|
||||
/* リスト容量 */
|
||||
size(): number {
|
||||
return this.#tree.length;
|
||||
}
|
||||
|
||||
/* インデックス i のノードの値を取得 */
|
||||
val(i: number): number | null {
|
||||
// インデックスが範囲外なら、空きを表す null を返す
|
||||
if (i < 0 || i >= this.size()) return null;
|
||||
return this.#tree[i];
|
||||
}
|
||||
|
||||
/* インデックス i のノードの左子ノードのインデックスを取得 */
|
||||
left(i: number): number {
|
||||
return 2 * i + 1;
|
||||
}
|
||||
|
||||
/* インデックス i のノードの右子ノードのインデックスを取得 */
|
||||
right(i: number): number {
|
||||
return 2 * i + 2;
|
||||
}
|
||||
|
||||
/* インデックス i のノードの親ノードのインデックスを取得 */
|
||||
parent(i: number): number {
|
||||
return Math.floor((i - 1) / 2); // 切り捨て除算
|
||||
}
|
||||
|
||||
/* レベル順走査 */
|
||||
levelOrder(): number[] {
|
||||
let res = [];
|
||||
// 配列を直接走査する
|
||||
for (let i = 0; i < this.size(); i++) {
|
||||
if (this.val(i) !== null) res.push(this.val(i));
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 深さ優先探索 */
|
||||
#dfs(i: number, order: Order, res: (number | null)[]): void {
|
||||
// 空きスロットなら返す
|
||||
if (this.val(i) === null) return;
|
||||
// 先行順走査
|
||||
if (order === 'pre') res.push(this.val(i));
|
||||
this.#dfs(this.left(i), order, res);
|
||||
// 中順走査
|
||||
if (order === 'in') res.push(this.val(i));
|
||||
this.#dfs(this.right(i), order, res);
|
||||
// 後順走査
|
||||
if (order === 'post') res.push(this.val(i));
|
||||
}
|
||||
|
||||
/* 先行順走査 */
|
||||
preOrder(): (number | null)[] {
|
||||
const res = [];
|
||||
this.#dfs(0, 'pre', res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 中順走査 */
|
||||
inOrder(): (number | null)[] {
|
||||
const res = [];
|
||||
this.#dfs(0, 'in', res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 後順走査 */
|
||||
postOrder(): (number | null)[] {
|
||||
const res = [];
|
||||
this.#dfs(0, 'post', res);
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
// 二分木を初期化
|
||||
// ここでは、配列から直接二分木を生成する関数を利用する
|
||||
const arr = Array.of(
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
4,
|
||||
null,
|
||||
6,
|
||||
7,
|
||||
8,
|
||||
9,
|
||||
null,
|
||||
null,
|
||||
12,
|
||||
null,
|
||||
null,
|
||||
15
|
||||
);
|
||||
|
||||
const root = arrToTree(arr);
|
||||
console.log('\n二分木を初期化する\n');
|
||||
console.log('二分木の配列表現：');
|
||||
console.log(arr);
|
||||
console.log('二分木の連結リスト表現：');
|
||||
printTree(root);
|
||||
|
||||
// 配列表現による二分木クラス
|
||||
const abt = new ArrayBinaryTree(arr);
|
||||
|
||||
// ノードにアクセス
|
||||
const i = 1;
|
||||
const l = abt.left(i);
|
||||
const r = abt.right(i);
|
||||
const p = abt.parent(i);
|
||||
console.log('\n現在のノードのインデックスは ' + i + ' 、値は ' + abt.val(i));
|
||||
console.log(
|
||||
'その左子ノードのインデックスは ' + l + ' 、値は ' + (l === null ? 'null' : abt.val(l))
|
||||
);
|
||||
console.log(
|
||||
'その右子ノードのインデックスは ' + r + ' 、値は ' + (r === null ? 'null' : abt.val(r))
|
||||
);
|
||||
console.log(
|
||||
'その親ノードのインデックスは ' + p + ' 、値は ' + (p === null ? 'null' : abt.val(p))
|
||||
);
|
||||
|
||||
// 木を走査
|
||||
let res = abt.levelOrder();
|
||||
console.log('\nレベル順走査：' + res);
|
||||
res = abt.preOrder();
|
||||
console.log('先行順走査：' + res);
|
||||
res = abt.inOrder();
|
||||
console.log('中間順走査：' + res);
|
||||
res = abt.postOrder();
|
||||
console.log('後行順走査：' + res);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,222 @@
|
||||
/**
|
||||
* File: avl_tree.ts
|
||||
* Created Time: 2023-02-06
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { TreeNode } from '../modules/TreeNode';
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
|
||||
/* AVL 木 */
|
||||
class AVLTree {
|
||||
root: TreeNode;
|
||||
/* コンストラクタ */
|
||||
constructor() {
|
||||
this.root = null; // 根ノード
|
||||
}
|
||||
|
||||
/* ノードの高さを取得 */
|
||||
height(node: TreeNode): number {
|
||||
// 空ノードの高さは -1、葉ノードの高さは 0
|
||||
return node === null ? -1 : node.height;
|
||||
}
|
||||
|
||||
/* ノードの高さを更新する */
|
||||
private updateHeight(node: TreeNode): void {
|
||||
// ノードの高さは最も高い部分木の高さ + 1 に等しい
|
||||
node.height =
|
||||
Math.max(this.height(node.left), this.height(node.right)) + 1;
|
||||
}
|
||||
|
||||
/* 平衡係数を取得 */
|
||||
balanceFactor(node: TreeNode): number {
|
||||
// 空ノードの平衡係数は 0
|
||||
if (node === null) return 0;
|
||||
// ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ
|
||||
return this.height(node.left) - this.height(node.right);
|
||||
}
|
||||
|
||||
/* 右回転 */
|
||||
private rightRotate(node: TreeNode): TreeNode {
|
||||
const child = node.left;
|
||||
const grandChild = child.right;
|
||||
// child を支点として node を右回転させる
|
||||
child.right = node;
|
||||
node.left = grandChild;
|
||||
// ノードの高さを更新する
|
||||
this.updateHeight(node);
|
||||
this.updateHeight(child);
|
||||
// 回転後の部分木の根ノードを返す
|
||||
return child;
|
||||
}
|
||||
|
||||
/* 左回転 */
|
||||
private leftRotate(node: TreeNode): TreeNode {
|
||||
const child = node.right;
|
||||
const grandChild = child.left;
|
||||
// child を支点として node を左回転させる
|
||||
child.left = node;
|
||||
node.right = grandChild;
|
||||
// ノードの高さを更新する
|
||||
this.updateHeight(node);
|
||||
this.updateHeight(child);
|
||||
// 回転後の部分木の根ノードを返す
|
||||
return child;
|
||||
}
|
||||
|
||||
/* 回転操作を行い、この部分木の平衡を回復する */
|
||||
private rotate(node: TreeNode): TreeNode {
|
||||
// ノード node の平衡係数を取得
|
||||
const balanceFactor = this.balanceFactor(node);
|
||||
// 左に偏った木
|
||||
if (balanceFactor > 1) {
|
||||
if (this.balanceFactor(node.left) >= 0) {
|
||||
// 右回転
|
||||
return this.rightRotate(node);
|
||||
} else {
|
||||
// 左回転してから右回転
|
||||
node.left = this.leftRotate(node.left);
|
||||
return this.rightRotate(node);
|
||||
}
|
||||
}
|
||||
// 右に偏った木
|
||||
if (balanceFactor < -1) {
|
||||
if (this.balanceFactor(node.right) <= 0) {
|
||||
// 左回転
|
||||
return this.leftRotate(node);
|
||||
} else {
|
||||
// 右回転してから左回転
|
||||
node.right = this.rightRotate(node.right);
|
||||
return this.leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡木なので回転不要、そのまま返す
|
||||
return node;
|
||||
}
|
||||
|
||||
/* ノードを挿入 */
|
||||
insert(val: number): void {
|
||||
this.root = this.insertHelper(this.root, val);
|
||||
}
|
||||
|
||||
/* ノードを再帰的に挿入する（補助メソッド） */
|
||||
private insertHelper(node: TreeNode, val: number): TreeNode {
|
||||
if (node === null) return new TreeNode(val);
|
||||
/* 1. 挿入位置を探索してノードを挿入 */
|
||||
if (val < node.val) {
|
||||
node.left = this.insertHelper(node.left, val);
|
||||
} else if (val > node.val) {
|
||||
node.right = this.insertHelper(node.right, val);
|
||||
} else {
|
||||
return node; // 重複ノードは挿入せず、そのまま返す
|
||||
}
|
||||
this.updateHeight(node); // ノードの高さを更新する
|
||||
/* 2. 回転操作を行い、部分木の平衡を回復する */
|
||||
node = this.rotate(node);
|
||||
// 部分木の根ノードを返す
|
||||
return node;
|
||||
}
|
||||
|
||||
/* ノードを削除 */
|
||||
remove(val: number): void {
|
||||
this.root = this.removeHelper(this.root, val);
|
||||
}
|
||||
|
||||
/* ノードを再帰的に削除する（補助メソッド） */
|
||||
private removeHelper(node: TreeNode, val: number): TreeNode {
|
||||
if (node === null) return null;
|
||||
/* 1. ノードを探索して削除 */
|
||||
if (val < node.val) {
|
||||
node.left = this.removeHelper(node.left, val);
|
||||
} else if (val > node.val) {
|
||||
node.right = this.removeHelper(node.right, val);
|
||||
} else {
|
||||
if (node.left === null || node.right === null) {
|
||||
const child = node.left !== null ? node.left : node.right;
|
||||
// 子ノード数 = 0 の場合、node をそのまま削除して返す
|
||||
if (child === null) {
|
||||
return null;
|
||||
} else {
|
||||
// 子ノード数 = 1 の場合、node をそのまま削除する
|
||||
node = child;
|
||||
}
|
||||
} else {
|
||||
// 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
|
||||
let temp = node.right;
|
||||
while (temp.left !== null) {
|
||||
temp = temp.left;
|
||||
}
|
||||
node.right = this.removeHelper(node.right, temp.val);
|
||||
node.val = temp.val;
|
||||
}
|
||||
}
|
||||
this.updateHeight(node); // ノードの高さを更新する
|
||||
/* 2. 回転操作を行い、部分木の平衡を回復する */
|
||||
node = this.rotate(node);
|
||||
// 部分木の根ノードを返す
|
||||
return node;
|
||||
}
|
||||
|
||||
/* ノードを探索 */
|
||||
search(val: number): TreeNode {
|
||||
let cur = this.root;
|
||||
// ループで探索し、葉ノードを越えたら抜ける
|
||||
while (cur !== null) {
|
||||
if (cur.val < val) {
|
||||
// 目標ノードは cur の右部分木にある
|
||||
cur = cur.right;
|
||||
} else if (cur.val > val) {
|
||||
// 目標ノードは cur の左部分木にある
|
||||
cur = cur.left;
|
||||
} else {
|
||||
// 目標ノードが見つかったらループを抜ける
|
||||
break;
|
||||
}
|
||||
}
|
||||
// 目標ノードを返す
|
||||
return cur;
|
||||
}
|
||||
}
|
||||
|
||||
function testInsert(tree: AVLTree, val: number): void {
|
||||
tree.insert(val);
|
||||
console.log('\nノード ' + val + ' を挿入した後、AVL 木は');
|
||||
printTree(tree.root);
|
||||
}
|
||||
|
||||
function testRemove(tree: AVLTree, val: number): void {
|
||||
tree.remove(val);
|
||||
console.log('\nノード ' + val + ' を削除した後、AVL 木は');
|
||||
printTree(tree.root);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 空の AVL 木を初期化する */
|
||||
const avlTree = new AVLTree();
|
||||
/* ノードを挿入 */
|
||||
// ノード挿入後に AVL 木がどのように平衡を保つかに注目してほしい
|
||||
testInsert(avlTree, 1);
|
||||
testInsert(avlTree, 2);
|
||||
testInsert(avlTree, 3);
|
||||
testInsert(avlTree, 4);
|
||||
testInsert(avlTree, 5);
|
||||
testInsert(avlTree, 8);
|
||||
testInsert(avlTree, 7);
|
||||
testInsert(avlTree, 9);
|
||||
testInsert(avlTree, 10);
|
||||
testInsert(avlTree, 6);
|
||||
|
||||
/* 重複ノードを挿入する */
|
||||
testInsert(avlTree, 7);
|
||||
|
||||
/* ノードを削除 */
|
||||
// ノード削除後に AVL 木がどのように平衡を保つかに注目してほしい
|
||||
testRemove(avlTree, 8); // 次数 0 のノードを削除する
|
||||
testRemove(avlTree, 5); // 次数 1 のノードを削除する
|
||||
testRemove(avlTree, 4); // 次数 2 のノードを削除する
|
||||
|
||||
/* ノードを検索 */
|
||||
const node = avlTree.search(7);
|
||||
console.log('\n見つかったノードオブジェクトは', node, '、ノードの値 = ' + node.val);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,146 @@
|
||||
/**
|
||||
* File: binary_search_tree.ts
|
||||
* Created Time: 2022-12-14
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { TreeNode } from '../modules/TreeNode';
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
|
||||
/* 二分探索木 */
|
||||
class BinarySearchTree {
|
||||
private root: TreeNode | null;
|
||||
|
||||
/* コンストラクタ */
|
||||
constructor() {
|
||||
// 空の木を初期化する
|
||||
this.root = null;
|
||||
}
|
||||
|
||||
/* 二分木の根ノードを取得 */
|
||||
getRoot(): TreeNode | null {
|
||||
return this.root;
|
||||
}
|
||||
|
||||
/* ノードを探索 */
|
||||
search(num: number): TreeNode | null {
|
||||
let cur = this.root;
|
||||
// ループで探索し、葉ノードを越えたら抜ける
|
||||
while (cur !== null) {
|
||||
// 目標ノードは cur の右部分木にある
|
||||
if (cur.val < num) cur = cur.right;
|
||||
// 目標ノードは cur の左部分木にある
|
||||
else if (cur.val > num) cur = cur.left;
|
||||
// 目標ノードが見つかったらループを抜ける
|
||||
else break;
|
||||
}
|
||||
// 目標ノードを返す
|
||||
return cur;
|
||||
}
|
||||
|
||||
/* ノードを挿入 */
|
||||
insert(num: number): void {
|
||||
// 木が空なら、根ノードを初期化する
|
||||
if (this.root === null) {
|
||||
this.root = new TreeNode(num);
|
||||
return;
|
||||
}
|
||||
let cur: TreeNode | null = this.root,
|
||||
pre: TreeNode | null = null;
|
||||
// ループで探索し、葉ノードを越えたら抜ける
|
||||
while (cur !== null) {
|
||||
// 重複ノードが見つかったら、直ちに返す
|
||||
if (cur.val === num) return;
|
||||
pre = cur;
|
||||
// 挿入位置は cur の右部分木にある
|
||||
if (cur.val < num) cur = cur.right;
|
||||
// 挿入位置は cur の左部分木にある
|
||||
else cur = cur.left;
|
||||
}
|
||||
// ノードを挿入
|
||||
const node = new TreeNode(num);
|
||||
if (pre!.val < num) pre!.right = node;
|
||||
else pre!.left = node;
|
||||
}
|
||||
|
||||
/* ノードを削除 */
|
||||
remove(num: number): void {
|
||||
// 木が空なら、そのまま早期リターンする
|
||||
if (this.root === null) return;
|
||||
let cur: TreeNode | null = this.root,
|
||||
pre: TreeNode | null = null;
|
||||
// ループで探索し、葉ノードを越えたら抜ける
|
||||
while (cur !== null) {
|
||||
// 削除対象のノードが見つかったら、ループを抜ける
|
||||
if (cur.val === num) break;
|
||||
pre = cur;
|
||||
// 削除対象ノードは cur の右部分木にある
|
||||
if (cur.val < num) cur = cur.right;
|
||||
// 削除対象ノードは cur の左部分木にある
|
||||
else cur = cur.left;
|
||||
}
|
||||
// 削除対象ノードがなければそのまま返す
|
||||
if (cur === null) return;
|
||||
// 子ノード数 = 0 or 1
|
||||
if (cur.left === null || cur.right === null) {
|
||||
// 子ノード数が 0 / 1 のとき、child = null / その子ノード
|
||||
const child: TreeNode | null =
|
||||
cur.left !== null ? cur.left : cur.right;
|
||||
// ノード cur を削除する
|
||||
if (cur !== this.root) {
|
||||
if (pre!.left === cur) pre!.left = child;
|
||||
else pre!.right = child;
|
||||
} else {
|
||||
// 削除ノードが根ノードなら、根ノードを再設定
|
||||
this.root = child;
|
||||
}
|
||||
}
|
||||
// 子ノード数 = 2
|
||||
else {
|
||||
// 中順走査における cur の次ノードを取得
|
||||
let tmp: TreeNode | null = cur.right;
|
||||
while (tmp!.left !== null) {
|
||||
tmp = tmp!.left;
|
||||
}
|
||||
// ノード tmp を再帰的に削除
|
||||
this.remove(tmp!.val);
|
||||
// tmp で cur を上書きする
|
||||
cur.val = tmp!.val;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 二分探索木を初期化 */
|
||||
const bst = new BinarySearchTree();
|
||||
// 注意：挿入順序が異なると異なる二分木が生成される。このシーケンスからは完全二分木を生成できる
|
||||
const nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15];
|
||||
for (const num of nums) {
|
||||
bst.insert(num);
|
||||
}
|
||||
console.log('\n初期化された二分木は\n');
|
||||
printTree(bst.getRoot());
|
||||
|
||||
/* ノードを探索 */
|
||||
const node = bst.search(7);
|
||||
console.log(
|
||||
'\n見つかったノードオブジェクトは ' + node + '、ノードの値 = ' + (node ? node.val : 'null')
|
||||
);
|
||||
|
||||
/* ノードを挿入 */
|
||||
bst.insert(16);
|
||||
console.log('\nノード 16 を挿入した後、二分木は\n');
|
||||
printTree(bst.getRoot());
|
||||
|
||||
/* ノードを削除 */
|
||||
bst.remove(1);
|
||||
console.log('\nノード 1 を削除した後、二分木は\n');
|
||||
printTree(bst.getRoot());
|
||||
bst.remove(2);
|
||||
console.log('\nノード 2 を削除した後、二分木は\n');
|
||||
printTree(bst.getRoot());
|
||||
bst.remove(4);
|
||||
console.log('\nノード 4 を削除した後、二分木は\n');
|
||||
printTree(bst.getRoot());
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* File: binary_tree.ts
|
||||
* Created Time: 2022-12-13
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { TreeNode } from '../modules/TreeNode';
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
|
||||
/* 二分木を初期化 */
|
||||
// ノードを初期化
|
||||
let n1 = new TreeNode(1),
|
||||
n2 = new TreeNode(2),
|
||||
n3 = new TreeNode(3),
|
||||
n4 = new TreeNode(4),
|
||||
n5 = new TreeNode(5);
|
||||
// ノード間の参照（ポインタ）を構築する
|
||||
n1.left = n2;
|
||||
n1.right = n3;
|
||||
n2.left = n4;
|
||||
n2.right = n5;
|
||||
console.log('\n二分木を初期化する\n');
|
||||
printTree(n1);
|
||||
|
||||
/* ノードの挿入と削除 */
|
||||
const P = new TreeNode(0);
|
||||
// n1 -> n2 の間にノード P を挿入
|
||||
n1.left = P;
|
||||
P.left = n2;
|
||||
console.log('\nノード P を挿入した後\n');
|
||||
printTree(n1);
|
||||
// ノード P を削除
|
||||
n1.left = n2;
|
||||
console.log('\nノード P を削除した後\n');
|
||||
printTree(n1);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,41 @@
|
||||
/**
|
||||
* File: binary_tree_bfs.ts
|
||||
* Created Time: 2022-12-14
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { type TreeNode } from '../modules/TreeNode';
|
||||
import { arrToTree } from '../modules/TreeNode';
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
|
||||
/* レベル順走査 */
|
||||
function levelOrder(root: TreeNode | null): number[] {
|
||||
// キューを初期化し、ルートノードを追加する
|
||||
const queue = [root];
|
||||
// 走査順序を保存するためのリストを初期化する
|
||||
const list: number[] = [];
|
||||
while (queue.length) {
|
||||
let node = queue.shift() as TreeNode; // デキュー
|
||||
list.push(node.val); // ノードの値を保存する
|
||||
if (node.left) {
|
||||
queue.push(node.left); // 左子ノードをキューに追加
|
||||
}
|
||||
if (node.right) {
|
||||
queue.push(node.right); // 右子ノードをキューに追加
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 二分木を初期化 */
|
||||
// ここでは、配列から直接二分木を生成する関数を利用する
|
||||
const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
|
||||
console.log('\n二分木を初期化する\n');
|
||||
printTree(root);
|
||||
|
||||
/* レベル順走査 */
|
||||
const list = levelOrder(root);
|
||||
console.log('\nレベル順走査のノード出力シーケンス = ' + list);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,69 @@
|
||||
/**
|
||||
* File: binary_tree_dfs.ts
|
||||
* Created Time: 2022-12-14
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { type TreeNode } from '../modules/TreeNode';
|
||||
import { arrToTree } from '../modules/TreeNode';
|
||||
import { printTree } from '../modules/PrintUtil';
|
||||
|
||||
// 走査順序を格納するリストを初期化
|
||||
const list: number[] = [];
|
||||
|
||||
/* 先行順走査 */
|
||||
function preOrder(root: TreeNode | null): void {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
// 訪問順序：根ノード -> 左部分木 -> 右部分木
|
||||
list.push(root.val);
|
||||
preOrder(root.left);
|
||||
preOrder(root.right);
|
||||
}
|
||||
|
||||
/* 中順走査 */
|
||||
function inOrder(root: TreeNode | null): void {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
// 訪問優先順: 左部分木 -> 根ノード -> 右部分木
|
||||
inOrder(root.left);
|
||||
list.push(root.val);
|
||||
inOrder(root.right);
|
||||
}
|
||||
|
||||
/* 後順走査 */
|
||||
function postOrder(root: TreeNode | null): void {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
// 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
|
||||
postOrder(root.left);
|
||||
postOrder(root.right);
|
||||
list.push(root.val);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
/* 二分木を初期化 */
|
||||
// ここでは、配列から直接二分木を生成する関数を利用する
|
||||
const root = arrToTree([1, 2, 3, 4, 5, 6, 7]);
|
||||
console.log('\n二分木を初期化する\n');
|
||||
printTree(root);
|
||||
|
||||
/* 先行順走査 */
|
||||
list.length = 0;
|
||||
preOrder(root);
|
||||
console.log('\n前順走査のノード出力シーケンス = ' + list);
|
||||
|
||||
/* 中順走査 */
|
||||
list.length = 0;
|
||||
inOrder(root);
|
||||
console.log('\n中順走査のノード出力シーケンス = ' + list);
|
||||
|
||||
/* 後順走査 */
|
||||
list.length = 0;
|
||||
postOrder(root);
|
||||
console.log('\n後順走査のノード出力シーケンス = ' + list);
|
||||
|
||||
export {};
|
||||
@@ -0,0 +1,28 @@
|
||||
/**
|
||||
* File: ListNode.ts
|
||||
* Created Time: 2022-12-10
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* 連結リストノード */
|
||||
class ListNode {
|
||||
val: number;
|
||||
next: ListNode | null;
|
||||
constructor(val?: number, next?: ListNode | null) {
|
||||
this.val = val === undefined ? 0 : val;
|
||||
this.next = next === undefined ? null : next;
|
||||
}
|
||||
}
|
||||
|
||||
/* 配列をデシリアライズして連結リストに変換する */
|
||||
function arrToLinkedList(arr: number[]): ListNode | null {
|
||||
const dum: ListNode = new ListNode(0);
|
||||
let head = dum;
|
||||
for (const val of arr) {
|
||||
head.next = new ListNode(val);
|
||||
head = head.next;
|
||||
}
|
||||
return dum.next;
|
||||
}
|
||||
|
||||
export { ListNode, arrToLinkedList };
|
||||
@@ -0,0 +1,93 @@
|
||||
/**
|
||||
* File: PrintUtil.ts
|
||||
* Created Time: 2022-12-13
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
import { ListNode } from './ListNode';
|
||||
import { TreeNode, arrToTree } from './TreeNode';
|
||||
|
||||
/* 連結リストを出力 */
|
||||
function printLinkedList(head: ListNode | null): void {
|
||||
const list: string[] = [];
|
||||
while (head !== null) {
|
||||
list.push(head.val.toString());
|
||||
head = head.next;
|
||||
}
|
||||
console.log(list.join(' -> '));
|
||||
}
|
||||
|
||||
class Trunk {
|
||||
prev: Trunk | null;
|
||||
str: string;
|
||||
|
||||
constructor(prev: Trunk | null, str: string) {
|
||||
this.prev = prev;
|
||||
this.str = str;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 二分木を出力
|
||||
* This tree printer is borrowed from TECHIE DELIGHT
|
||||
* https://www.techiedelight.com/c-program-print-binary-tree/
|
||||
*/
|
||||
function printTree(root: TreeNode | null) {
|
||||
printTreeHelper(root, null, false);
|
||||
}
|
||||
|
||||
/* 二分木を出力 */
|
||||
function printTreeHelper(
|
||||
root: TreeNode | null,
|
||||
prev: Trunk | null,
|
||||
isRight: boolean
|
||||
) {
|
||||
if (root === null) {
|
||||
return;
|
||||
}
|
||||
|
||||
let prev_str = ' ';
|
||||
const trunk = new Trunk(prev, prev_str);
|
||||
|
||||
printTreeHelper(root.right, trunk, true);
|
||||
|
||||
if (prev === null) {
|
||||
trunk.str = '———';
|
||||
} else if (isRight) {
|
||||
trunk.str = '/———';
|
||||
prev_str = ' |';
|
||||
} else {
|
||||
trunk.str = '\\———';
|
||||
prev.str = prev_str;
|
||||
}
|
||||
|
||||
showTrunks(trunk);
|
||||
console.log(' ' + root.val);
|
||||
|
||||
if (prev) {
|
||||
prev.str = prev_str;
|
||||
}
|
||||
trunk.str = ' |';
|
||||
|
||||
printTreeHelper(root.left, trunk, false);
|
||||
}
|
||||
|
||||
function showTrunks(p: Trunk | null) {
|
||||
if (p === null) {
|
||||
return;
|
||||
}
|
||||
|
||||
showTrunks(p.prev);
|
||||
process.stdout.write(p.str);
|
||||
}
|
||||
|
||||
/* ヒープを出力 */
|
||||
function printHeap(arr: number[]): void {
|
||||
console.log('ヒープの配列表現：');
|
||||
console.log(arr);
|
||||
console.log('ヒープの木構造表現：');
|
||||
const root = arrToTree(arr);
|
||||
printTree(root);
|
||||
}
|
||||
|
||||
export { printLinkedList, printTree, printHeap };
|
||||
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* File: TreeNode.ts
|
||||
* Created Time: 2022-12-13
|
||||
* Author: Justin (xiefahit@gmail.com)
|
||||
*/
|
||||
|
||||
/* 二分木ノード */
|
||||
class TreeNode {
|
||||
val: number; // ノード値
|
||||
height: number; // ノードの高さ
|
||||
left: TreeNode | null; // 左の子ノードへのポインタ
|
||||
right: TreeNode | null; // 右の子ノードへのポインタ
|
||||
constructor(
|
||||
val?: number,
|
||||
height?: number,
|
||||
left?: TreeNode | null,
|
||||
right?: TreeNode | null
|
||||
) {
|
||||
this.val = val === undefined ? 0 : val;
|
||||
this.height = height === undefined ? 0 : height;
|
||||
this.left = left === undefined ? null : left;
|
||||
this.right = right === undefined ? null : right;
|
||||
}
|
||||
}
|
||||
|
||||
/* 配列をデシリアライズして二分木に変換する */
|
||||
function arrToTree(arr: (number | null)[], i: number = 0): TreeNode | null {
|
||||
if (i < 0 || i >= arr.length || arr[i] === null) {
|
||||
return null;
|
||||
}
|
||||
let root = new TreeNode(arr[i]);
|
||||
root.left = arrToTree(arr, 2 * i + 1);
|
||||
root.right = arrToTree(arr, 2 * i + 2);
|
||||
return root;
|
||||
}
|
||||
|
||||
export { TreeNode, arrToTree };
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* File: Vertex.ts
|
||||
* Created Time: 2023-02-15
|
||||
* Author: Zhuo Qinyue (1403450829@qq.com)
|
||||
*/
|
||||
|
||||
/* 頂点クラス */
|
||||
class Vertex {
|
||||
val: number;
|
||||
constructor(val: number) {
|
||||
this.val = val;
|
||||
}
|
||||
|
||||
/* 値リスト vals を入力し、頂点リスト vets を返す */
|
||||
public static valsToVets(vals: number[]): Vertex[] {
|
||||
const vets: Vertex[] = [];
|
||||
for (let i = 0; i < vals.length; i++) {
|
||||
vets[i] = new Vertex(vals[i]);
|
||||
}
|
||||
return vets;
|
||||
}
|
||||
|
||||
/* 頂点リスト vets を入力し、値リスト vals を返す */
|
||||
public static vetsToVals(vets: Vertex[]): number[] {
|
||||
const vals: number[] = [];
|
||||
for (const vet of vets) {
|
||||
vals.push(vet.val);
|
||||
}
|
||||
return vals;
|
||||
}
|
||||
}
|
||||
|
||||
export { Vertex };
|
||||
@@ -0,0 +1,11 @@
|
||||
{
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"scripts": {
|
||||
"check": "tsc"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^24.9.2",
|
||||
"typescript": "^5.9.3"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"baseUrl": ".",
|
||||
"module": "esnext",
|
||||
"moduleResolution": "node",
|
||||
"types": ["@types/node"],
|
||||
"noEmit": true,
|
||||
"target": "esnext",
|
||||
},
|
||||
"include": ["chapter_*/*.ts"],
|
||||
"exclude": ["node_modules"]
|
||||
}
|
||||
Reference in New Issue
Block a user