mirror of
https://github.com/krahets/hello-algo.git
synced 2026-08-13 12:20:57 +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,39 @@
|
||||
import 'dart:io';
|
||||
|
||||
void main() {
|
||||
Directory foldPath = Directory('codes/dart/');
|
||||
List<FileSystemEntity> files = foldPath.listSync();
|
||||
int totalCount = 0;
|
||||
int errorCount = 0;
|
||||
for (var file in files) {
|
||||
if (file.path.endsWith('build.dart')) continue;
|
||||
if (file is File && file.path.endsWith('.dart')) {
|
||||
totalCount++;
|
||||
try {
|
||||
Process.runSync('dart', [file.path]);
|
||||
} catch (e) {
|
||||
errorCount++;
|
||||
print('Error: $e');
|
||||
print('File: ${file.path}');
|
||||
}
|
||||
} else if (file is Directory) {
|
||||
List<FileSystemEntity> subFiles = file.listSync();
|
||||
for (var subFile in subFiles) {
|
||||
if (subFile is File && subFile.path.endsWith('.dart')) {
|
||||
totalCount++;
|
||||
try {
|
||||
Process.runSync('dart', [subFile.path]);
|
||||
} catch (e) {
|
||||
errorCount++;
|
||||
print('Error: $e');
|
||||
print('File: ${file.path}');
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
print('===== Build Complete =====');
|
||||
print('Total: $totalCount');
|
||||
print('Error: $errorCount');
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
/**
|
||||
* File: array.dart
|
||||
* Created Time: 2023-01-20
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
// ignore_for_file: unused_local_variable
|
||||
|
||||
import 'dart:math';
|
||||
|
||||
/* 要素へランダムアクセス */
|
||||
int randomAccess(List<int> nums) {
|
||||
// 区間 [0, nums.length) からランダムに 1 つの数を選ぶ
|
||||
int randomIndex = Random().nextInt(nums.length);
|
||||
// ランダムな要素を取得して返す
|
||||
int randomNum = nums[randomIndex];
|
||||
return randomNum;
|
||||
}
|
||||
|
||||
/* 配列長を拡張する */
|
||||
List<int> extend(List<int> nums, int enlarge) {
|
||||
// 拡張後の長さを持つ配列を初期化する
|
||||
List<int> res = List.filled(nums.length + enlarge, 0);
|
||||
// 元の配列の全要素を新しい配列にコピー
|
||||
for (var i = 0; i < nums.length; i++) {
|
||||
res[i] = nums[i];
|
||||
}
|
||||
// 拡張後の新しい配列を返す
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 配列の添字 index に要素 _num を挿入 */
|
||||
void insert(List<int> nums, int _num, int index) {
|
||||
// インデックス index 以降の全要素を 1 つ後ろへ移動する
|
||||
for (var i = nums.length - 1; i > index; i--) {
|
||||
nums[i] = nums[i - 1];
|
||||
}
|
||||
// _num を index の位置の要素に代入
|
||||
nums[index] = _num;
|
||||
}
|
||||
|
||||
/* index の要素を削除する */
|
||||
void remove(List<int> nums, int index) {
|
||||
// インデックス index より後ろの全要素を 1 つ前へ移動する
|
||||
for (var i = index; i < nums.length - 1; i++) {
|
||||
nums[i] = nums[i + 1];
|
||||
}
|
||||
}
|
||||
|
||||
/* 配列要素を走査する */
|
||||
void traverse(List<int> nums) {
|
||||
int count = 0;
|
||||
// インデックスで配列を走査
|
||||
for (var i = 0; i < nums.length; i++) {
|
||||
count += nums[i];
|
||||
}
|
||||
// 配列要素を直接走査
|
||||
for (int _num in nums) {
|
||||
count += _num;
|
||||
}
|
||||
// forEach メソッドで配列を走査する
|
||||
nums.forEach((_num) {
|
||||
count += _num;
|
||||
});
|
||||
}
|
||||
|
||||
/* 配列内で指定要素を探す */
|
||||
int find(List<int> nums, int target) {
|
||||
for (var i = 0; i < nums.length; i++) {
|
||||
if (nums[i] == target) return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* 配列を初期化 */
|
||||
var arr = List.filled(5, 0);
|
||||
print('配列 arr = $arr');
|
||||
List<int> nums = [1, 3, 2, 5, 4];
|
||||
print('配列 nums = $nums');
|
||||
|
||||
/* ランダムアクセス */
|
||||
int randomNum = randomAccess(nums);
|
||||
print('nums からランダムな要素 $randomNum を取得');
|
||||
|
||||
/* 長さを拡張 */
|
||||
nums = extend(nums, 3);
|
||||
print('配列の長さを 8 に拡張し、nums = $nums を取得');
|
||||
|
||||
/* 要素を挿入する */
|
||||
insert(nums, 6, 3);
|
||||
print("インデックス 3 に数字 6 を挿入し、nums = $nums を取得");
|
||||
|
||||
/* 要素を削除 */
|
||||
remove(nums, 2);
|
||||
print("インデックス 2 の要素を削除し、nums = $nums を取得");
|
||||
|
||||
/* 配列を走査 */
|
||||
traverse(nums);
|
||||
|
||||
/* 要素を探索する */
|
||||
int index = find(nums, 3);
|
||||
print("nums で要素 3 を検索し、インデックス = $index を取得");
|
||||
}
|
||||
@@ -0,0 +1,83 @@
|
||||
/**
|
||||
* File: linked_list.dart
|
||||
* Created Time: 2023-01-23
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/list_node.dart';
|
||||
import '../utils/print_util.dart';
|
||||
|
||||
/* 連結リストでノード n0 の後ろにノード P を挿入する */
|
||||
void insert(ListNode n0, ListNode P) {
|
||||
ListNode? n1 = n0.next;
|
||||
P.next = n1;
|
||||
n0.next = P;
|
||||
}
|
||||
|
||||
/* 連結リストでノード n0 の直後のノードを削除する */
|
||||
void remove(ListNode n0) {
|
||||
if (n0.next == null) return;
|
||||
// n0 -> P -> n1
|
||||
ListNode P = n0.next!;
|
||||
ListNode? n1 = P.next;
|
||||
n0.next = n1;
|
||||
}
|
||||
|
||||
/* 連結リスト内で index 番目のノードにアクセス */
|
||||
ListNode? access(ListNode? head, int index) {
|
||||
for (var i = 0; i < index; i++) {
|
||||
if (head == null) return null;
|
||||
head = head.next;
|
||||
}
|
||||
return head;
|
||||
}
|
||||
|
||||
/* 連結リストで値が target の最初のノードを探す */
|
||||
int find(ListNode? head, int target) {
|
||||
int index = 0;
|
||||
while (head != null) {
|
||||
if (head.val == target) {
|
||||
return index;
|
||||
}
|
||||
head = head.next;
|
||||
index++;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
// 連結リストを初期化する
|
||||
// 各ノードを初期化する
|
||||
ListNode n0 = ListNode(1);
|
||||
ListNode n1 = ListNode(3);
|
||||
ListNode n2 = ListNode(2);
|
||||
ListNode n3 = ListNode(5);
|
||||
ListNode n4 = ListNode(4);
|
||||
// ノード間の参照を構築する
|
||||
n0.next = n1;
|
||||
n1.next = n2;
|
||||
n2.next = n3;
|
||||
n3.next = n4;
|
||||
|
||||
print('初期化した連結リストは');
|
||||
printLinkedList(n0);
|
||||
|
||||
/* ノードを挿入 */
|
||||
insert(n0, ListNode(0));
|
||||
print('ノードを挿入した後の連結リストは');
|
||||
printLinkedList(n0);
|
||||
|
||||
/* ノードを削除 */
|
||||
remove(n0);
|
||||
print('ノードを削除した後の連結リストは');
|
||||
printLinkedList(n0);
|
||||
|
||||
/* ノードにアクセス */
|
||||
ListNode? node = access(n0, 3);
|
||||
print('連結リストのインデックス 3 にあるノードの値 = ${node!.val}');
|
||||
|
||||
/* ノードを探索 */
|
||||
int index = find(n0, 2);
|
||||
print('連結リストで値 2 のノードのインデックス = $index');
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
* File: list.dart
|
||||
* Created Time: 2023-01-24
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
// ignore_for_file: unused_local_variable
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* リストを初期化 */
|
||||
List<int> nums = [1, 3, 2, 5, 4];
|
||||
print('リスト nums = $nums');
|
||||
|
||||
/* 要素にアクセス */
|
||||
int _num = nums[1];
|
||||
print('インデックス 1 の要素にアクセスし、_num = $_num を取得');
|
||||
|
||||
/* 要素を更新 */
|
||||
nums[1] = 0;
|
||||
print('インデックス 1 の要素を 0 に更新し、nums = $nums を取得');
|
||||
|
||||
/* リストを空にする */
|
||||
nums.clear();
|
||||
print('リストを空にした後 nums = $nums');
|
||||
|
||||
/* 末尾に要素を追加 */
|
||||
nums.add(1);
|
||||
nums.add(3);
|
||||
nums.add(2);
|
||||
nums.add(5);
|
||||
nums.add(4);
|
||||
print('要素を追加した後 nums = $nums');
|
||||
|
||||
/* 中間に要素を挿入 */
|
||||
nums.insert(3, 6);
|
||||
print('インデックス 3 に数字 6 を挿入し、nums = $nums を取得');
|
||||
|
||||
/* 要素を削除 */
|
||||
nums.removeAt(3);
|
||||
print('インデックス 3 の要素を削除し、nums = $nums を取得');
|
||||
|
||||
/* インデックスでリストを走査 */
|
||||
int count = 0;
|
||||
for (var i = 0; i < nums.length; i++) {
|
||||
count += nums[i];
|
||||
}
|
||||
/* リスト要素を直接走査 */
|
||||
count = 0;
|
||||
for (var x in nums) {
|
||||
count += x;
|
||||
}
|
||||
|
||||
/* 2 つのリストを連結する */
|
||||
List<int> nums1 = [6, 8, 7, 10, 9];
|
||||
nums.addAll(nums1);
|
||||
print('リスト nums1 を nums の後ろに連結し、nums = $nums を取得');
|
||||
|
||||
/* リストをソート */
|
||||
nums.sort();
|
||||
print('リストをソートした後 nums = $nums');
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
/**
|
||||
* File: my_list.dart
|
||||
* Created Time: 2023-02-05
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
/* リストクラス */
|
||||
class MyList {
|
||||
late List<int> _arr; // 配列（リスト要素を格納）
|
||||
int _capacity = 10; // リスト容量
|
||||
int _size = 0; // リストの長さ（現在の要素数）
|
||||
int _extendRatio = 2; // リスト拡張時の増加倍率
|
||||
|
||||
/* コンストラクタ */
|
||||
MyList() {
|
||||
_arr = List.filled(_capacity, 0);
|
||||
}
|
||||
|
||||
/* リストの長さを取得（現在の要素数） */
|
||||
int size() => _size;
|
||||
|
||||
/* リスト容量を取得する */
|
||||
int capacity() => _capacity;
|
||||
|
||||
/* 要素にアクセス */
|
||||
int get(int index) {
|
||||
if (index >= _size) throw RangeError('インデックスが範囲外です');
|
||||
return _arr[index];
|
||||
}
|
||||
|
||||
/* 要素を更新 */
|
||||
void set(int index, int _num) {
|
||||
if (index >= _size) throw RangeError('インデックスが範囲外です');
|
||||
_arr[index] = _num;
|
||||
}
|
||||
|
||||
/* 末尾に要素を追加 */
|
||||
void add(int _num) {
|
||||
// 要素数が容量を超えると、拡張機構が発動する
|
||||
if (_size == _capacity) extendCapacity();
|
||||
_arr[_size] = _num;
|
||||
// 要素数を更新
|
||||
_size++;
|
||||
}
|
||||
|
||||
/* 中間に要素を挿入 */
|
||||
void insert(int index, int _num) {
|
||||
if (index >= _size) throw RangeError('インデックスが範囲外です');
|
||||
// 要素数が容量を超えると、拡張機構が発動する
|
||||
if (_size == _capacity) extendCapacity();
|
||||
// index 以降の要素をすべて 1 つ後ろへずらす
|
||||
for (var j = _size - 1; j >= index; j--) {
|
||||
_arr[j + 1] = _arr[j];
|
||||
}
|
||||
_arr[index] = _num;
|
||||
// 要素数を更新
|
||||
_size++;
|
||||
}
|
||||
|
||||
/* 要素を削除 */
|
||||
int remove(int index) {
|
||||
if (index >= _size) throw RangeError('インデックスが範囲外です');
|
||||
int _num = _arr[index];
|
||||
// インデックス index より後の要素をすべて 1 つ前に移動する
|
||||
for (var j = index; j < _size - 1; j++) {
|
||||
_arr[j] = _arr[j + 1];
|
||||
}
|
||||
// 要素数を更新
|
||||
_size--;
|
||||
// 削除された要素を返す
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* リストの拡張 */
|
||||
void extendCapacity() {
|
||||
// 元の配列の `_extendRatio` 倍の長さを持つ新しい配列を作成する
|
||||
final _newNums = List.filled(_capacity * _extendRatio, 0);
|
||||
// 元の配列を新しい配列にコピー
|
||||
List.copyRange(_newNums, 0, _arr);
|
||||
// `_arr` の参照を更新
|
||||
_arr = _newNums;
|
||||
// リストの容量を更新
|
||||
_capacity = _arr.length;
|
||||
}
|
||||
|
||||
/* リストを配列に変換する */
|
||||
List<int> toArray() {
|
||||
List<int> arr = [];
|
||||
for (var i = 0; i < _size; i++) {
|
||||
arr.add(get(i));
|
||||
}
|
||||
return arr;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* リストを初期化 */
|
||||
MyList nums = MyList();
|
||||
/* 末尾に要素を追加 */
|
||||
nums.add(1);
|
||||
nums.add(3);
|
||||
nums.add(2);
|
||||
nums.add(5);
|
||||
nums.add(4);
|
||||
print(
|
||||
'リスト nums = ${nums.toArray()} ，容量 = ${nums.capacity()} ，長さ = ${nums.size()}');
|
||||
|
||||
/* 中間に要素を挿入 */
|
||||
nums.insert(3, 6);
|
||||
print('インデックス 3 に数字 6 を挿入し、nums = ${nums.toArray()} を取得');
|
||||
|
||||
/* 要素を削除 */
|
||||
nums.remove(3);
|
||||
print('インデックス 3 の要素を削除し、nums = ${nums.toArray()} を取得');
|
||||
|
||||
/* 要素にアクセス */
|
||||
int _num = nums.get(1);
|
||||
print('インデックス 1 の要素にアクセスし、_num = $_num を取得');
|
||||
|
||||
/* 要素を更新 */
|
||||
nums.set(1, 0);
|
||||
print('インデックス 1 の要素を 0 に更新し、nums = ${nums.toArray()} を取得');
|
||||
|
||||
/* 拡張機構をテストする */
|
||||
for (var i = 0; i < 10; i++) {
|
||||
// i = 5 のとき、リスト長が容量を超えるため、この時点で拡張機構が発動する
|
||||
nums.add(i);
|
||||
}
|
||||
print(
|
||||
'容量拡張後のリスト nums = ${nums.toArray()} ，容量 = ${nums.capacity()} ，長さ = ${nums.size()}');
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
/**
|
||||
* File: n_queens.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：N クイーン */
|
||||
void backtrack(
|
||||
int row,
|
||||
int n,
|
||||
List<List<String>> state,
|
||||
List<List<List<String>>> res,
|
||||
List<bool> cols,
|
||||
List<bool> diags1,
|
||||
List<bool> diags2,
|
||||
) {
|
||||
// すべての行への配置が完了したら、解を記録する
|
||||
if (row == n) {
|
||||
List<List<String>> copyState = [];
|
||||
for (List<String> sRow in state) {
|
||||
copyState.add(List.from(sRow));
|
||||
}
|
||||
res.add(copyState);
|
||||
return;
|
||||
}
|
||||
// すべての列を走査
|
||||
for (int col = 0; col < n; col++) {
|
||||
// このマスに対応する主対角線と副対角線を計算
|
||||
int diag1 = row - col + n - 1;
|
||||
int diag2 = row + col;
|
||||
// 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない
|
||||
if (!cols[col] && !diags1[diag1] && !diags2[diag2]) {
|
||||
// 試行：そのマスにクイーンを置く
|
||||
state[row][col] = "Q";
|
||||
cols[col] = true;
|
||||
diags1[diag1] = true;
|
||||
diags2[diag2] = true;
|
||||
// 次の行に配置する
|
||||
backtrack(row + 1, n, state, res, cols, diags1, diags2);
|
||||
// 戻す：そのマスを空きマスに戻す
|
||||
state[row][col] = "#";
|
||||
cols[col] = false;
|
||||
diags1[diag1] = false;
|
||||
diags2[diag2] = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* N クイーンを解く */
|
||||
List<List<List<String>>> nQueens(int n) {
|
||||
// n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す
|
||||
List<List<String>> state = List.generate(n, (index) => List.filled(n, "#"));
|
||||
List<bool> cols = List.filled(n, false); // 列にクイーンがあるか記録
|
||||
List<bool> diags1 = List.filled(2 * n - 1, false); // 主対角線にクイーンがあるかを記録
|
||||
List<bool> diags2 = List.filled(2 * n - 1, false); // 副対角線にクイーンがあるかを記録
|
||||
List<List<List<String>>> res = [];
|
||||
|
||||
backtrack(0, n, state, res, cols, diags1, diags2);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int n = 4;
|
||||
List<List<List<String>>> res = nQueens(n);
|
||||
print("チェス盤の縦横サイズの入力値は $n");
|
||||
print("クイーンの配置パターンは全部で ${res.length} 通り");
|
||||
for (List<List<String>> state in res) {
|
||||
print("--------------------");
|
||||
for (List<String> row in state) {
|
||||
print(row);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
/**
|
||||
* File: permutations_i.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：順列 I */
|
||||
void backtrack(
|
||||
List<int> state,
|
||||
List<int> choices,
|
||||
List<bool> selected,
|
||||
List<List<int>> res,
|
||||
) {
|
||||
// 状態の長さが要素数に等しければ、解を記録
|
||||
if (state.length == choices.length) {
|
||||
res.add(List.from(state));
|
||||
return;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
for (int i = 0; i < choices.length; i++) {
|
||||
int choice = choices[i];
|
||||
// 枝刈り：要素の重複選択を許可しない
|
||||
if (!selected[i]) {
|
||||
// 試行: 選択を行い、状態を更新
|
||||
selected[i] = true;
|
||||
state.add(choice);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, choices, selected, res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
selected[i] = false;
|
||||
state.removeLast();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 全順列 I */
|
||||
List<List<int>> permutationsI(List<int> nums) {
|
||||
List<List<int>> res = [];
|
||||
backtrack([], nums, List.filled(nums.length, false), res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> nums = [1, 2, 3];
|
||||
|
||||
List<List<int>> res = permutationsI(nums);
|
||||
|
||||
print("入力配列 nums = $nums");
|
||||
print("すべての順列 res = $res");
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
/**
|
||||
* File: permutations_ii.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：順列 II */
|
||||
void backtrack(
|
||||
List<int> state,
|
||||
List<int> choices,
|
||||
List<bool> selected,
|
||||
List<List<int>> res,
|
||||
) {
|
||||
// 状態の長さが要素数に等しければ、解を記録
|
||||
if (state.length == choices.length) {
|
||||
res.add(List.from(state));
|
||||
return;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
Set<int> duplicated = {};
|
||||
for (int i = 0; i < choices.length; i++) {
|
||||
int choice = choices[i];
|
||||
// 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない
|
||||
if (!selected[i] && !duplicated.contains(choice)) {
|
||||
// 試行: 選択を行い、状態を更新
|
||||
duplicated.add(choice); // 選択済みの要素値を記録
|
||||
selected[i] = true;
|
||||
state.add(choice);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, choices, selected, res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
selected[i] = false;
|
||||
state.removeLast();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 全順列 II */
|
||||
List<List<int>> permutationsII(List<int> nums) {
|
||||
List<List<int>> res = [];
|
||||
backtrack([], nums, List.filled(nums.length, false), res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> nums = [1, 2, 2];
|
||||
|
||||
List<List<int>> res = permutationsII(nums);
|
||||
|
||||
print("入力配列 nums = $nums");
|
||||
print("すべての順列 res = $res");
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
/**
|
||||
* File: preorder_traversal_i_compact.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
/* 前順走査：例題 1 */
|
||||
void preOrder(TreeNode? root, List<TreeNode> res) {
|
||||
if (root == null) {
|
||||
return;
|
||||
}
|
||||
if (root.val == 7) {
|
||||
// 解を記録
|
||||
res.add(root);
|
||||
}
|
||||
preOrder(root.left, res);
|
||||
preOrder(root.right, res);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
|
||||
print("\n二分木を初期化");
|
||||
printTree(root);
|
||||
|
||||
// 先行順走査
|
||||
List<TreeNode> res = [];
|
||||
preOrder(root, res);
|
||||
|
||||
print("\n値が 7 のノードをすべて出力");
|
||||
print(List.generate(res.length, (i) => res[i].val));
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
/**
|
||||
* File: preorder_traversal_ii_compact.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
/* 前順走査：例題 2 */
|
||||
void preOrder(
|
||||
TreeNode? root,
|
||||
List<TreeNode> path,
|
||||
List<List<TreeNode>> res,
|
||||
) {
|
||||
if (root == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
// 試す
|
||||
path.add(root);
|
||||
if (root.val == 7) {
|
||||
// 解を記録
|
||||
res.add(List.from(path));
|
||||
}
|
||||
preOrder(root.left, path, res);
|
||||
preOrder(root.right, path, res);
|
||||
// バックトラック
|
||||
path.removeLast();
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
|
||||
print("\n二分木を初期化");
|
||||
printTree(root);
|
||||
|
||||
// 先行順走査
|
||||
List<TreeNode> path = [];
|
||||
List<List<TreeNode>> res = [];
|
||||
preOrder(root, path, res);
|
||||
|
||||
print("\nルートノードからノード 7 までのすべての経路を出力");
|
||||
for (List<TreeNode> vals in res) {
|
||||
print(List.generate(vals.length, (i) => vals[i].val));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
/**
|
||||
* File: preorder_traversal_iii_compact.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
/* 前順走査：例題 3 */
|
||||
void preOrder(
|
||||
TreeNode? root,
|
||||
List<TreeNode> path,
|
||||
List<List<TreeNode>> res,
|
||||
) {
|
||||
if (root == null || root.val == 3) {
|
||||
return;
|
||||
}
|
||||
|
||||
// 試す
|
||||
path.add(root);
|
||||
if (root.val == 7) {
|
||||
// 解を記録
|
||||
res.add(List.from(path));
|
||||
}
|
||||
preOrder(root.left, path, res);
|
||||
preOrder(root.right, path, res);
|
||||
// バックトラック
|
||||
path.removeLast();
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
|
||||
print("\n二分木を初期化");
|
||||
printTree(root);
|
||||
|
||||
// 先行順走査
|
||||
List<TreeNode> path = [];
|
||||
List<List<TreeNode>> res = [];
|
||||
preOrder(root, path, res);
|
||||
|
||||
print("\nルートノードからノード 7 までのすべての経路を出力");
|
||||
for (List<TreeNode> vals in res) {
|
||||
print(List.generate(vals.length, (i) => vals[i].val));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
/**
|
||||
* File: preorder_traversal_iii_template.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
/* 現在の状態が解かどうかを判定 */
|
||||
bool isSolution(List<TreeNode> state) {
|
||||
return state.isNotEmpty && state.last.val == 7;
|
||||
}
|
||||
|
||||
/* 解を記録 */
|
||||
void recordSolution(List<TreeNode> state, List<List<TreeNode>> res) {
|
||||
res.add(List.from(state));
|
||||
}
|
||||
|
||||
/* 現在の状態で、この選択が有効かどうかを判定 */
|
||||
bool isValid(List<TreeNode> state, TreeNode? choice) {
|
||||
return choice != null && choice.val != 3;
|
||||
}
|
||||
|
||||
/* 状態を更新 */
|
||||
void makeChoice(List<TreeNode> state, TreeNode? choice) {
|
||||
state.add(choice!);
|
||||
}
|
||||
|
||||
/* 状態を元に戻す */
|
||||
void undoChoice(List<TreeNode> state, TreeNode? choice) {
|
||||
state.removeLast();
|
||||
}
|
||||
|
||||
/* バックトラッキング：例題 3 */
|
||||
void backtrack(
|
||||
List<TreeNode> state,
|
||||
List<TreeNode?> choices,
|
||||
List<List<TreeNode>> res,
|
||||
) {
|
||||
// 解かどうかを確認
|
||||
if (isSolution(state)) {
|
||||
// 解を記録
|
||||
recordSolution(state, res);
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
for (TreeNode? choice in choices) {
|
||||
// 枝刈り：選択が妥当かを確認する
|
||||
if (isValid(state, choice)) {
|
||||
// 試行: 選択を行い、状態を更新
|
||||
makeChoice(state, choice);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, [choice!.left, choice.right], res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
undoChoice(state, choice);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
TreeNode? root = listToTree([1, 7, 3, 4, 5, 6, 7]);
|
||||
print("\n二分木を初期化");
|
||||
printTree(root);
|
||||
|
||||
// バックトラッキング法
|
||||
List<List<TreeNode>> res = [];
|
||||
backtrack([], [root!], res);
|
||||
print("\nルートノードからノード 7 までのすべての経路を出力し、経路には値が 3 のノードを含まない");
|
||||
for (List<TreeNode> path in res) {
|
||||
print(List.from(path.map((e) => e.val)));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
/**
|
||||
* File: subset_sum_i.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：部分和 I */
|
||||
void backtrack(
|
||||
List<int> state,
|
||||
int target,
|
||||
List<int> choices,
|
||||
int start,
|
||||
List<List<int>> res,
|
||||
) {
|
||||
// 部分集合の和が target に等しければ、解を記録
|
||||
if (target == 0) {
|
||||
res.add(List.from(state));
|
||||
return;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
|
||||
for (int i = start; i < choices.length; i++) {
|
||||
// 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
|
||||
// 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
|
||||
if (target - choices[i] < 0) {
|
||||
break;
|
||||
}
|
||||
// 試す：選択を行い、target と start を更新
|
||||
state.add(choices[i]);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, target - choices[i], choices, i, res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
state.removeLast();
|
||||
}
|
||||
}
|
||||
|
||||
/* 部分和 I を解く */
|
||||
List<List<int>> subsetSumI(List<int> nums, int target) {
|
||||
List<int> state = []; // 状態（部分集合）
|
||||
nums.sort(); // nums をソート
|
||||
int start = 0; // 開始点を走査
|
||||
List<List<int>> res = []; // 結果リスト（部分集合のリスト）
|
||||
backtrack(state, target, nums, start, res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> nums = [3, 4, 5];
|
||||
int target = 9;
|
||||
|
||||
List<List<int>> res = subsetSumI(nums, target);
|
||||
|
||||
print("入力配列 nums = $nums, target = $target");
|
||||
print("和が $target に等しいすべての部分集合 res = $res");
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
/**
|
||||
* File: subset_sum_i_naive.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：部分和 I */
|
||||
void backtrack(
|
||||
List<int> state,
|
||||
int target,
|
||||
int total,
|
||||
List<int> choices,
|
||||
List<List<int>> res,
|
||||
) {
|
||||
// 部分集合の和が target に等しければ、解を記録
|
||||
if (total == target) {
|
||||
res.add(List.from(state));
|
||||
return;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
for (int i = 0; i < choices.length; i++) {
|
||||
// 枝刈り：部分和が target を超える場合はその選択をスキップする
|
||||
if (total + choices[i] > target) {
|
||||
continue;
|
||||
}
|
||||
// 試行：選択を行い、要素と total を更新する
|
||||
state.add(choices[i]);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, target, total + choices[i], choices, res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
state.removeLast();
|
||||
}
|
||||
}
|
||||
|
||||
/* 部分和 I を解く（重複部分集合を含む） */
|
||||
List<List<int>> subsetSumINaive(List<int> nums, int target) {
|
||||
List<int> state = []; // 状態（部分集合）
|
||||
int total = 0; // 要素の合計
|
||||
List<List<int>> res = []; // 結果リスト（部分集合のリスト）
|
||||
backtrack(state, target, total, nums, res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> nums = [3, 4, 5];
|
||||
int target = 9;
|
||||
|
||||
List<List<int>> res = subsetSumINaive(nums, target);
|
||||
|
||||
print("入力配列 nums = $nums, target = $target");
|
||||
print("和が $target に等しいすべての部分集合 res = $res");
|
||||
print("この方法が出力する結果には重複する集合が含まれることに注意してください");
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
/**
|
||||
* File: subset_sum_ii.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング：部分和 II */
|
||||
void backtrack(
|
||||
List<int> state,
|
||||
int target,
|
||||
List<int> choices,
|
||||
int start,
|
||||
List<List<int>> res,
|
||||
) {
|
||||
// 部分集合の和が target に等しければ、解を記録
|
||||
if (target == 0) {
|
||||
res.add(List.from(state));
|
||||
return;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
|
||||
// 枝刈り 3: start から走査し、同じ要素の重複選択を避ける
|
||||
for (int 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.add(choices[i]);
|
||||
// 次の選択へ進む
|
||||
backtrack(state, target - choices[i], choices, i + 1, res);
|
||||
// バックトラック：選択を取り消し、前の状態に戻す
|
||||
state.removeLast();
|
||||
}
|
||||
}
|
||||
|
||||
/* 部分和 II を解く */
|
||||
List<List<int>> subsetSumII(List<int> nums, int target) {
|
||||
List<int> state = []; // 状態（部分集合）
|
||||
nums.sort(); // nums をソート
|
||||
int start = 0; // 開始点を走査
|
||||
List<List<int>> res = []; // 結果リスト（部分集合のリスト）
|
||||
backtrack(state, target, nums, start, res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> nums = [4, 4, 5];
|
||||
int target = 9;
|
||||
|
||||
List<List<int>> res = subsetSumII(nums, target);
|
||||
|
||||
print("入力配列 nums = $nums, target = $target");
|
||||
print("和が $target に等しいすべての部分集合 res = $res");
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
/**
|
||||
* File: iteration.dart
|
||||
* Created Time: 2023-08-27
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* for ループ */
|
||||
int forLoop(int n) {
|
||||
int res = 0;
|
||||
// 1, 2, ..., n-1, n を順に加算する
|
||||
for (int i = 1; i <= n; i++) {
|
||||
res += i;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* while ループ */
|
||||
int whileLoop(int n) {
|
||||
int res = 0;
|
||||
int i = 1; // 条件変数を初期化する
|
||||
// 1, 2, ..., n-1, n を順に加算する
|
||||
while (i <= n) {
|
||||
res += i;
|
||||
i++; // 条件変数を更新する
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* while ループ（2回更新） */
|
||||
int whileLoopII(int n) {
|
||||
int res = 0;
|
||||
int i = 1; // 条件変数を初期化する
|
||||
// 1, 4, 10, ... を順に加算する
|
||||
while (i <= n) {
|
||||
res += i;
|
||||
// 条件変数を更新する
|
||||
i++;
|
||||
i *= 2;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 二重 for ループ */
|
||||
String nestedForLoop(int n) {
|
||||
String res = "";
|
||||
// i = 1, 2, ..., n-1, n とループする
|
||||
for (int i = 1; i <= n; i++) {
|
||||
// j = 1, 2, ..., n-1, n とループする
|
||||
for (int j = 1; j <= n; j++) {
|
||||
res += "($i, $j), ";
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int n = 5;
|
||||
int res;
|
||||
|
||||
res = forLoop(n);
|
||||
print("\nfor ループの合計結果 res = $res");
|
||||
|
||||
res = whileLoop(n);
|
||||
print("\nwhile ループの合計結果 res = $res");
|
||||
|
||||
res = whileLoopII(n);
|
||||
print("\nwhile ループ（2 回更新）の合計結果 res = $res");
|
||||
|
||||
String resStr = nestedForLoop(n);
|
||||
print("\n二重 for ループの結果 $resStr");
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
/**
|
||||
* File: recursion.dart
|
||||
* Created Time: 2023-08-27
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 再帰 */
|
||||
int recur(int n) {
|
||||
// 終了条件
|
||||
if (n == 1) return 1;
|
||||
// 再帰：再帰呼び出し
|
||||
int res = recur(n - 1);
|
||||
// 帰りがけ：結果を返す
|
||||
return n + res;
|
||||
}
|
||||
|
||||
/* 反復で再帰を模擬する */
|
||||
int forLoopRecur(int n) {
|
||||
// 明示的なスタックを使ってシステムコールスタックを模擬する
|
||||
List<int> stack = [];
|
||||
int res = 0;
|
||||
// 再帰：再帰呼び出し
|
||||
for (int i = n; i > 0; i--) {
|
||||
// 「スタックへのプッシュ」で「再帰」を模擬する
|
||||
stack.add(i);
|
||||
}
|
||||
// 帰りがけ：結果を返す
|
||||
while (!stack.isEmpty) {
|
||||
// 「スタックから取り出す操作」で「帰り」をシミュレート
|
||||
res += stack.removeLast();
|
||||
}
|
||||
// res = 1+2+3+...+n
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 末尾再帰 */
|
||||
int tailRecur(int n, int res) {
|
||||
// 終了条件
|
||||
if (n == 0) return res;
|
||||
// 末尾再帰呼び出し
|
||||
return tailRecur(n - 1, res + n);
|
||||
}
|
||||
|
||||
/* フィボナッチ数列：再帰 */
|
||||
int fib(int n) {
|
||||
// 終了条件 f(1) = 0, f(2) = 1
|
||||
if (n == 1 || n == 2) return n - 1;
|
||||
// f(n) = f(n-1) + f(n-2) を再帰的に呼び出す
|
||||
int res = fib(n - 1) + fib(n - 2);
|
||||
// 結果 f(n) を返す
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int n = 5;
|
||||
int res;
|
||||
|
||||
res = recur(n);
|
||||
print("\n再帰関数の合計結果 res = $res");
|
||||
|
||||
res = tailRecur(n, 0);
|
||||
print("\n末尾再帰関数の合計結果 res = $res");
|
||||
|
||||
res = forLoopRecur(n);
|
||||
print("\n反復で再帰をシミュレートした合計結果 res = $res");
|
||||
|
||||
res = fib(n);
|
||||
print("\nフィボナッチ数列の第 $n 項は $res");
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
/**
|
||||
* File: space_complexity.dart
|
||||
* Created Time: 2023-2-12
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
// ignore_for_file: unused_local_variable
|
||||
|
||||
import 'dart:collection';
|
||||
import '../utils/list_node.dart';
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
/* 関数 */
|
||||
int function() {
|
||||
// 何らかの処理を行う
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* 定数階 */
|
||||
void constant(int n) {
|
||||
// 定数、変数、オブジェクトは O(1) の空間を占める
|
||||
final int a = 0;
|
||||
int b = 0;
|
||||
List<int> nums = List.filled(10000, 0);
|
||||
ListNode node = ListNode(0);
|
||||
// ループ内の変数は O(1) の空間を占める
|
||||
for (var i = 0; i < n; i++) {
|
||||
int c = 0;
|
||||
}
|
||||
// ループ内の関数は O(1) の空間を占める
|
||||
for (var i = 0; i < n; i++) {
|
||||
function();
|
||||
}
|
||||
}
|
||||
|
||||
/* 線形階 */
|
||||
void linear(int n) {
|
||||
// 長さ n の配列は O(n) の空間を使用
|
||||
List<int> nums = List.filled(n, 0);
|
||||
// 長さ n のリストは O(n) の空間を使用
|
||||
List<ListNode> nodes = [];
|
||||
for (var i = 0; i < n; i++) {
|
||||
nodes.add(ListNode(i));
|
||||
}
|
||||
// 長さ n のハッシュテーブルは O(n) の空間を使用
|
||||
Map<int, String> map = HashMap();
|
||||
for (var i = 0; i < n; i++) {
|
||||
map.putIfAbsent(i, () => i.toString());
|
||||
}
|
||||
}
|
||||
|
||||
/* 線形時間（再帰実装） */
|
||||
void linearRecur(int n) {
|
||||
print('再帰 n = $n');
|
||||
if (n == 1) return;
|
||||
linearRecur(n - 1);
|
||||
}
|
||||
|
||||
/* 二乗階 */
|
||||
void quadratic(int n) {
|
||||
// 行列は O(n^2) の空間を使用する
|
||||
List<List<int>> numMatrix = List.generate(n, (_) => List.filled(n, 0));
|
||||
// 二次元リストは O(n^2) の空間を使用
|
||||
List<List<int>> numList = [];
|
||||
for (var i = 0; i < n; i++) {
|
||||
List<int> tmp = [];
|
||||
for (int j = 0; j < n; j++) {
|
||||
tmp.add(0);
|
||||
}
|
||||
numList.add(tmp);
|
||||
}
|
||||
}
|
||||
|
||||
/* 二次時間（再帰実装） */
|
||||
int quadraticRecur(int n) {
|
||||
if (n <= 0) return 0;
|
||||
List<int> nums = List.filled(n, 0);
|
||||
print('再帰 n = $n における nums の長さ = ${nums.length}');
|
||||
return quadraticRecur(n - 1);
|
||||
}
|
||||
|
||||
/* 指数時間（完全二分木の構築） */
|
||||
TreeNode? buildTree(int n) {
|
||||
if (n == 0) return null;
|
||||
TreeNode root = TreeNode(0);
|
||||
root.left = buildTree(n - 1);
|
||||
root.right = buildTree(n - 1);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int n = 5;
|
||||
// 定数階
|
||||
constant(n);
|
||||
// 線形階
|
||||
linear(n);
|
||||
linearRecur(n);
|
||||
// 二乗階
|
||||
quadratic(n);
|
||||
quadraticRecur(n);
|
||||
// 指数オーダー
|
||||
TreeNode? root = buildTree(n);
|
||||
printTree(root);
|
||||
}
|
||||
@@ -0,0 +1,165 @@
|
||||
/**
|
||||
* File: time_complexity.dart
|
||||
* Created Time: 2023-02-12
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
// ignore_for_file: unused_local_variable
|
||||
|
||||
/* 定数階 */
|
||||
int constant(int n) {
|
||||
int count = 0;
|
||||
int size = 100000;
|
||||
for (var i = 0; i < size; i++) {
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 線形階 */
|
||||
int linear(int n) {
|
||||
int count = 0;
|
||||
for (var i = 0; i < n; i++) {
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 線形時間（配列を走査） */
|
||||
int arrayTraversal(List<int> nums) {
|
||||
int count = 0;
|
||||
// ループ回数は配列長に比例する
|
||||
for (var _num in nums) {
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 二乗階 */
|
||||
int quadratic(int n) {
|
||||
int count = 0;
|
||||
// ループ回数はデータサイズ n の二乗に比例する
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
count++;
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 二次時間（バブルソート） */
|
||||
int bubbleSort(List<int> nums) {
|
||||
int count = 0; // カウンタ
|
||||
// 外側のループ：未ソート区間は [0, i]
|
||||
for (var i = nums.length - 1; i > 0; i--) {
|
||||
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
|
||||
for (var j = 0; j < i; j++) {
|
||||
if (nums[j] > nums[j + 1]) {
|
||||
// nums[j] と nums[j + 1] を交換
|
||||
int tmp = nums[j];
|
||||
nums[j] = nums[j + 1];
|
||||
nums[j + 1] = tmp;
|
||||
count += 3; // 要素交換には 3 回の単位操作が含まれる
|
||||
}
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 指数時間（ループ実装） */
|
||||
int exponential(int n) {
|
||||
int count = 0, base = 1;
|
||||
// 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する
|
||||
for (var i = 0; i < n; i++) {
|
||||
for (var j = 0; j < base; j++) {
|
||||
count++;
|
||||
}
|
||||
base *= 2;
|
||||
}
|
||||
// count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 指数時間（再帰実装） */
|
||||
int expRecur(int n) {
|
||||
if (n == 1) return 1;
|
||||
return expRecur(n - 1) + expRecur(n - 1) + 1;
|
||||
}
|
||||
|
||||
/* 対数時間（ループ実装） */
|
||||
int logarithmic(int n) {
|
||||
int count = 0;
|
||||
while (n > 1) {
|
||||
n = n ~/ 2;
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 対数時間（再帰実装） */
|
||||
int logRecur(int n) {
|
||||
if (n <= 1) return 0;
|
||||
return logRecur(n ~/ 2) + 1;
|
||||
}
|
||||
|
||||
/* 線形対数時間 */
|
||||
int linearLogRecur(int n) {
|
||||
if (n <= 1) return 1;
|
||||
int count = linearLogRecur(n ~/ 2) + linearLogRecur(n ~/ 2);
|
||||
for (var i = 0; i < n; i++) {
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 階乗時間（再帰実装） */
|
||||
int factorialRecur(int n) {
|
||||
if (n == 0) return 1;
|
||||
int count = 0;
|
||||
// 1個から n 個に分裂
|
||||
for (var i = 0; i < n; i++) {
|
||||
count += factorialRecur(n - 1);
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
// n を変えて実行し、各計算量で操作回数がどう変化するかを確認できる
|
||||
int n = 8;
|
||||
print('入力データサイズ n = $n');
|
||||
|
||||
int count = constant(n);
|
||||
print('定数時間の操作回数 = $count');
|
||||
|
||||
count = linear(n);
|
||||
print('線形時間の操作回数 = $count');
|
||||
|
||||
count = arrayTraversal(List.filled(n, 0));
|
||||
print('線形時間（配列走査）の操作回数 = $count');
|
||||
|
||||
count = quadratic(n);
|
||||
print('二次時間の操作回数 = $count');
|
||||
final nums = List.filled(n, 0);
|
||||
for (int i = 0; i < n; i++) {
|
||||
nums[i] = n - i; // [n,n-1,...,2,1]
|
||||
}
|
||||
count = bubbleSort(nums);
|
||||
print('二次時間（バブルソート）の操作回数 = $count');
|
||||
|
||||
count = exponential(n);
|
||||
print('指数時間（ループ実装）の操作回数 = $count');
|
||||
count = expRecur(n);
|
||||
print('指数時間（再帰実装）の操作回数 = $count');
|
||||
|
||||
count = logarithmic(n);
|
||||
print('対数時間（ループ実装）の操作回数 = $count');
|
||||
count = logRecur(n);
|
||||
print('対数時間（再帰実装）の操作回数 = $count');
|
||||
|
||||
count = linearLogRecur(n);
|
||||
print('線形対数時間（再帰実装）の操作回数 = $count');
|
||||
|
||||
count = factorialRecur(n);
|
||||
print('階乗時間（再帰実装）の操作回数 = $count');
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
/**
|
||||
* File: worst_best_time_complexity.dart
|
||||
* Created Time: 2023-02-12
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */
|
||||
List<int> randomNumbers(int n) {
|
||||
final nums = List.filled(n, 0);
|
||||
// 配列 nums = { 1, 2, 3, ..., n } を生成
|
||||
for (var i = 0; i < n; i++) {
|
||||
nums[i] = i + 1;
|
||||
}
|
||||
// 配列要素をランダムにシャッフル
|
||||
nums.shuffle();
|
||||
|
||||
return nums;
|
||||
}
|
||||
|
||||
/* 配列 nums 内で数値 1 のインデックスを探す */
|
||||
int findOne(List<int> nums) {
|
||||
for (var i = 0; i < nums.length; i++) {
|
||||
// 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる
|
||||
// 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる
|
||||
if (nums[i] == 1) return i;
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
for (var i = 0; i < 10; i++) {
|
||||
int n = 100;
|
||||
final nums = randomNumbers(n);
|
||||
int index = findOne(nums);
|
||||
print('\n配列 [ 1, 2, ..., n ] をシャッフルした後 = $nums');
|
||||
print('数字 1 のインデックスは + $index');
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
/**
|
||||
* File: binary_search_recur.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 二分探索：問題 f(i, j) */
|
||||
int dfs(List<int> nums, int target, int i, int j) {
|
||||
// 区間が空なら対象要素は存在しないので -1 を返す
|
||||
if (i > j) {
|
||||
return -1;
|
||||
}
|
||||
// 中点インデックス m を計算
|
||||
int m = (i + j) ~/ 2;
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
||||
/* 二分探索 */
|
||||
int binarySearch(List<int> nums, int target) {
|
||||
int n = nums.length;
|
||||
// 問題 f(0, n-1) を解く
|
||||
return dfs(nums, target, 0, n - 1);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int target = 6;
|
||||
List<int> nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
|
||||
|
||||
// 二分探索（両閉区間）
|
||||
int index = binarySearch(nums, target);
|
||||
print("目標要素 6 のインデックス = $index");
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
/**
|
||||
* File: build_tree.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
/* 二分木を構築：分割統治 */
|
||||
TreeNode? dfs(
|
||||
List<int> preorder,
|
||||
Map<int, int> inorderMap,
|
||||
int i,
|
||||
int l,
|
||||
int r,
|
||||
) {
|
||||
// 部分木区間が空なら終了する
|
||||
if (r - l < 0) {
|
||||
return null;
|
||||
}
|
||||
// ルートノードを初期化する
|
||||
TreeNode? root = TreeNode(preorder[i]);
|
||||
// m を求めて左右部分木を分割する
|
||||
int m = inorderMap[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;
|
||||
}
|
||||
|
||||
/* 二分木を構築 */
|
||||
TreeNode? buildTree(List<int> preorder, List<int> inorder) {
|
||||
// inorder の要素からインデックスへの対応を格納するハッシュテーブルを初期化する
|
||||
Map<int, int> inorderMap = {};
|
||||
for (int i = 0; i < inorder.length; i++) {
|
||||
inorderMap[inorder[i]] = i;
|
||||
}
|
||||
TreeNode? root = dfs(preorder, inorderMap, 0, 0, inorder.length - 1);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> preorder = [3, 9, 2, 1, 7];
|
||||
List<int> inorder = [9, 3, 1, 2, 7];
|
||||
print("前順走査 = $preorder");
|
||||
print("中順走査 = $inorder");
|
||||
|
||||
TreeNode? root = buildTree(preorder, inorder);
|
||||
print("構築した二分木は：");
|
||||
printTree(root!);
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
/**
|
||||
* File: hanota.dart
|
||||
* Created Time: 2023-08-10
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 円盤を 1 枚移動 */
|
||||
void move(List<int> src, List<int> tar) {
|
||||
// src の上から円盤を1枚取り出す
|
||||
int pan = src.removeLast();
|
||||
// 円盤を tar の上に置く
|
||||
tar.add(pan);
|
||||
}
|
||||
|
||||
/* ハノイの塔の問題 f(i) を解く */
|
||||
void dfs(int i, List<int> src, List<int> buf, List<int> tar) {
|
||||
// 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);
|
||||
}
|
||||
|
||||
/* ハノイの塔を解く */
|
||||
void solveHanota(List<int> A, List<int> B, List<int> C) {
|
||||
int n = A.length;
|
||||
// A の上から n 枚の円盤を B を介して C へ移す
|
||||
dfs(n, A, B, C);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
// リスト末尾が柱の頂上
|
||||
List<int> A = [5, 4, 3, 2, 1];
|
||||
List<int> B = [];
|
||||
List<int> C = [];
|
||||
print("初期状態：");
|
||||
print("A = $A");
|
||||
print("B = $B");
|
||||
print("C = $C");
|
||||
|
||||
solveHanota(A, B, C);
|
||||
|
||||
print("円盤の移動完了後：");
|
||||
print("A = $A");
|
||||
print("B = $B");
|
||||
print("C = $C");
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
/**
|
||||
* File: climbing_stairs_backtrack.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* バックトラッキング */
|
||||
void backtrack(List<int> choices, int state, int n, List<int> res) {
|
||||
// 第 n 段に到達したら、方法数を 1 増やす
|
||||
if (state == n) {
|
||||
res[0]++;
|
||||
}
|
||||
// すべての選択肢を走査
|
||||
for (int choice in choices) {
|
||||
// 枝刈り: 第 n 段を超えないようにする
|
||||
if (state + choice > n) continue;
|
||||
// 試行: 選択を行い、状態を更新
|
||||
backtrack(choices, state + choice, n, res);
|
||||
// バックトラック
|
||||
}
|
||||
}
|
||||
|
||||
/* 階段登り：バックトラッキング */
|
||||
int climbingStairsBacktrack(int n) {
|
||||
List<int> choices = [1, 2]; // 1 段または 2 段上ることを選べる
|
||||
int state = 0; // 第 0 段から上り始める
|
||||
List<int> res = [];
|
||||
res.add(0); // res[0] を使って方法数を記録する
|
||||
backtrack(choices, state, n, res);
|
||||
return res[0];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int n = 9;
|
||||
|
||||
int res = climbingStairsBacktrack(n);
|
||||
print("$n 段の階段の登り方は全部で $res 通り");
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* File: climbing_stairs_constraint_dp.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 制約付き階段登り：動的計画法 */
|
||||
int climbingStairsConstraintDP(int n) {
|
||||
if (n == 1 || n == 2) {
|
||||
return 1;
|
||||
}
|
||||
// 部分問題の解を保存するために dp テーブルを初期化
|
||||
List<List<int>> dp = List.generate(n + 1, (index) => List.filled(3, 0));
|
||||
// 初期状態：最小部分問題の解をあらかじめ設定
|
||||
dp[1][1] = 1;
|
||||
dp[1][2] = 0;
|
||||
dp[2][1] = 0;
|
||||
dp[2][2] = 1;
|
||||
// 状態遷移：小さい部分問題から大きい部分問題へ順に解く
|
||||
for (int 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 */
|
||||
void main() {
|
||||
int n = 9;
|
||||
|
||||
int res = climbingStairsConstraintDP(n);
|
||||
print("$n 段の階段の登り方は全部で $res 通り");
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
/**
|
||||
* File: climbing_stairs_dfs.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 検索 */
|
||||
int dfs(int i) {
|
||||
// dp[1] と dp[2] は既知なので返す
|
||||
if (i == 1 || i == 2) return i;
|
||||
// dp[i] = dp[i-1] + dp[i-2]
|
||||
int count = dfs(i - 1) + dfs(i - 2);
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 階段登り：探索 */
|
||||
int climbingStairsDFS(int n) {
|
||||
return dfs(n);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int n = 9;
|
||||
|
||||
int res = climbingStairsDFS(n);
|
||||
print("$n 段の階段の登り方は全部で $res 通り");
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* File: climbing_stairs_dfs_mem.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* メモ化探索 */
|
||||
int dfs(int i, List<int> mem) {
|
||||
// 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]
|
||||
int count = dfs(i - 1, mem) + dfs(i - 2, mem);
|
||||
// dp[i] を記録する
|
||||
mem[i] = count;
|
||||
return count;
|
||||
}
|
||||
|
||||
/* 階段登り：メモ化探索 */
|
||||
int climbingStairsDFSMem(int n) {
|
||||
// mem[i] は第 i 段まで上る方法の総数を記録し、-1 は未記録を表す
|
||||
List<int> mem = List.filled(n + 1, -1);
|
||||
return dfs(n, mem);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int n = 9;
|
||||
|
||||
int res = climbingStairsDFSMem(n);
|
||||
print("$n 段の階段の登り方は全部で $res 通り");
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
/**
|
||||
* File: climbing_stairs_dp.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 階段登り：動的計画法 */
|
||||
int climbingStairsDP(int n) {
|
||||
if (n == 1 || n == 2) return n;
|
||||
// 部分問題の解を保存するために dp テーブルを初期化
|
||||
List<int> dp = List.filled(n + 1, 0);
|
||||
// 初期状態：最小部分問題の解をあらかじめ設定
|
||||
dp[1] = 1;
|
||||
dp[2] = 2;
|
||||
// 状態遷移：小さい部分問題から大きい部分問題へ順に解く
|
||||
for (int i = 3; i <= n; i++) {
|
||||
dp[i] = dp[i - 1] + dp[i - 2];
|
||||
}
|
||||
return dp[n];
|
||||
}
|
||||
|
||||
/* 階段登り：空間最適化した動的計画法 */
|
||||
int climbingStairsDPComp(int n) {
|
||||
if (n == 1 || n == 2) return n;
|
||||
int a = 1, b = 2;
|
||||
for (int i = 3; i <= n; i++) {
|
||||
int tmp = b;
|
||||
b = a + b;
|
||||
a = tmp;
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int n = 9;
|
||||
|
||||
int res = climbingStairsDP(n);
|
||||
print("$n 段の階段の登り方は全部で $res 通り");
|
||||
|
||||
res = climbingStairsDPComp(n);
|
||||
print("$n 段の階段の登り方は全部で $res 通り");
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
/**
|
||||
* File: coin_change.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:math';
|
||||
|
||||
/* コイン両替：動的計画法 */
|
||||
int coinChangeDP(List<int> coins, int amt) {
|
||||
int n = coins.length;
|
||||
int MAX = amt + 1;
|
||||
// dp テーブルを初期化
|
||||
List<List<int>> dp = List.generate(n + 1, (index) => List.filled(amt + 1, 0));
|
||||
// 状態遷移：先頭行と先頭列
|
||||
for (int a = 1; a <= amt; a++) {
|
||||
dp[0][a] = MAX;
|
||||
}
|
||||
// 状態遷移: 残りの行と列
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int a = 1; a <= amt; a++) {
|
||||
if (coins[i - 1] > a) {
|
||||
// 目標金額を超えるなら硬貨 i は選ばない
|
||||
dp[i][a] = dp[i - 1][a];
|
||||
} else {
|
||||
// 硬貨 i を選ばない場合と選ぶ場合の小さい方
|
||||
dp[i][a] = min(dp[i - 1][a], dp[i][a - coins[i - 1]] + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[n][amt] != MAX ? dp[n][amt] : -1;
|
||||
}
|
||||
|
||||
/* コイン交換：空間最適化後の動的計画法 */
|
||||
int coinChangeDPComp(List<int> coins, int amt) {
|
||||
int n = coins.length;
|
||||
int MAX = amt + 1;
|
||||
// dp テーブルを初期化
|
||||
List<int> dp = List.filled(amt + 1, MAX);
|
||||
dp[0] = 0;
|
||||
// 状態遷移
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int a = 1; a <= amt; a++) {
|
||||
if (coins[i - 1] > a) {
|
||||
// 目標金額を超えるなら硬貨 i は選ばない
|
||||
dp[a] = dp[a];
|
||||
} else {
|
||||
// 硬貨 i を選ばない場合と選ぶ場合の小さい方
|
||||
dp[a] = min(dp[a], dp[a - coins[i - 1]] + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[amt] != MAX ? dp[amt] : -1;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> coins = [1, 2, 5];
|
||||
int amt = 4;
|
||||
|
||||
// 動的計画法
|
||||
int res = coinChangeDP(coins, amt);
|
||||
print("目標金額を作るのに必要な最小硬貨枚数は $res");
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
res = coinChangeDPComp(coins, amt);
|
||||
print("目標金額を作るのに必要な最小硬貨枚数は $res");
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
/**
|
||||
* File: coin_change_ii.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* コイン両替 II：動的計画法 */
|
||||
int coinChangeIIDP(List<int> coins, int amt) {
|
||||
int n = coins.length;
|
||||
// dp テーブルを初期化
|
||||
List<List<int>> dp = List.generate(n + 1, (index) => List.filled(amt + 1, 0));
|
||||
// 先頭列を初期化する
|
||||
for (int i = 0; i <= n; i++) {
|
||||
dp[i][0] = 1;
|
||||
}
|
||||
// 状態遷移
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int 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：空間最適化した動的計画法 */
|
||||
int coinChangeIIDPComp(List<int> coins, int amt) {
|
||||
int n = coins.length;
|
||||
// dp テーブルを初期化
|
||||
List<int> dp = List.filled(amt + 1, 0);
|
||||
dp[0] = 1;
|
||||
// 状態遷移
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int 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 */
|
||||
void main() {
|
||||
List<int> coins = [1, 2, 5];
|
||||
int amt = 5;
|
||||
|
||||
// 動的計画法
|
||||
int res = coinChangeIIDP(coins, amt);
|
||||
print("目標金額を作る硬貨の組み合わせ数は $res");
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
res = coinChangeIIDPComp(coins, amt);
|
||||
print("目標金額を作る硬貨の組み合わせ数は $res");
|
||||
}
|
||||
@@ -0,0 +1,125 @@
|
||||
/**
|
||||
* File: edit_distance.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:math';
|
||||
|
||||
/* 編集距離：総当たり探索 */
|
||||
int editDistanceDFS(String s, String t, int i, int j) {
|
||||
// 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[i - 1] == t[j - 1]) return editDistanceDFS(s, t, i - 1, j - 1);
|
||||
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
|
||||
int insert = editDistanceDFS(s, t, i, j - 1);
|
||||
int delete = editDistanceDFS(s, t, i - 1, j);
|
||||
int replace = editDistanceDFS(s, t, i - 1, j - 1);
|
||||
// 最小編集回数を返す
|
||||
return min(min(insert, delete), replace) + 1;
|
||||
}
|
||||
|
||||
/* 編集距離：メモ化探索 */
|
||||
int editDistanceDFSMem(String s, String t, List<List<int>> mem, int i, int j) {
|
||||
// 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[i - 1] == t[j - 1]) return editDistanceDFSMem(s, t, mem, i - 1, j - 1);
|
||||
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
|
||||
int insert = editDistanceDFSMem(s, t, mem, i, j - 1);
|
||||
int delete = editDistanceDFSMem(s, t, mem, i - 1, j);
|
||||
int replace = editDistanceDFSMem(s, t, mem, i - 1, j - 1);
|
||||
// 最小編集回数を記録して返す
|
||||
mem[i][j] = min(min(insert, delete), replace) + 1;
|
||||
return mem[i][j];
|
||||
}
|
||||
|
||||
/* 編集距離：動的計画法 */
|
||||
int editDistanceDP(String s, String t) {
|
||||
int n = s.length, m = t.length;
|
||||
List<List<int>> dp = List.generate(n + 1, (_) => List.filled(m + 1, 0));
|
||||
// 状態遷移：先頭行と先頭列
|
||||
for (int i = 1; i <= n; i++) {
|
||||
dp[i][0] = i;
|
||||
}
|
||||
for (int j = 1; j <= m; j++) {
|
||||
dp[0][j] = j;
|
||||
}
|
||||
// 状態遷移: 残りの行と列
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int j = 1; j <= m; j++) {
|
||||
if (s[i - 1] == t[j - 1]) {
|
||||
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
|
||||
dp[i][j] = dp[i - 1][j - 1];
|
||||
} else {
|
||||
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
|
||||
dp[i][j] = min(min(dp[i][j - 1], dp[i - 1][j]), dp[i - 1][j - 1]) + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[n][m];
|
||||
}
|
||||
|
||||
/* 編集距離：空間最適化した動的計画法 */
|
||||
int editDistanceDPComp(String s, String t) {
|
||||
int n = s.length, m = t.length;
|
||||
List<int> dp = List.filled(m + 1, 0);
|
||||
// 状態遷移：先頭行
|
||||
for (int j = 1; j <= m; j++) {
|
||||
dp[j] = j;
|
||||
}
|
||||
// 状態遷移：残りの行
|
||||
for (int i = 1; i <= n; i++) {
|
||||
// 状態遷移：先頭列
|
||||
int leftup = dp[0]; // dp[i-1, j-1] を一時保存する
|
||||
dp[0] = i;
|
||||
// 状態遷移：残りの列
|
||||
for (int j = 1; j <= m; j++) {
|
||||
int temp = dp[j];
|
||||
if (s[i - 1] == t[j - 1]) {
|
||||
// 2 つの文字が等しければ、その 2 文字をそのままスキップする
|
||||
dp[j] = leftup;
|
||||
} else {
|
||||
// 最小編集回数 = 挿入・削除・置換の 3 操作における最小編集回数 + 1
|
||||
dp[j] = min(min(dp[j - 1], dp[j]), leftup) + 1;
|
||||
}
|
||||
leftup = temp; // 次の反復の dp[i-1, j-1] に更新する
|
||||
}
|
||||
}
|
||||
return dp[m];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
String s = "bag";
|
||||
String t = "pack";
|
||||
int n = s.length, m = t.length;
|
||||
|
||||
// 全探索
|
||||
int res = editDistanceDFS(s, t, n, m);
|
||||
print("" + s + " を " + t + " に変更するには最小で $res 回の編集が必要");
|
||||
|
||||
// メモ化探索
|
||||
List<List<int>> mem = List.generate(n + 1, (_) => List.filled(m + 1, -1));
|
||||
res = editDistanceDFSMem(s, t, mem, n, m);
|
||||
print("" + s + " を " + t + " に変更するには最小で $res 回の編集が必要");
|
||||
|
||||
// 動的計画法
|
||||
res = editDistanceDP(s, t);
|
||||
print("" + s + " を " + t + " に変更するには最小で $res 回の編集が必要");
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
res = editDistanceDPComp(s, t);
|
||||
print("" + s + " を " + t + " に変更するには最小で $res 回の編集が必要");
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
/**
|
||||
* File: knapsack.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:math';
|
||||
|
||||
/* 0-1 ナップサック：総当たり探索 */
|
||||
int knapsackDFS(List<int> wgt, List<int> val, int i, int c) {
|
||||
// すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 0 を返す
|
||||
if (i == 0 || c == 0) {
|
||||
return 0;
|
||||
}
|
||||
// ナップサック容量を超える場合は、入れない選択しかできない
|
||||
if (wgt[i - 1] > c) {
|
||||
return knapsackDFS(wgt, val, i - 1, c);
|
||||
}
|
||||
// 品物 i を入れない場合と入れる場合の最大価値を計算する
|
||||
int no = knapsackDFS(wgt, val, i - 1, c);
|
||||
int yes = knapsackDFS(wgt, val, i - 1, c - wgt[i - 1]) + val[i - 1];
|
||||
// 2つの案のうち価値が大きいほうを返す
|
||||
return max(no, yes);
|
||||
}
|
||||
|
||||
/* 0-1 ナップサック：メモ化探索 */
|
||||
int knapsackDFSMem(
|
||||
List<int> wgt,
|
||||
List<int> val,
|
||||
List<List<int>> mem,
|
||||
int i,
|
||||
int c,
|
||||
) {
|
||||
// すべての品物を選び終えたか、ナップサックに残り容量がなければ、価値 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 を入れない場合と入れる場合の最大価値を計算する
|
||||
int no = knapsackDFSMem(wgt, val, mem, i - 1, c);
|
||||
int yes = knapsackDFSMem(wgt, val, mem, i - 1, c - wgt[i - 1]) + val[i - 1];
|
||||
// 2 つの案のうち価値が大きい方を記録して返す
|
||||
mem[i][c] = max(no, yes);
|
||||
return mem[i][c];
|
||||
}
|
||||
|
||||
/* 0-1 ナップサック：動的計画法 */
|
||||
int knapsackDP(List<int> wgt, List<int> val, int cap) {
|
||||
int n = wgt.length;
|
||||
// dp テーブルを初期化
|
||||
List<List<int>> dp = List.generate(n + 1, (index) => List.filled(cap + 1, 0));
|
||||
// 状態遷移
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int c = 1; c <= cap; c++) {
|
||||
if (wgt[i - 1] > c) {
|
||||
// ナップサック容量を超えるなら品物 i は選ばない
|
||||
dp[i][c] = dp[i - 1][c];
|
||||
} else {
|
||||
// 品物 i を選ばない場合と選ぶ場合の大きい方
|
||||
dp[i][c] = max(dp[i - 1][c], dp[i - 1][c - wgt[i - 1]] + val[i - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[n][cap];
|
||||
}
|
||||
|
||||
/* 0-1 ナップサック：空間最適化後の動的計画法 */
|
||||
int knapsackDPComp(List<int> wgt, List<int> val, int cap) {
|
||||
int n = wgt.length;
|
||||
// dp テーブルを初期化
|
||||
List<int> dp = List.filled(cap + 1, 0);
|
||||
// 状態遷移
|
||||
for (int i = 1; i <= n; i++) {
|
||||
// 逆順に走査する
|
||||
for (int c = cap; c >= 1; c--) {
|
||||
if (wgt[i - 1] <= c) {
|
||||
// 品物 i を選ばない場合と選ぶ場合の大きい方
|
||||
dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[cap];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> wgt = [10, 20, 30, 40, 50];
|
||||
List<int> val = [50, 120, 150, 210, 240];
|
||||
int cap = 50;
|
||||
int n = wgt.length;
|
||||
|
||||
// 全探索
|
||||
int res = knapsackDFS(wgt, val, n, cap);
|
||||
print("ナップサック容量を超えない最大価値は $res");
|
||||
|
||||
// メモ化探索
|
||||
List<List<int>> mem =
|
||||
List.generate(n + 1, (index) => List.filled(cap + 1, -1));
|
||||
res = knapsackDFSMem(wgt, val, mem, n, cap);
|
||||
print("ナップサック容量を超えない最大価値は $res");
|
||||
|
||||
// 動的計画法
|
||||
res = knapsackDP(wgt, val, cap);
|
||||
print("ナップサック容量を超えない最大価値は $res");
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
res = knapsackDPComp(wgt, val, cap);
|
||||
print("ナップサック容量を超えない最大価値は $res");
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
/**
|
||||
* File: min_cost_climbing_stairs_dp.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:math';
|
||||
|
||||
/* 階段登りの最小コスト：動的計画法 */
|
||||
int minCostClimbingStairsDP(List<int> cost) {
|
||||
int n = cost.length - 1;
|
||||
if (n == 1 || n == 2) return cost[n];
|
||||
// 部分問題の解を保存するために dp テーブルを初期化
|
||||
List<int> dp = List.filled(n + 1, 0);
|
||||
// 初期状態：最小部分問題の解をあらかじめ設定
|
||||
dp[1] = cost[1];
|
||||
dp[2] = cost[2];
|
||||
// 状態遷移：小さい部分問題から大きい部分問題へ順に解く
|
||||
for (int i = 3; i <= n; i++) {
|
||||
dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i];
|
||||
}
|
||||
return dp[n];
|
||||
}
|
||||
|
||||
/* 階段昇りの最小コスト：空間最適化後の動的計画法 */
|
||||
int minCostClimbingStairsDPComp(List<int> cost) {
|
||||
int n = cost.length - 1;
|
||||
if (n == 1 || n == 2) return cost[n];
|
||||
int a = cost[1], b = cost[2];
|
||||
for (int i = 3; i <= n; i++) {
|
||||
int tmp = b;
|
||||
b = min(a, tmp) + cost[i];
|
||||
a = tmp;
|
||||
}
|
||||
return b;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> cost = [0, 1, 10, 1, 1, 1, 10, 1, 1, 10, 1];
|
||||
print("入力された階段コストのリストは $cost");
|
||||
|
||||
int res = minCostClimbingStairsDP(cost);
|
||||
print("階段を登り切る最小コストは $res");
|
||||
|
||||
res = minCostClimbingStairsDPComp(cost);
|
||||
print("階段を登り切る最小コストは $res");
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
/**
|
||||
* File: min_path_sum.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:math';
|
||||
|
||||
/* 最小経路和：全探索 */
|
||||
int minPathSumDFS(List<List<int>> grid, int i, int j) {
|
||||
// 左上のセルなら探索を終了する
|
||||
if (i == 0 && j == 0) {
|
||||
return grid[0][0];
|
||||
}
|
||||
// 行または列のインデックスが範囲外なら、コスト +∞ を返す
|
||||
if (i < 0 || j < 0) {
|
||||
// Dart では、int 型は固定範囲の整数であり、「無限大」を表す値は存在しない
|
||||
return BigInt.from(2).pow(31).toInt();
|
||||
}
|
||||
// 左上から (i-1, j) および (i, j-1) までの最小経路コストを計算する
|
||||
int up = minPathSumDFS(grid, i - 1, j);
|
||||
int left = minPathSumDFS(grid, i, j - 1);
|
||||
// 左上隅から (i, j) までの最小経路コストを返す
|
||||
return min(left, up) + grid[i][j];
|
||||
}
|
||||
|
||||
/* 最小経路和：メモ化探索 */
|
||||
int minPathSumDFSMem(List<List<int>> grid, List<List<int>> mem, int i, int j) {
|
||||
// 左上のセルなら探索を終了する
|
||||
if (i == 0 && j == 0) {
|
||||
return grid[0][0];
|
||||
}
|
||||
// 行または列のインデックスが範囲外なら、コスト +∞ を返す
|
||||
if (i < 0 || j < 0) {
|
||||
// Dart では、int 型は固定範囲の整数であり、「無限大」を表す値は存在しない
|
||||
return BigInt.from(2).pow(31).toInt();
|
||||
}
|
||||
// 既に記録があればそのまま返す
|
||||
if (mem[i][j] != -1) {
|
||||
return mem[i][j];
|
||||
}
|
||||
// 左と上のセルからの最小経路コスト
|
||||
int up = minPathSumDFSMem(grid, mem, i - 1, j);
|
||||
int left = minPathSumDFSMem(grid, mem, i, j - 1);
|
||||
// 左上から (i, j) までの最小経路コストを記録して返す
|
||||
mem[i][j] = min(left, up) + grid[i][j];
|
||||
return mem[i][j];
|
||||
}
|
||||
|
||||
/* 最小経路和：動的計画法 */
|
||||
int minPathSumDP(List<List<int>> grid) {
|
||||
int n = grid.length, m = grid[0].length;
|
||||
// dp テーブルを初期化
|
||||
List<List<int>> dp = List.generate(n, (i) => List.filled(m, 0));
|
||||
dp[0][0] = grid[0][0];
|
||||
// 状態遷移：先頭行
|
||||
for (int j = 1; j < m; j++) {
|
||||
dp[0][j] = dp[0][j - 1] + grid[0][j];
|
||||
}
|
||||
// 状態遷移：先頭列
|
||||
for (int i = 1; i < n; i++) {
|
||||
dp[i][0] = dp[i - 1][0] + grid[i][0];
|
||||
}
|
||||
// 状態遷移: 残りの行と列
|
||||
for (int i = 1; i < n; i++) {
|
||||
for (int j = 1; j < m; j++) {
|
||||
dp[i][j] = min(dp[i][j - 1], dp[i - 1][j]) + grid[i][j];
|
||||
}
|
||||
}
|
||||
return dp[n - 1][m - 1];
|
||||
}
|
||||
|
||||
/* 最小経路和：空間最適化後の動的計画法 */
|
||||
int minPathSumDPComp(List<List<int>> grid) {
|
||||
int n = grid.length, m = grid[0].length;
|
||||
// dp テーブルを初期化
|
||||
List<int> dp = List.filled(m, 0);
|
||||
dp[0] = grid[0][0];
|
||||
for (int j = 1; j < m; j++) {
|
||||
dp[j] = dp[j - 1] + grid[0][j];
|
||||
}
|
||||
// 状態遷移：残りの行
|
||||
for (int i = 1; i < n; i++) {
|
||||
// 状態遷移：先頭列
|
||||
dp[0] = dp[0] + grid[i][0];
|
||||
// 状態遷移：残りの列
|
||||
for (int j = 1; j < m; j++) {
|
||||
dp[j] = min(dp[j - 1], dp[j]) + grid[i][j];
|
||||
}
|
||||
}
|
||||
return dp[m - 1];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<List<int>> grid = [
|
||||
[1, 3, 1, 5],
|
||||
[2, 2, 4, 2],
|
||||
[5, 3, 2, 1],
|
||||
[4, 3, 5, 2],
|
||||
];
|
||||
int n = grid.length, m = grid[0].length;
|
||||
|
||||
// 全探索
|
||||
int res = minPathSumDFS(grid, n - 1, m - 1);
|
||||
print("左上から右下までの最小経路和は $res");
|
||||
|
||||
// メモ化探索
|
||||
List<List<int>> mem = List.generate(n, (i) => List.filled(m, -1));
|
||||
res = minPathSumDFSMem(grid, mem, n - 1, m - 1);
|
||||
print("左上から右下までの最小経路和は $res");
|
||||
|
||||
// 動的計画法
|
||||
res = minPathSumDP(grid);
|
||||
print("左上から右下までの最小経路和は $res");
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
res = minPathSumDPComp(grid);
|
||||
print("左上から右下までの最小経路和は $res");
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
* File: unbounded_knapsack.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:math';
|
||||
|
||||
/* 完全ナップサック問題：動的計画法 */
|
||||
int unboundedKnapsackDP(List<int> wgt, List<int> val, int cap) {
|
||||
int n = wgt.length;
|
||||
// dp テーブルを初期化
|
||||
List<List<int>> dp = List.generate(n + 1, (index) => List.filled(cap + 1, 0));
|
||||
// 状態遷移
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int c = 1; c <= cap; c++) {
|
||||
if (wgt[i - 1] > c) {
|
||||
// ナップサック容量を超えるなら品物 i は選ばない
|
||||
dp[i][c] = dp[i - 1][c];
|
||||
} else {
|
||||
// 品物 i を選ばない場合と選ぶ場合の大きい方
|
||||
dp[i][c] = max(dp[i - 1][c], dp[i][c - wgt[i - 1]] + val[i - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[n][cap];
|
||||
}
|
||||
|
||||
/* 完全ナップサック問題：空間最適化後の動的計画法 */
|
||||
int unboundedKnapsackDPComp(List<int> wgt, List<int> val, int cap) {
|
||||
int n = wgt.length;
|
||||
// dp テーブルを初期化
|
||||
List<int> dp = List.filled(cap + 1, 0);
|
||||
// 状態遷移
|
||||
for (int i = 1; i <= n; i++) {
|
||||
for (int c = 1; c <= cap; c++) {
|
||||
if (wgt[i - 1] > c) {
|
||||
// ナップサック容量を超えるなら品物 i は選ばない
|
||||
dp[c] = dp[c];
|
||||
} else {
|
||||
// 品物 i を選ばない場合と選ぶ場合の大きい方
|
||||
dp[c] = max(dp[c], dp[c - wgt[i - 1]] + val[i - 1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return dp[cap];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> wgt = [1, 2, 3];
|
||||
List<int> val = [5, 11, 15];
|
||||
int cap = 4;
|
||||
|
||||
// 動的計画法
|
||||
int res = unboundedKnapsackDP(wgt, val, cap);
|
||||
print("ナップサック容量を超えない最大価値は $res");
|
||||
|
||||
// 空間最適化後の動的計画法
|
||||
int resComp = unboundedKnapsackDPComp(wgt, val, cap);
|
||||
print("ナップサック容量を超えない最大価値は $resComp");
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
/**
|
||||
* File: graph_adjacency_list.dart
|
||||
* Created Time: 2023-05-15
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/vertex.dart';
|
||||
|
||||
/* 隣接リストに基づく無向グラフクラス */
|
||||
class GraphAdjList {
|
||||
// 隣接リスト。key は頂点、value はその頂点に隣接する全頂点
|
||||
Map<Vertex, List<Vertex>> adjList = {};
|
||||
|
||||
/* コンストラクタ */
|
||||
GraphAdjList(List<List<Vertex>> edges) {
|
||||
for (List<Vertex> edge in edges) {
|
||||
addVertex(edge[0]);
|
||||
addVertex(edge[1]);
|
||||
addEdge(edge[0], edge[1]);
|
||||
}
|
||||
}
|
||||
|
||||
/* 頂点数を取得 */
|
||||
int size() {
|
||||
return adjList.length;
|
||||
}
|
||||
|
||||
/* 辺を追加 */
|
||||
void addEdge(Vertex vet1, Vertex vet2) {
|
||||
if (!adjList.containsKey(vet1) ||
|
||||
!adjList.containsKey(vet2) ||
|
||||
vet1 == vet2) {
|
||||
throw ArgumentError;
|
||||
}
|
||||
// 辺 vet1 - vet2 を追加
|
||||
adjList[vet1]!.add(vet2);
|
||||
adjList[vet2]!.add(vet1);
|
||||
}
|
||||
|
||||
/* 辺を削除 */
|
||||
void removeEdge(Vertex vet1, Vertex vet2) {
|
||||
if (!adjList.containsKey(vet1) ||
|
||||
!adjList.containsKey(vet2) ||
|
||||
vet1 == vet2) {
|
||||
throw ArgumentError;
|
||||
}
|
||||
// 辺 vet1 - vet2 を削除
|
||||
adjList[vet1]!.remove(vet2);
|
||||
adjList[vet2]!.remove(vet1);
|
||||
}
|
||||
|
||||
/* 頂点を追加 */
|
||||
void addVertex(Vertex vet) {
|
||||
if (adjList.containsKey(vet)) return;
|
||||
// 隣接リストに新しいリストを追加
|
||||
adjList[vet] = [];
|
||||
}
|
||||
|
||||
/* 頂点を削除 */
|
||||
void removeVertex(Vertex vet) {
|
||||
if (!adjList.containsKey(vet)) {
|
||||
throw ArgumentError;
|
||||
}
|
||||
// 隣接リストから頂点 vet に対応するリストを削除
|
||||
adjList.remove(vet);
|
||||
// 他の頂点のリストを走査し、vet を含むすべての辺を削除
|
||||
adjList.forEach((key, value) {
|
||||
value.remove(vet);
|
||||
});
|
||||
}
|
||||
|
||||
/* 隣接リストを出力 */
|
||||
void printAdjList() {
|
||||
print("隣接リスト =");
|
||||
adjList.forEach((key, value) {
|
||||
List<int> tmp = [];
|
||||
for (Vertex vertex in value) {
|
||||
tmp.add(vertex.val);
|
||||
}
|
||||
print("${key.val}: $tmp,");
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* 無向グラフを初期化 */
|
||||
List<Vertex> v = Vertex.valsToVets([1, 3, 2, 5, 4]);
|
||||
List<List<Vertex>> edges = [
|
||||
[v[0], v[1]],
|
||||
[v[0], v[3]],
|
||||
[v[1], v[2]],
|
||||
[v[2], v[3]],
|
||||
[v[2], v[4]],
|
||||
[v[3], v[4]],
|
||||
];
|
||||
GraphAdjList graph = GraphAdjList(edges);
|
||||
print("\n初期化後、グラフは");
|
||||
graph.printAdjList();
|
||||
|
||||
/* 辺を追加 */
|
||||
// 頂点 1, 2 は v[0], v[2]
|
||||
graph.addEdge(v[0], v[2]);
|
||||
print("\n辺 1-2 を追加後、グラフは");
|
||||
graph.printAdjList();
|
||||
|
||||
/* 辺を削除 */
|
||||
// 頂点 1, 3 は v[0], v[1]
|
||||
graph.removeEdge(v[0], v[1]);
|
||||
print("\n辺 1-3 を削除後、グラフは");
|
||||
graph.printAdjList();
|
||||
|
||||
/* 頂点を追加 */
|
||||
Vertex v5 = Vertex(6);
|
||||
graph.addVertex(v5);
|
||||
print("\n頂点 6 を追加後、グラフは");
|
||||
graph.printAdjList();
|
||||
|
||||
/* 頂点を削除 */
|
||||
// 頂点 3 は v[1]
|
||||
graph.removeVertex(v[1]);
|
||||
print("\n頂点 3 を削除後、グラフは");
|
||||
graph.printAdjList();
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
/**
|
||||
* File: graph_adjacency_matrix.dart
|
||||
* Created Time: 2023-05-15
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
|
||||
/* 隣接行列に基づく無向グラフクラス */
|
||||
class GraphAdjMat {
|
||||
List<int> vertices = []; // 頂点要素。要素は「頂点値」を表し、インデックスは「頂点インデックス」を表す
|
||||
List<List<int>> adjMat = []; // 隣接行列。行・列のインデックスは「頂点インデックス」に対応
|
||||
|
||||
/* コンストラクタ */
|
||||
GraphAdjMat(List<int> vertices, List<List<int>> edges) {
|
||||
this.vertices = [];
|
||||
this.adjMat = [];
|
||||
// 頂点を追加
|
||||
for (int val in vertices) {
|
||||
addVertex(val);
|
||||
}
|
||||
// 辺を追加
|
||||
// 注意：edges の各要素は頂点インデックスを表し、vertices の要素インデックスに対応する
|
||||
for (List<int> e in edges) {
|
||||
addEdge(e[0], e[1]);
|
||||
}
|
||||
}
|
||||
|
||||
/* 頂点数を取得 */
|
||||
int size() {
|
||||
return vertices.length;
|
||||
}
|
||||
|
||||
/* 頂点を追加 */
|
||||
void addVertex(int val) {
|
||||
int n = size();
|
||||
// 頂点リストに新しい頂点の値を追加
|
||||
vertices.add(val);
|
||||
// 隣接行列に 1 行追加
|
||||
List<int> newRow = List.filled(n, 0, growable: true);
|
||||
adjMat.add(newRow);
|
||||
// 隣接行列に 1 列追加
|
||||
for (List<int> row in adjMat) {
|
||||
row.add(0);
|
||||
}
|
||||
}
|
||||
|
||||
/* 頂点を削除 */
|
||||
void removeVertex(int index) {
|
||||
if (index >= size()) {
|
||||
throw IndexError;
|
||||
}
|
||||
// 頂点リストから index の頂点を削除する
|
||||
vertices.removeAt(index);
|
||||
// 隣接行列で index 行を削除する
|
||||
adjMat.removeAt(index);
|
||||
// 隣接行列で index 列を削除する
|
||||
for (List<int> row in adjMat) {
|
||||
row.removeAt(index);
|
||||
}
|
||||
}
|
||||
|
||||
/* 辺を追加 */
|
||||
// 引数 i, j は vertices の要素インデックスに対応する
|
||||
void addEdge(int i, int j) {
|
||||
// インデックスの範囲外と等値の処理
|
||||
if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
|
||||
throw IndexError;
|
||||
}
|
||||
// 無向グラフでは、隣接行列は主対角線に関して対称、すなわち (i, j) == (j, i) を満たす
|
||||
adjMat[i][j] = 1;
|
||||
adjMat[j][i] = 1;
|
||||
}
|
||||
|
||||
/* 辺を削除 */
|
||||
// 引数 i, j は vertices の要素インデックスに対応する
|
||||
void removeEdge(int i, int j) {
|
||||
// インデックスの範囲外と等値の処理
|
||||
if (i < 0 || j < 0 || i >= size() || j >= size() || i == j) {
|
||||
throw IndexError;
|
||||
}
|
||||
adjMat[i][j] = 0;
|
||||
adjMat[j][i] = 0;
|
||||
}
|
||||
|
||||
/* 隣接行列を出力 */
|
||||
void printAdjMat() {
|
||||
print("頂点リスト = $vertices");
|
||||
print("隣接行列 = ");
|
||||
printMatrix(adjMat);
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* 無向グラフを初期化 */
|
||||
// edges の要素は頂点インデックス、すなわち vertices の要素インデックスに対応する点に注意
|
||||
List<int> vertices = [1, 3, 2, 5, 4];
|
||||
List<List<int>> edges = [
|
||||
[0, 1],
|
||||
[0, 3],
|
||||
[1, 2],
|
||||
[2, 3],
|
||||
[2, 4],
|
||||
[3, 4],
|
||||
];
|
||||
GraphAdjMat graph = GraphAdjMat(vertices, edges);
|
||||
print("\n初期化後、グラフは");
|
||||
graph.printAdjMat();
|
||||
|
||||
/* 辺を追加 */
|
||||
// 頂点 1, 2 のインデックスはそれぞれ 0, 2
|
||||
graph.addEdge(0, 2);
|
||||
print("\n辺 1-2 を追加後、グラフは");
|
||||
graph.printAdjMat();
|
||||
|
||||
/* 辺を削除 */
|
||||
// 頂点 1, 3 のインデックスはそれぞれ 0, 1
|
||||
graph.removeEdge(0, 1);
|
||||
print("\n辺 1-3 を削除後、グラフは");
|
||||
graph.printAdjMat();
|
||||
|
||||
/* 頂点を追加 */
|
||||
graph.addVertex(6);
|
||||
print("\n頂点 6 を追加後、グラフは");
|
||||
graph.printAdjMat();
|
||||
|
||||
/* 頂点を削除 */
|
||||
// 頂点 3 のインデックスは 1
|
||||
graph.removeVertex(1);
|
||||
print("\n頂点 3 を削除後、グラフは");
|
||||
graph.printAdjMat();
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
/**
|
||||
* File: graph_bfs.dart
|
||||
* Created Time: 2023-05-15
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:collection';
|
||||
|
||||
import '../utils/vertex.dart';
|
||||
import 'graph_adjacency_list.dart';
|
||||
|
||||
/* 幅優先探索 */
|
||||
List<Vertex> graphBFS(GraphAdjList graph, Vertex startVet) {
|
||||
// 指定した頂点の隣接頂点をすべて取得できるよう、隣接リストでグラフを表現する
|
||||
// 頂点の走査順序
|
||||
List<Vertex> res = [];
|
||||
// 訪問済み頂点を記録するためのハッシュ集合
|
||||
Set<Vertex> visited = {};
|
||||
visited.add(startVet);
|
||||
// BFS の実装にキューを用いる
|
||||
Queue<Vertex> que = Queue();
|
||||
que.add(startVet);
|
||||
// 頂点 vet を起点に、すべての頂点を訪問し終えるまで繰り返す
|
||||
while (que.isNotEmpty) {
|
||||
Vertex vet = que.removeFirst(); // 先頭の頂点をデキュー
|
||||
res.add(vet); // 訪問した頂点を記録
|
||||
// この頂点のすべての隣接頂点を走査
|
||||
for (Vertex adjVet in graph.adjList[vet]!) {
|
||||
if (visited.contains(adjVet)) {
|
||||
continue; // 訪問済みの頂点をスキップ
|
||||
}
|
||||
que.add(adjVet); // 未訪問の頂点のみをキューに追加
|
||||
visited.add(adjVet); // この頂点を訪問済みにする
|
||||
}
|
||||
}
|
||||
// 頂点の走査順を返す
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Dirver Code */
|
||||
void main() {
|
||||
/* 無向グラフを初期化 */
|
||||
List<Vertex> v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
|
||||
List<List<Vertex>> 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]],
|
||||
];
|
||||
GraphAdjList graph = GraphAdjList(edges);
|
||||
print("\n初期化後、グラフは");
|
||||
graph.printAdjList();
|
||||
|
||||
/* 幅優先探索 */
|
||||
List<Vertex> res = graphBFS(graph, v[0]);
|
||||
print("\n幅優先探索（BFS）頂点列");
|
||||
print(Vertex.vetsToVals(res));
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
/**
|
||||
* File: graph_dfs.dart
|
||||
* Created Time: 2023-05-15
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/vertex.dart';
|
||||
import 'graph_adjacency_list.dart';
|
||||
|
||||
/* 深さ優先走査の補助関数 */
|
||||
void dfs(
|
||||
GraphAdjList graph,
|
||||
Set<Vertex> visited,
|
||||
List<Vertex> res,
|
||||
Vertex vet,
|
||||
) {
|
||||
res.add(vet); // 訪問した頂点を記録
|
||||
visited.add(vet); // この頂点を訪問済みにする
|
||||
// この頂点のすべての隣接頂点を走査
|
||||
for (Vertex adjVet in graph.adjList[vet]!) {
|
||||
if (visited.contains(adjVet)) {
|
||||
continue; // 訪問済みの頂点をスキップ
|
||||
}
|
||||
// 隣接頂点を再帰的に訪問
|
||||
dfs(graph, visited, res, adjVet);
|
||||
}
|
||||
}
|
||||
|
||||
/* 深さ優先探索 */
|
||||
List<Vertex> graphDFS(GraphAdjList graph, Vertex startVet) {
|
||||
// 頂点の走査順序
|
||||
List<Vertex> res = [];
|
||||
// 訪問済み頂点を記録するためのハッシュ集合
|
||||
Set<Vertex> visited = {};
|
||||
dfs(graph, visited, res, startVet);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* 無向グラフを初期化 */
|
||||
List<Vertex> v = Vertex.valsToVets([0, 1, 2, 3, 4, 5, 6]);
|
||||
List<List<Vertex>> 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]],
|
||||
];
|
||||
GraphAdjList graph = GraphAdjList(edges);
|
||||
print("\n初期化後、グラフは");
|
||||
graph.printAdjList();
|
||||
|
||||
/* 深さ優先探索 */
|
||||
List<Vertex> res = graphDFS(graph, v[0]);
|
||||
print("\n深さ優先探索（DFS）頂点列");
|
||||
print(Vertex.vetsToVals(res));
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* File: coin_change_greedy.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* コイン交換：貪欲法 */
|
||||
int coinChangeGreedy(List<int> coins, int amt) {
|
||||
// coins リストはソート済みと仮定する
|
||||
int i = coins.length - 1;
|
||||
int 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 */
|
||||
void main() {
|
||||
// 貪欲法：大域最適解を保証できる
|
||||
List<int> coins = [1, 5, 10, 20, 50, 100];
|
||||
int amt = 186;
|
||||
int res = coinChangeGreedy(coins, amt);
|
||||
print("\ncoins = $coins, amt = $amt");
|
||||
print("$amt を作るのに必要な最小硬貨枚数は $res");
|
||||
|
||||
// 貪欲法：大域最適解を保証できない
|
||||
coins = [1, 20, 50];
|
||||
amt = 60;
|
||||
res = coinChangeGreedy(coins, amt);
|
||||
print("\ncoins = $coins, amt = $amt");
|
||||
print("$amt を作るのに必要な最小硬貨枚数は $res");
|
||||
print("実際に必要な最小枚数は 3 、つまり 20 + 20 + 20");
|
||||
|
||||
// 貪欲法：大域最適解を保証できない
|
||||
coins = [1, 49, 50];
|
||||
amt = 98;
|
||||
res = coinChangeGreedy(coins, amt);
|
||||
print("\ncoins = $coins, amt = $amt");
|
||||
print("$amt を作るのに必要な最小硬貨枚数は $res");
|
||||
print("実際に必要な最小枚数は 2 、つまり 49 + 49");
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
/**
|
||||
* File: fractional_knapsack.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 品物 */
|
||||
class Item {
|
||||
int w; // 品物の重さ
|
||||
int v; // 品物の価値
|
||||
|
||||
Item(this.w, this.v);
|
||||
}
|
||||
|
||||
/* 分数ナップサック：貪欲法 */
|
||||
double fractionalKnapsack(List<int> wgt, List<int> val, int cap) {
|
||||
// 重さと価値の 2 属性を持つ品物リストを作成
|
||||
List<Item> items = List.generate(wgt.length, (i) => Item(wgt[i], val[i]));
|
||||
// 単位価値 item.v / item.w の高い順にソートする
|
||||
items.sort((a, b) => (b.v / b.w).compareTo(a.v / a.w));
|
||||
// 貪欲選択を繰り返す
|
||||
double res = 0;
|
||||
for (Item item in items) {
|
||||
if (item.w <= cap) {
|
||||
// 残り容量が十分なら、現在の品物を丸ごとナップサックに入れる
|
||||
res += item.v;
|
||||
cap -= item.w;
|
||||
} else {
|
||||
// 残り容量が足りない場合は、現在の品物の一部だけをナップサックに入れる
|
||||
res += item.v / item.w * cap;
|
||||
// 残り容量がないため、ループを抜ける
|
||||
break;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> wgt = [10, 20, 30, 40, 50];
|
||||
List<int> val = [50, 120, 150, 210, 240];
|
||||
int cap = 50;
|
||||
|
||||
// 貪欲法
|
||||
double res = fractionalKnapsack(wgt, val, cap);
|
||||
print("ナップサック容量を超えない最大価値は $res");
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* File: max_capacity.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:math';
|
||||
|
||||
/* 最大容量：貪欲法 */
|
||||
int maxCapacity(List<int> ht) {
|
||||
// i, j を初期化し、それぞれ配列の両端に置く
|
||||
int i = 0, j = ht.length - 1;
|
||||
// 初期の最大容量は 0
|
||||
int res = 0;
|
||||
// 2 枚の板が出会うまで貪欲選択を繰り返す
|
||||
while (i < j) {
|
||||
// 最大容量を更新する
|
||||
int cap = min(ht[i], ht[j]) * (j - i);
|
||||
res = max(res, cap);
|
||||
// 短い方を内側へ動かす
|
||||
if (ht[i] < ht[j]) {
|
||||
i++;
|
||||
} else {
|
||||
j--;
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> ht = [3, 8, 5, 2, 7, 7, 3, 4];
|
||||
|
||||
// 貪欲法
|
||||
int res = maxCapacity(ht);
|
||||
print("最大容量は $res");
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* File: max_product_cutting.dart
|
||||
* Created Time: 2023-08-11
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:math';
|
||||
|
||||
/* 最大切断積：貪欲法 */
|
||||
int maxProductCutting(int n) {
|
||||
// n <= 3 のときは、必ず 1 を切り出す
|
||||
if (n <= 3) {
|
||||
return 1 * (n - 1);
|
||||
}
|
||||
// 貪欲に 3 を切り出し、a を 3 の個数、b を余りとする
|
||||
int a = n ~/ 3;
|
||||
int b = n % 3;
|
||||
if (b == 1) {
|
||||
// 余りが 1 のときは、1 * 3 を 2 * 2 に変える
|
||||
return (pow(3, a - 1) * 2 * 2).toInt();
|
||||
}
|
||||
if (b == 2) {
|
||||
// 余りが 2 のときは、そのままにする
|
||||
return (pow(3, a) * 2).toInt();
|
||||
}
|
||||
// 余りが 0 のときは、そのままにする
|
||||
return pow(3, a).toInt();
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int n = 58;
|
||||
|
||||
// 貪欲法
|
||||
int res = maxProductCutting(n);
|
||||
print("最大分割積は $res");
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
/**
|
||||
* File: array_hash_map.dart
|
||||
* Created Time: 2023-03-29
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* キーと値の組 */
|
||||
class Pair {
|
||||
int key;
|
||||
String val;
|
||||
Pair(this.key, this.val);
|
||||
}
|
||||
|
||||
/* 配列ベースのハッシュテーブル */
|
||||
class ArrayHashMap {
|
||||
late List<Pair?> _buckets;
|
||||
|
||||
ArrayHashMap() {
|
||||
// 100 個のバケットを含む配列を初期化
|
||||
_buckets = List.filled(100, null);
|
||||
}
|
||||
|
||||
/* ハッシュ関数 */
|
||||
int _hashFunc(int key) {
|
||||
final int index = key % 100;
|
||||
return index;
|
||||
}
|
||||
|
||||
/* 検索操作 */
|
||||
String? get(int key) {
|
||||
final int index = _hashFunc(key);
|
||||
final Pair? pair = _buckets[index];
|
||||
if (pair == null) {
|
||||
return null;
|
||||
}
|
||||
return pair.val;
|
||||
}
|
||||
|
||||
/* 追加操作 */
|
||||
void put(int key, String val) {
|
||||
final Pair pair = Pair(key, val);
|
||||
final int index = _hashFunc(key);
|
||||
_buckets[index] = pair;
|
||||
}
|
||||
|
||||
/* 削除操作 */
|
||||
void remove(int key) {
|
||||
final int index = _hashFunc(key);
|
||||
_buckets[index] = null;
|
||||
}
|
||||
|
||||
/* すべてのキーと値のペアを取得 */
|
||||
List<Pair> pairSet() {
|
||||
List<Pair> pairSet = [];
|
||||
for (final Pair? pair in _buckets) {
|
||||
if (pair != null) {
|
||||
pairSet.add(pair);
|
||||
}
|
||||
}
|
||||
return pairSet;
|
||||
}
|
||||
|
||||
/* すべてのキーを取得 */
|
||||
List<int> keySet() {
|
||||
List<int> keySet = [];
|
||||
for (final Pair? pair in _buckets) {
|
||||
if (pair != null) {
|
||||
keySet.add(pair.key);
|
||||
}
|
||||
}
|
||||
return keySet;
|
||||
}
|
||||
|
||||
/* すべての値を取得 */
|
||||
List<String> values() {
|
||||
List<String> valueSet = [];
|
||||
for (final Pair? pair in _buckets) {
|
||||
if (pair != null) {
|
||||
valueSet.add(pair.val);
|
||||
}
|
||||
}
|
||||
return valueSet;
|
||||
}
|
||||
|
||||
/* ハッシュテーブルを出力 */
|
||||
void printHashMap() {
|
||||
for (final Pair kv in pairSet()) {
|
||||
print("${kv.key} -> ${kv.val}");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* ハッシュテーブルを初期化 */
|
||||
final ArrayHashMap map = ArrayHashMap();
|
||||
|
||||
/* 追加操作 */
|
||||
// ハッシュテーブルにキーと値のペア (key, value) を追加
|
||||
map.put(12836, "シャオハー");
|
||||
map.put(15937, "シャオルオ");
|
||||
map.put(16750, "シャオスワン");
|
||||
map.put(13276, "シャオファー");
|
||||
map.put(10583, "シャオヤー");
|
||||
print("\n追加完了後、ハッシュテーブルは\nKey -> Value");
|
||||
map.printHashMap();
|
||||
|
||||
/* 検索操作 */
|
||||
// キー key をハッシュテーブルに渡し、値 value を取得
|
||||
String? name = map.get(15937);
|
||||
print("\n学籍番号 15937 を入力すると、名前 $name が見つかりました");
|
||||
|
||||
/* 削除操作 */
|
||||
// ハッシュテーブルからキーと値のペア (key, value) を削除
|
||||
map.remove(10583);
|
||||
print("\n10583 を削除後、ハッシュテーブルは\nKey -> Value");
|
||||
map.printHashMap();
|
||||
|
||||
/* ハッシュテーブルを走査 */
|
||||
print("\nキーと値のペア Key->Value を走査");
|
||||
map.pairSet().forEach((kv) => print("${kv.key} -> ${kv.val}"));
|
||||
print("\nキー Key のみを走査");
|
||||
map.keySet().forEach((key) => print("$key"));
|
||||
print("\n値 Value のみを走査");
|
||||
map.values().forEach((val) => print("$val"));
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
/**
|
||||
* File: built_in_hash.dart
|
||||
* Created Time: 2023-06-25
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../chapter_stack_and_queue/linkedlist_deque.dart';
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int _num = 3;
|
||||
int hashNum = _num.hashCode;
|
||||
print("整数 $_num のハッシュ値は $hashNum");
|
||||
|
||||
bool bol = true;
|
||||
int hashBol = bol.hashCode;
|
||||
print("真偽値 $bol のハッシュ値は $hashBol");
|
||||
|
||||
double dec = 3.14159;
|
||||
int hashDec = dec.hashCode;
|
||||
print("小数 $dec のハッシュ値は $hashDec です");
|
||||
|
||||
String str = "Hello アルゴリズム";
|
||||
int hashStr = str.hashCode;
|
||||
print("文字列 $str のハッシュ値は $hashStr です");
|
||||
|
||||
List arr = [12836, "シャオハー"];
|
||||
int hashArr = arr.hashCode;
|
||||
print("配列 $arr のハッシュ値は $hashArr です");
|
||||
|
||||
ListNode obj = new ListNode(0);
|
||||
int hashObj = obj.hashCode;
|
||||
print("ノードオブジェクト $obj のハッシュ値は $hashObj です");
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
/**
|
||||
* File: hash_map.dart
|
||||
* Created Time: 2023-03-29
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* ハッシュテーブルを初期化 */
|
||||
final Map<int, String> map = {};
|
||||
|
||||
/* 追加操作 */
|
||||
// ハッシュテーブルにキーと値のペア (key, value) を追加
|
||||
map[12836] = "シャオハー";
|
||||
map[15937] = "シャオルオ";
|
||||
map[16750] = "シャオスワン";
|
||||
map[13276] = "シャオファー";
|
||||
map[10583] = "シャオヤー";
|
||||
print("\n追加完了後、ハッシュテーブルは\nKey -> Value");
|
||||
map.forEach((key, value) => print("$key -> $value"));
|
||||
|
||||
/* 検索操作 */
|
||||
// キー key をハッシュテーブルに渡し、値 value を取得
|
||||
final String? name = map[15937];
|
||||
print("\n学籍番号 15937 を入力すると、名前 $name が見つかりました");
|
||||
|
||||
/* 削除操作 */
|
||||
// ハッシュテーブルからキーと値のペア (key, value) を削除
|
||||
map.remove(10583);
|
||||
print("\n10583 を削除後、ハッシュテーブルは\nKey -> Value");
|
||||
map.forEach((key, value) => print("$key -> $value"));
|
||||
|
||||
/* ハッシュテーブルを走査 */
|
||||
print("\nキーと値のペア Key->Value を走査");
|
||||
map.forEach((key, value) => print("$key -> $value"));
|
||||
print("\nキー Key のみを走査");
|
||||
map.keys.forEach((key) => print(key));
|
||||
print("\n値 Value のみを走査");
|
||||
map.forEach((key, value) => print("$value"));
|
||||
map.values.forEach((value) => print(value));
|
||||
}
|
||||
@@ -0,0 +1,138 @@
|
||||
/**
|
||||
* File: hash_map_chaining.dart
|
||||
* Created Time: 2023-06-24
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'array_hash_map.dart';
|
||||
|
||||
/* チェイン法ハッシュテーブル */
|
||||
class HashMapChaining {
|
||||
late int size; // キーと値のペア数
|
||||
late int capacity; // ハッシュテーブル容量
|
||||
late double loadThres; // リサイズを発動する負荷率のしきい値
|
||||
late int extendRatio; // 拡張倍率
|
||||
late List<List<Pair>> buckets; // バケット配列
|
||||
|
||||
/* コンストラクタ */
|
||||
HashMapChaining() {
|
||||
size = 0;
|
||||
capacity = 4;
|
||||
loadThres = 2.0 / 3.0;
|
||||
extendRatio = 2;
|
||||
buckets = List.generate(capacity, (_) => []);
|
||||
}
|
||||
|
||||
/* ハッシュ関数 */
|
||||
int hashFunc(int key) {
|
||||
return key % capacity;
|
||||
}
|
||||
|
||||
/* 負荷率 */
|
||||
double loadFactor() {
|
||||
return size / capacity;
|
||||
}
|
||||
|
||||
/* 検索操作 */
|
||||
String? get(int key) {
|
||||
int index = hashFunc(key);
|
||||
List<Pair> bucket = buckets[index];
|
||||
// バケットを走査し、key が見つかれば対応する val を返す
|
||||
for (Pair pair in bucket) {
|
||||
if (pair.key == key) {
|
||||
return pair.val;
|
||||
}
|
||||
}
|
||||
// key が見つからない場合は null を返す
|
||||
return null;
|
||||
}
|
||||
|
||||
/* 追加操作 */
|
||||
void put(int key, String val) {
|
||||
// 負荷率がしきい値を超えたら、リサイズを実行
|
||||
if (loadFactor() > loadThres) {
|
||||
extend();
|
||||
}
|
||||
int index = hashFunc(key);
|
||||
List<Pair> bucket = buckets[index];
|
||||
// バケットを走査し、指定した key が見つかれば対応する val を更新して返す
|
||||
for (Pair pair in bucket) {
|
||||
if (pair.key == key) {
|
||||
pair.val = val;
|
||||
return;
|
||||
}
|
||||
}
|
||||
// その key が存在しなければ、キーと値のペアを末尾に追加
|
||||
Pair pair = Pair(key, val);
|
||||
bucket.add(pair);
|
||||
size++;
|
||||
}
|
||||
|
||||
/* 削除操作 */
|
||||
void remove(int key) {
|
||||
int index = hashFunc(key);
|
||||
List<Pair> bucket = buckets[index];
|
||||
// バケットを走査してキーと値のペアを削除
|
||||
for (Pair pair in bucket) {
|
||||
if (pair.key == key) {
|
||||
bucket.remove(pair);
|
||||
size--;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ハッシュテーブルを拡張 */
|
||||
void extend() {
|
||||
// 元のハッシュテーブルを一時保存
|
||||
List<List<Pair>> bucketsTmp = buckets;
|
||||
// リサイズ後の新しいハッシュテーブルを初期化
|
||||
capacity *= extendRatio;
|
||||
buckets = List.generate(capacity, (_) => []);
|
||||
size = 0;
|
||||
// キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す
|
||||
for (List<Pair> bucket in bucketsTmp) {
|
||||
for (Pair pair in bucket) {
|
||||
put(pair.key, pair.val);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ハッシュテーブルを出力 */
|
||||
void printHashMap() {
|
||||
for (List<Pair> bucket in buckets) {
|
||||
List<String> res = [];
|
||||
for (Pair pair in bucket) {
|
||||
res.add("${pair.key} -> ${pair.val}");
|
||||
}
|
||||
print(res);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* ハッシュテーブルを初期化 */
|
||||
HashMapChaining map = HashMapChaining();
|
||||
|
||||
/* 追加操作 */
|
||||
// ハッシュテーブルにキーと値のペア (key, value) を追加
|
||||
map.put(12836, "シャオハー");
|
||||
map.put(15937, "シャオルオ");
|
||||
map.put(16750, "シャオスワン");
|
||||
map.put(13276, "シャオファー");
|
||||
map.put(10583, "シャオヤー");
|
||||
print("\n追加完了後、ハッシュテーブルは\nKey -> Value");
|
||||
map.printHashMap();
|
||||
|
||||
/* 検索操作 */
|
||||
// キー key をハッシュテーブルに渡し、値 value を取得
|
||||
String? name = map.get(13276);
|
||||
print("\n学籍番号 13276 を入力すると、氏名 ${name} が見つかります");
|
||||
|
||||
/* 削除操作 */
|
||||
// ハッシュテーブルからキーと値のペア (key, value) を削除
|
||||
map.remove(12836);
|
||||
print("\n12836 を削除した後、ハッシュテーブルは\nKey -> Value");
|
||||
map.printHashMap();
|
||||
}
|
||||
@@ -0,0 +1,157 @@
|
||||
/**
|
||||
* File: hash_map_open_addressing.dart
|
||||
* Created Time: 2023-06-25
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'array_hash_map.dart';
|
||||
|
||||
/* オープンアドレス法ハッシュテーブル */
|
||||
class HashMapOpenAddressing {
|
||||
late int _size; // キーと値のペア数
|
||||
int _capacity = 4; // ハッシュテーブル容量
|
||||
double _loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値
|
||||
int _extendRatio = 2; // 拡張倍率
|
||||
late List<Pair?> _buckets; // バケット配列
|
||||
Pair _TOMBSTONE = Pair(-1, "-1"); // 削除済みマーク
|
||||
|
||||
/* コンストラクタ */
|
||||
HashMapOpenAddressing() {
|
||||
_size = 0;
|
||||
_buckets = List.generate(_capacity, (index) => null);
|
||||
}
|
||||
|
||||
/* ハッシュ関数 */
|
||||
int hashFunc(int key) {
|
||||
return key % _capacity;
|
||||
}
|
||||
|
||||
/* 負荷率 */
|
||||
double loadFactor() {
|
||||
return _size / _capacity;
|
||||
}
|
||||
|
||||
/* key に対応するバケットインデックスを探す */
|
||||
int findBucket(int key) {
|
||||
int index = hashFunc(key);
|
||||
int firstTombstone = -1;
|
||||
// 線形プロービングを行い、空バケットに達したら終了
|
||||
while (_buckets[index] != null) {
|
||||
// key が見つかったら、対応するバケットのインデックスを返す
|
||||
if (_buckets[index]!.key == key) {
|
||||
// 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動
|
||||
if (firstTombstone != -1) {
|
||||
_buckets[firstTombstone] = _buckets[index];
|
||||
_buckets[index] = _TOMBSTONE;
|
||||
return firstTombstone; // 移動後のバケットインデックスを返す
|
||||
}
|
||||
return index; // バケットのインデックスを返す
|
||||
}
|
||||
// 最初に見つかった削除マークを記録
|
||||
if (firstTombstone == -1 && _buckets[index] == _TOMBSTONE) {
|
||||
firstTombstone = index;
|
||||
}
|
||||
// バケットのインデックスを計算し、末尾を越えたら先頭に戻る
|
||||
index = (index + 1) % _capacity;
|
||||
}
|
||||
// key が存在しない場合は追加位置のインデックスを返す
|
||||
return firstTombstone == -1 ? index : firstTombstone;
|
||||
}
|
||||
|
||||
/* 検索操作 */
|
||||
String? get(int key) {
|
||||
// key に対応するバケットインデックスを探す
|
||||
int index = findBucket(key);
|
||||
// キーと値の組が見つかったら、対応する val を返す
|
||||
if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {
|
||||
return _buckets[index]!.val;
|
||||
}
|
||||
// キーと値の組が存在しなければ null を返す
|
||||
return null;
|
||||
}
|
||||
|
||||
/* 追加操作 */
|
||||
void put(int key, String val) {
|
||||
// 負荷率がしきい値を超えたら、リサイズを実行
|
||||
if (loadFactor() > _loadThres) {
|
||||
extend();
|
||||
}
|
||||
// key に対応するバケットインデックスを探す
|
||||
int index = findBucket(key);
|
||||
// キーと値の組が見つかったら、val を上書きして返す
|
||||
if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {
|
||||
_buckets[index]!.val = val;
|
||||
return;
|
||||
}
|
||||
// キーと値の組が存在しない場合は、その組を追加する
|
||||
_buckets[index] = new Pair(key, val);
|
||||
_size++;
|
||||
}
|
||||
|
||||
/* 削除操作 */
|
||||
void remove(int key) {
|
||||
// key に対応するバケットインデックスを探す
|
||||
int index = findBucket(key);
|
||||
// キーと値の組が見つかったら、削除マーカーで上書きする
|
||||
if (_buckets[index] != null && _buckets[index] != _TOMBSTONE) {
|
||||
_buckets[index] = _TOMBSTONE;
|
||||
_size--;
|
||||
}
|
||||
}
|
||||
|
||||
/* ハッシュテーブルを拡張 */
|
||||
void extend() {
|
||||
// 元のハッシュテーブルを一時保存
|
||||
List<Pair?> bucketsTmp = _buckets;
|
||||
// リサイズ後の新しいハッシュテーブルを初期化
|
||||
_capacity *= _extendRatio;
|
||||
_buckets = List.generate(_capacity, (index) => null);
|
||||
_size = 0;
|
||||
// キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す
|
||||
for (Pair? pair in bucketsTmp) {
|
||||
if (pair != null && pair != _TOMBSTONE) {
|
||||
put(pair.key, pair.val);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* ハッシュテーブルを出力 */
|
||||
void printHashMap() {
|
||||
for (Pair? pair in _buckets) {
|
||||
if (pair == null) {
|
||||
print("null");
|
||||
} else if (pair == _TOMBSTONE) {
|
||||
print("TOMBSTONE");
|
||||
} else {
|
||||
print("${pair.key} -> ${pair.val}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* ハッシュテーブルを初期化 */
|
||||
HashMapOpenAddressing map = HashMapOpenAddressing();
|
||||
|
||||
/* 追加操作 */
|
||||
// ハッシュテーブルにキーと値のペア (key, value) を追加
|
||||
map.put(12836, "シャオハー");
|
||||
map.put(15937, "シャオルオ");
|
||||
map.put(16750, "シャオスワン");
|
||||
map.put(13276, "シャオファー");
|
||||
map.put(10583, "シャオヤー");
|
||||
print("\n追加完了後、ハッシュテーブルは\nKey -> Value");
|
||||
map.printHashMap();
|
||||
|
||||
/* 検索操作 */
|
||||
// キー key をハッシュテーブルに渡し、値 value を取得
|
||||
String? name = map.get(13276);
|
||||
print("\n学籍番号 13276 を入力すると、氏名 $name が見つかります");
|
||||
|
||||
/* 削除操作 */
|
||||
// ハッシュテーブルからキーと値のペア (key, value) を削除
|
||||
map.remove(16750);
|
||||
print("\n16750 を削除した後、ハッシュテーブルは\nKey -> Value");
|
||||
map.printHashMap();
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
* File: simple_hash.dart
|
||||
* Created Time: 2023-06-25
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 加算ハッシュ */
|
||||
int addHash(String key) {
|
||||
int hash = 0;
|
||||
final int MODULUS = 1000000007;
|
||||
for (int i = 0; i < key.length; i++) {
|
||||
hash = (hash + key.codeUnitAt(i)) % MODULUS;
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
/* 乗算ハッシュ */
|
||||
int mulHash(String key) {
|
||||
int hash = 0;
|
||||
final int MODULUS = 1000000007;
|
||||
for (int i = 0; i < key.length; i++) {
|
||||
hash = (31 * hash + key.codeUnitAt(i)) % MODULUS;
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
/* XOR ハッシュ */
|
||||
int xorHash(String key) {
|
||||
int hash = 0;
|
||||
final int MODULUS = 1000000007;
|
||||
for (int i = 0; i < key.length; i++) {
|
||||
hash ^= key.codeUnitAt(i);
|
||||
}
|
||||
return hash & MODULUS;
|
||||
}
|
||||
|
||||
/* 回転ハッシュ */
|
||||
int rotHash(String key) {
|
||||
int hash = 0;
|
||||
final int MODULUS = 1000000007;
|
||||
for (int i = 0; i < key.length; i++) {
|
||||
hash = ((hash << 4) ^ (hash >> 28) ^ key.codeUnitAt(i)) % MODULUS;
|
||||
}
|
||||
return hash;
|
||||
}
|
||||
|
||||
/* Dirver Code */
|
||||
void main() {
|
||||
String key = "Hello アルゴリズム";
|
||||
|
||||
int hash = addHash(key);
|
||||
print("加算ハッシュ値は $hash です");
|
||||
|
||||
hash = mulHash(key);
|
||||
print("乗算ハッシュ値は $hash です");
|
||||
|
||||
hash = xorHash(key);
|
||||
print("XOR ハッシュ値は $hash です");
|
||||
|
||||
hash = rotHash(key);
|
||||
print("回転ハッシュ値は $hash です");
|
||||
}
|
||||
@@ -0,0 +1,151 @@
|
||||
/**
|
||||
* File: my_heap.dart
|
||||
* Created Time: 2023-04-09
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
|
||||
/* 最大ヒープ */
|
||||
class MaxHeap {
|
||||
late List<int> _maxHeap;
|
||||
|
||||
/* コンストラクタ。入力リストに基づいてヒープを構築する */
|
||||
MaxHeap(List<int> nums) {
|
||||
// リスト要素をそのままヒープに追加
|
||||
_maxHeap = nums;
|
||||
// 葉ノード以外のすべてのノードをヒープ化
|
||||
for (int i = _parent(size() - 1); i >= 0; i--) {
|
||||
siftDown(i);
|
||||
}
|
||||
}
|
||||
|
||||
/* 左子ノードのインデックスを取得 */
|
||||
int _left(int i) {
|
||||
return 2 * i + 1;
|
||||
}
|
||||
|
||||
/* 右子ノードのインデックスを取得 */
|
||||
int _right(int i) {
|
||||
return 2 * i + 2;
|
||||
}
|
||||
|
||||
/* 親ノードのインデックスを取得 */
|
||||
int _parent(int i) {
|
||||
return (i - 1) ~/ 2; // 切り捨て除算
|
||||
}
|
||||
|
||||
/* 要素を交換 */
|
||||
void _swap(int i, int j) {
|
||||
int tmp = _maxHeap[i];
|
||||
_maxHeap[i] = _maxHeap[j];
|
||||
_maxHeap[j] = tmp;
|
||||
}
|
||||
|
||||
/* ヒープのサイズを取得 */
|
||||
int size() {
|
||||
return _maxHeap.length;
|
||||
}
|
||||
|
||||
/* ヒープが空かどうかを判定 */
|
||||
bool isEmpty() {
|
||||
return size() == 0;
|
||||
}
|
||||
|
||||
/* ヒープ先頭要素にアクセス */
|
||||
int peek() {
|
||||
return _maxHeap[0];
|
||||
}
|
||||
|
||||
/* 要素をヒープに追加 */
|
||||
void push(int val) {
|
||||
// ノードを追加
|
||||
_maxHeap.add(val);
|
||||
// 下から上へヒープ化
|
||||
siftUp(size() - 1);
|
||||
}
|
||||
|
||||
/* ノード i から始めて、下から上へヒープ化 */
|
||||
void siftUp(int i) {
|
||||
while (true) {
|
||||
// ノード i の親ノードを取得
|
||||
int p = _parent(i);
|
||||
// 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了
|
||||
if (p < 0 || _maxHeap[i] <= _maxHeap[p]) {
|
||||
break;
|
||||
}
|
||||
// 2 つのノードを交換
|
||||
_swap(i, p);
|
||||
// ループで下から上へヒープ化
|
||||
i = p;
|
||||
}
|
||||
}
|
||||
|
||||
/* 要素をヒープから取り出す */
|
||||
int pop() {
|
||||
// 空判定の処理
|
||||
if (isEmpty()) throw Exception('ヒープが空です');
|
||||
// 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
|
||||
_swap(0, size() - 1);
|
||||
// ノードを削除
|
||||
int val = _maxHeap.removeLast();
|
||||
// 上から下へヒープ化
|
||||
siftDown(0);
|
||||
// ヒープ先頭要素を返す
|
||||
return val;
|
||||
}
|
||||
|
||||
/* ノード i から始めて、上から下へヒープ化 */
|
||||
void siftDown(int i) {
|
||||
while (true) {
|
||||
// ノード i, l, r のうち値が最大のノードを ma とする
|
||||
int l = _left(i);
|
||||
int r = _right(i);
|
||||
int ma = i;
|
||||
if (l < size() && _maxHeap[l] > _maxHeap[ma]) ma = l;
|
||||
if (r < size() && _maxHeap[r] > _maxHeap[ma]) ma = r;
|
||||
// ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
|
||||
if (ma == i) break;
|
||||
// 2 つのノードを交換
|
||||
_swap(i, ma);
|
||||
// ループで上から下へヒープ化
|
||||
i = ma;
|
||||
}
|
||||
}
|
||||
|
||||
/* ヒープ（二分木）を出力 */
|
||||
void print() {
|
||||
printHeap(_maxHeap);
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* 最大ヒープを初期化 */
|
||||
MaxHeap maxHeap = MaxHeap([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2]);
|
||||
print("\nリストを入力してヒープを構築した後");
|
||||
maxHeap.print();
|
||||
|
||||
/* ヒープ頂点の要素を取得 */
|
||||
int peek = maxHeap.peek();
|
||||
print("\nヒープの先頭要素は $peek です");
|
||||
|
||||
/* 要素をヒープに追加 */
|
||||
int val = 7;
|
||||
maxHeap.push(val);
|
||||
print("\n要素 $val をヒープに追加した後");
|
||||
maxHeap.print();
|
||||
|
||||
/* ヒープ頂点の要素を取り出す */
|
||||
peek = maxHeap.pop();
|
||||
print("\nヒープの先頭要素 $peek を取り出した後");
|
||||
maxHeap.print();
|
||||
|
||||
/* ヒープのサイズを取得 */
|
||||
int size = maxHeap.size();
|
||||
print("\nヒープ要素数は $size です");
|
||||
|
||||
/* ヒープが空かどうかを判定 */
|
||||
bool isEmpty = maxHeap.isEmpty();
|
||||
print("\nヒープが空かどうか $isEmpty");
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
/**
|
||||
* File: top_k.dart
|
||||
* Created Time: 2023-08-15
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
|
||||
/* ヒープに基づいて配列中の最大の k 個の要素を探す */
|
||||
MinHeap topKHeap(List<int> nums, int k) {
|
||||
// 最小ヒープを初期化し、配列の先頭 k 個の要素をヒープに入れる
|
||||
MinHeap heap = MinHeap(nums.sublist(0, k));
|
||||
// k+1 番目の要素から開始し、ヒープ長を k に保つ
|
||||
for (int i = k; i < nums.length; i++) {
|
||||
// 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する
|
||||
if (nums[i] > heap.peek()) {
|
||||
heap.pop();
|
||||
heap.push(nums[i]);
|
||||
}
|
||||
}
|
||||
return heap;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> nums = [1, 7, 6, 3, 2];
|
||||
int k = 3;
|
||||
|
||||
MinHeap res = topKHeap(nums, k);
|
||||
print("最大の $k 個の要素は");
|
||||
res.print();
|
||||
}
|
||||
|
||||
/* 最小ヒープ */
|
||||
class MinHeap {
|
||||
late List<int> _minHeap;
|
||||
|
||||
/* コンストラクタ。入力リストに基づいてヒープを構築する */
|
||||
MinHeap(List<int> nums) {
|
||||
// リスト要素をそのままヒープに追加
|
||||
_minHeap = nums;
|
||||
// 葉ノード以外のすべてのノードをヒープ化
|
||||
for (int i = _parent(size() - 1); i >= 0; i--) {
|
||||
siftDown(i);
|
||||
}
|
||||
}
|
||||
|
||||
/* ヒープ内の要素を返す */
|
||||
List<int> getHeap() {
|
||||
return _minHeap;
|
||||
}
|
||||
|
||||
/* 左子ノードのインデックスを取得 */
|
||||
int _left(int i) {
|
||||
return 2 * i + 1;
|
||||
}
|
||||
|
||||
/* 右子ノードのインデックスを取得 */
|
||||
int _right(int i) {
|
||||
return 2 * i + 2;
|
||||
}
|
||||
|
||||
/* 親ノードのインデックスを取得 */
|
||||
int _parent(int i) {
|
||||
return (i - 1) ~/ 2; // 切り捨て除算
|
||||
}
|
||||
|
||||
/* 要素を交換 */
|
||||
void _swap(int i, int j) {
|
||||
int tmp = _minHeap[i];
|
||||
_minHeap[i] = _minHeap[j];
|
||||
_minHeap[j] = tmp;
|
||||
}
|
||||
|
||||
/* ヒープのサイズを取得 */
|
||||
int size() {
|
||||
return _minHeap.length;
|
||||
}
|
||||
|
||||
/* ヒープが空かどうかを判定 */
|
||||
bool isEmpty() {
|
||||
return size() == 0;
|
||||
}
|
||||
|
||||
/* ヒープ先頭要素にアクセス */
|
||||
int peek() {
|
||||
return _minHeap[0];
|
||||
}
|
||||
|
||||
/* 要素をヒープに追加 */
|
||||
void push(int val) {
|
||||
// ノードを追加
|
||||
_minHeap.add(val);
|
||||
// 下から上へヒープ化
|
||||
siftUp(size() - 1);
|
||||
}
|
||||
|
||||
/* ノード i から始めて、下から上へヒープ化 */
|
||||
void siftUp(int i) {
|
||||
while (true) {
|
||||
// ノード i の親ノードを取得
|
||||
int p = _parent(i);
|
||||
// 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了
|
||||
if (p < 0 || _minHeap[i] >= _minHeap[p]) {
|
||||
break;
|
||||
}
|
||||
// 2 つのノードを交換
|
||||
_swap(i, p);
|
||||
// ループで下から上へヒープ化
|
||||
i = p;
|
||||
}
|
||||
}
|
||||
|
||||
/* 要素をヒープから取り出す */
|
||||
int pop() {
|
||||
// 空判定の処理
|
||||
if (isEmpty()) throw Exception('ヒープが空です');
|
||||
// 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
|
||||
_swap(0, size() - 1);
|
||||
// ノードを削除
|
||||
int val = _minHeap.removeLast();
|
||||
// 上から下へヒープ化
|
||||
siftDown(0);
|
||||
// ヒープ先頭要素を返す
|
||||
return val;
|
||||
}
|
||||
|
||||
/* ノード i から始めて、上から下へヒープ化 */
|
||||
void siftDown(int i) {
|
||||
while (true) {
|
||||
// ノード i, l, r のうち値が最大のノードを ma とする
|
||||
int l = _left(i);
|
||||
int r = _right(i);
|
||||
int mi = i;
|
||||
if (l < size() && _minHeap[l] < _minHeap[mi]) mi = l;
|
||||
if (r < size() && _minHeap[r] < _minHeap[mi]) mi = r;
|
||||
// ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
|
||||
if (mi == i) break;
|
||||
// 2 つのノードを交換
|
||||
_swap(i, mi);
|
||||
// ループで上から下へヒープ化
|
||||
i = mi;
|
||||
}
|
||||
}
|
||||
|
||||
/* ヒープ（二分木）を出力 */
|
||||
void print() {
|
||||
printHeap(_minHeap);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
/**
|
||||
* File: binary_search.dart
|
||||
* Created Time: 2023-05-12
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
/* 二分探索（両閉区間） */
|
||||
int binarySearch(List<int> nums, int target) {
|
||||
// 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す
|
||||
int i = 0, j = nums.length - 1;
|
||||
// ループし、探索区間が空になったら終了する（i > j で空）
|
||||
while (i <= j) {
|
||||
int m = i + (j - i) ~/ 2; // 中点インデックス m を計算
|
||||
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;
|
||||
}
|
||||
}
|
||||
// 目標要素が見つからなければ -1 を返す
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* 二分探索（左閉右開区間） */
|
||||
int binarySearchLCRO(List<int> nums, int target) {
|
||||
// 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す
|
||||
int i = 0, j = nums.length;
|
||||
// ループし、探索区間が空になったら終了する（i = j で空）
|
||||
while (i < j) {
|
||||
int m = i + (j - i) ~/ 2; // 中点インデックス m を計算
|
||||
if (nums[m] < target) {
|
||||
// この場合、target は区間 [m+1, j) にある
|
||||
i = m + 1;
|
||||
} else if (nums[m] > target) {
|
||||
// この場合、target は区間 [i, m) にある
|
||||
j = m;
|
||||
} else {
|
||||
// 目標要素が見つかったらそのインデックスを返す
|
||||
return m;
|
||||
}
|
||||
}
|
||||
// 目標要素が見つからなければ -1 を返す
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Driver Code*/
|
||||
void main() {
|
||||
int target = 6;
|
||||
final nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
|
||||
|
||||
/* 二分探索（両閉区間） */
|
||||
int index = binarySearch(nums, target);
|
||||
print('対象要素 6 のインデックス = $index');
|
||||
|
||||
/* 二分探索（左閉右開区間） */
|
||||
index = binarySearchLCRO(nums, target);
|
||||
print('対象要素 6 のインデックス = $index');
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
/**
|
||||
* File: binary_search_edge.dart
|
||||
* Created Time: 2023-08-14
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'binary_search_insertion.dart';
|
||||
|
||||
/* 最も左の target を二分探索 */
|
||||
int binarySearchLeftEdge(List<int> nums, int target) {
|
||||
// target の挿入位置を探すのと等価
|
||||
int i = binarySearchInsertion(nums, target);
|
||||
// target が見つからなければ、-1 を返す
|
||||
if (i == nums.length || nums[i] != target) {
|
||||
return -1;
|
||||
}
|
||||
// target が見つかったら、インデックス i を返す
|
||||
return i;
|
||||
}
|
||||
|
||||
/* 最も右の target を二分探索 */
|
||||
int binarySearchRightEdge(List<int> nums, int target) {
|
||||
// 最左の target + 1 を探す問題に変換する
|
||||
int i = binarySearchInsertion(nums, target + 1);
|
||||
// j は最も右の target を指し、i は target より大きい最初の要素を指す
|
||||
int j = i - 1;
|
||||
// target が見つからなければ、-1 を返す
|
||||
if (j == -1 || nums[j] != target) {
|
||||
return -1;
|
||||
}
|
||||
// target が見つかったら、インデックス j を返す
|
||||
return j;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
// 重複要素を含む配列
|
||||
List<int> nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
|
||||
print("\n配列 nums = $nums");
|
||||
|
||||
// 二分探索で左端と右端を探す
|
||||
for (int target in [6, 7]) {
|
||||
int index = binarySearchLeftEdge(nums, target);
|
||||
print("最も左の要素 $target のインデックスは $index です");
|
||||
index = binarySearchRightEdge(nums, target);
|
||||
print("最も右の要素 $target のインデックスは $index です");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,60 @@
|
||||
/**
|
||||
* File: binary_search_insertion.dart
|
||||
* Created Time: 2023-08-14
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 二分探索で挿入位置を探す（重複要素なし） */
|
||||
int binarySearchInsertionSimple(List<int> nums, int target) {
|
||||
int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化
|
||||
while (i <= j) {
|
||||
int m = i + (j - i) ~/ 2; // 中点インデックス m を計算
|
||||
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;
|
||||
}
|
||||
|
||||
/* 二分探索で挿入位置を探す（重複要素あり） */
|
||||
int binarySearchInsertion(List<int> nums, int target) {
|
||||
int i = 0, j = nums.length - 1; // 両閉区間 [0, n-1] を初期化
|
||||
while (i <= j) {
|
||||
int m = i + (j - i) ~/ 2; // 中点インデックス m を計算
|
||||
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 */
|
||||
void main() {
|
||||
// 重複要素のない配列
|
||||
List<int> nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35];
|
||||
print("\n配列 nums = $nums");
|
||||
// 二分探索で挿入位置を探す
|
||||
for (int target in [6, 9]) {
|
||||
int index = binarySearchInsertionSimple(nums, target);
|
||||
print("要素 $target の挿入位置のインデックスは $index です");
|
||||
}
|
||||
|
||||
// 重複要素を含む配列
|
||||
nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15];
|
||||
print("\n配列 nums = $nums");
|
||||
// 二分探索で挿入位置を探す
|
||||
for (int target in [2, 6, 20]) {
|
||||
int index = binarySearchInsertion(nums, target);
|
||||
print("要素 $target の挿入位置のインデックスは $index です");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
/**
|
||||
* File: hashing_search.dart
|
||||
* Created Time: 2023-05-12
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:collection';
|
||||
import '../utils/list_node.dart';
|
||||
|
||||
/* ハッシュ探索（配列） */
|
||||
int hashingSearchArray(Map<int, int> map, int target) {
|
||||
// ハッシュテーブルの key: 目標要素、value: インデックス
|
||||
// ハッシュテーブルにこの key がなければ -1 を返す
|
||||
if (!map.containsKey(target)) {
|
||||
return -1;
|
||||
}
|
||||
return map[target]!;
|
||||
}
|
||||
|
||||
/* ハッシュ探索（連結リスト） */
|
||||
ListNode? hashingSearchLinkedList(Map<int, ListNode> map, int target) {
|
||||
// ハッシュテーブルの key: 目標ノード値、value: ノードオブジェクト
|
||||
// ハッシュテーブルにこの key がなければ null を返す
|
||||
if (!map.containsKey(target)) {
|
||||
return null;
|
||||
}
|
||||
return map[target]!;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int target = 3;
|
||||
|
||||
/* ハッシュ探索（配列） */
|
||||
List<int> nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
|
||||
// ハッシュテーブルを初期化
|
||||
Map<int, int> map = HashMap();
|
||||
for (int i = 0; i < nums.length; i++) {
|
||||
map.putIfAbsent(nums[i], () => i); // key: 要素、value: インデックス
|
||||
}
|
||||
int index = hashingSearchArray(map, target);
|
||||
print('対象要素 3 のインデックス = $index');
|
||||
|
||||
/* ハッシュ探索（連結リスト） */
|
||||
ListNode? head = listToLinkedList(nums);
|
||||
// ハッシュテーブルを初期化
|
||||
Map<int, ListNode> map1 = HashMap();
|
||||
while (head != null) {
|
||||
map1.putIfAbsent(head.val, () => head!); // key: ノード値、value: ノード
|
||||
head = head.next;
|
||||
}
|
||||
ListNode? node = hashingSearchLinkedList(map1, target);
|
||||
print('目標ノード値 3 に対応するノードオブジェクトは $node です');
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
/**
|
||||
* File: linear_search.dart
|
||||
* Created Time: 2023-05-12
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/list_node.dart';
|
||||
|
||||
/* 線形探索（配列） */
|
||||
int linearSearchArray(List<int> nums, int target) {
|
||||
// 配列を走査
|
||||
for (int i = 0; i < nums.length; i++) {
|
||||
// 目標要素が見つかったらそのインデックスを返す
|
||||
if (nums[i] == target) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
// 目標要素が見つからなければ -1 を返す
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* 線形探索（連結リスト） */
|
||||
ListNode? linearSearchList(ListNode? head, int target) {
|
||||
// 連結リストを走査
|
||||
while (head != null) {
|
||||
// 対象ノードが見つかったら、それを返す
|
||||
if (head.val == target) return head;
|
||||
head = head.next;
|
||||
}
|
||||
// 対象要素が見つからない場合は `null` を返す
|
||||
return null;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
int target = 3;
|
||||
|
||||
/* 配列で線形探索を行う */
|
||||
List<int> nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8];
|
||||
int index = linearSearchArray(nums, target);
|
||||
print('対象要素 3 のインデックス = $index');
|
||||
|
||||
/* 連結リストで線形探索を行う */
|
||||
ListNode? head = listToLinkedList(nums);
|
||||
ListNode? node = linearSearchList(head, target);
|
||||
print('目標ノード値 3 に対応するノードオブジェクトは $node です');
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
/**
|
||||
* File: two_sum.dart
|
||||
* Created Time: 2023-2-11
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:collection';
|
||||
|
||||
/* 方法1: 総当たり列挙 */
|
||||
List<int> twoSumBruteForce(List<int> nums, int target) {
|
||||
int size = nums.length;
|
||||
// 2重ループのため、時間計算量は O(n^2)
|
||||
for (var i = 0; i < size - 1; i++) {
|
||||
for (var j = i + 1; j < size; j++) {
|
||||
if (nums[i] + nums[j] == target) return [i, j];
|
||||
}
|
||||
}
|
||||
return [0];
|
||||
}
|
||||
|
||||
/* 方法2: 補助ハッシュテーブル */
|
||||
List<int> twoSumHashTable(List<int> nums, int target) {
|
||||
int size = nums.length;
|
||||
// 補助ハッシュテーブルを使用し、空間計算量は O(n)
|
||||
Map<int, int> dic = HashMap();
|
||||
// 単一ループで、時間計算量は O(n)
|
||||
for (var i = 0; i < size; i++) {
|
||||
if (dic.containsKey(target - nums[i])) {
|
||||
return [dic[target - nums[i]]!, i];
|
||||
}
|
||||
dic.putIfAbsent(nums[i], () => i);
|
||||
}
|
||||
return [0];
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
// ======= Test Case =======
|
||||
List<int> nums = [2, 7, 11, 15];
|
||||
int target = 13;
|
||||
|
||||
// ====== Driver Code ======
|
||||
// 方法 1
|
||||
List<int> res = twoSumBruteForce(nums, target);
|
||||
print('方法1 res = $res');
|
||||
// 方法 2
|
||||
res = twoSumHashTable(nums, target);
|
||||
print('方法2 res = $res');
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
/**
|
||||
* File: bubble_sort.dart
|
||||
* Created Time: 2023-02-14
|
||||
* Author: what-is-me (whatisme@outlook.jp)
|
||||
*/
|
||||
|
||||
/* バブルソート */
|
||||
void bubbleSort(List<int> nums) {
|
||||
// 外側のループ：未ソート区間は [0, i]
|
||||
for (int i = nums.length - 1; i > 0; i--) {
|
||||
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
|
||||
for (int j = 0; j < i; j++) {
|
||||
if (nums[j] > nums[j + 1]) {
|
||||
// nums[j] と nums[j + 1] を交換
|
||||
int tmp = nums[j];
|
||||
nums[j] = nums[j + 1];
|
||||
nums[j + 1] = tmp;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* バブルソート（フラグ最適化） */
|
||||
void bubbleSortWithFlag(List<int> nums) {
|
||||
// 外側のループ：未ソート区間は [0, i]
|
||||
for (int i = nums.length - 1; i > 0; i--) {
|
||||
bool flag = false; // フラグを初期化する
|
||||
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
|
||||
for (int j = 0; j < i; j++) {
|
||||
if (nums[j] > nums[j + 1]) {
|
||||
// nums[j] と nums[j + 1] を交換
|
||||
int tmp = nums[j];
|
||||
nums[j] = nums[j + 1];
|
||||
nums[j + 1] = tmp;
|
||||
flag = true; // 交換する要素を記録
|
||||
}
|
||||
}
|
||||
if (!flag) break; // このバブル処理で要素交換が一度もなければそのまま終了
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> nums = [4, 1, 3, 1, 5, 2];
|
||||
bubbleSort(nums);
|
||||
print("バブルソート完了後 nums = $nums");
|
||||
|
||||
List<int> nums1 = [4, 1, 3, 1, 5, 2];
|
||||
bubbleSortWithFlag(nums1);
|
||||
print("バブルソート完了後 nums1 = $nums1");
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
/**
|
||||
* File: bucket_sort.dart
|
||||
* Created Time: 2023-05-12
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
/* バケットソート */
|
||||
void bucketSort(List<double> nums) {
|
||||
// k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする
|
||||
int k = nums.length ~/ 2;
|
||||
List<List<double>> buckets = List.generate(k, (index) => []);
|
||||
|
||||
// 1. 配列要素を各バケットに振り分ける
|
||||
for (double _num in nums) {
|
||||
// 入力データの範囲は [0, 1) であり、_num * k を用いてインデックス範囲 [0, k-1] に写像する
|
||||
int i = (_num * k).toInt();
|
||||
// _num をバケット bucket_idx に追加
|
||||
buckets[i].add(_num);
|
||||
}
|
||||
// 2. 各バケットをソートする
|
||||
for (List<double> bucket in buckets) {
|
||||
bucket.sort();
|
||||
}
|
||||
// 3. バケットを走査して結果を結合
|
||||
int i = 0;
|
||||
for (List<double> bucket in buckets) {
|
||||
for (double _num in bucket) {
|
||||
nums[i++] = _num;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code*/
|
||||
void main() {
|
||||
// 入力データは範囲 [0, 1) の浮動小数点数とする
|
||||
final nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37];
|
||||
bucketSort(nums);
|
||||
print('バケットソート完了後 nums = $nums');
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
/**
|
||||
* File: counting_sort.dart
|
||||
* Created Time: 2023-05-12
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
import 'dart:math';
|
||||
|
||||
/* 計数ソート */
|
||||
// 簡易実装のため、オブジェクトのソートには使えない
|
||||
void countingSortNaive(List<int> nums) {
|
||||
// 1. 配列の最大要素 m を求める
|
||||
int m = 0;
|
||||
for (int _num in nums) {
|
||||
m = max(m, _num);
|
||||
}
|
||||
// 2. 各数値の出現回数を数える
|
||||
// counter[_num] は _num の出現回数を表す
|
||||
List<int> counter = List.filled(m + 1, 0);
|
||||
for (int _num in nums) {
|
||||
counter[_num]++;
|
||||
}
|
||||
// 3. counter を走査し、各要素を元の配列 nums に書き戻す
|
||||
int i = 0;
|
||||
for (int _num = 0; _num < m + 1; _num++) {
|
||||
for (int j = 0; j < counter[_num]; j++, i++) {
|
||||
nums[i] = _num;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* 計数ソート */
|
||||
// 完全な実装で、オブジェクトをソートでき、かつ安定ソートである
|
||||
void countingSort(List<int> nums) {
|
||||
// 1. 配列の最大要素 m を求める
|
||||
int m = 0;
|
||||
for (int _num in nums) {
|
||||
m = max(m, _num);
|
||||
}
|
||||
// 2. 各数値の出現回数を数える
|
||||
// counter[_num] は _num の出現回数を表す
|
||||
List<int> counter = List.filled(m + 1, 0);
|
||||
for (int _num in nums) {
|
||||
counter[_num]++;
|
||||
}
|
||||
// 3. counter の累積和を求め、「出現回数」を「末尾インデックス」に変換する
|
||||
// つまり counter[_num]-1 は、res において _num が最後に出現する位置のインデックスである
|
||||
for (int i = 0; i < m; i++) {
|
||||
counter[i + 1] += counter[i];
|
||||
}
|
||||
// 4. nums を逆順に走査し、各要素を結果配列 res に格納する
|
||||
// 結果を記録するための配列 res を初期化
|
||||
int n = nums.length;
|
||||
List<int> res = List.filled(n, 0);
|
||||
for (int i = n - 1; i >= 0; i--) {
|
||||
int _num = nums[i];
|
||||
res[counter[_num] - 1] = _num; // _num を対応する添字に配置
|
||||
counter[_num]--; // 累積和を 1 減らし、次に _num を配置するインデックスを得る
|
||||
}
|
||||
// 結果配列 res で元の配列 nums を上書きする
|
||||
nums.setAll(0, res);
|
||||
}
|
||||
|
||||
/* Driver Code*/
|
||||
void main() {
|
||||
final nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
|
||||
countingSortNaive(nums);
|
||||
print('カウントソート（オブジェクトはソート不可）完了後 nums = $nums');
|
||||
|
||||
final nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4];
|
||||
countingSort(nums1);
|
||||
print('カウントソート完了後 nums1 = $nums1');
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
/**
|
||||
* File: heap_sort.dart
|
||||
* Created Time: 2023-06-01
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* ヒープの長さは n。ノード i から下方向にヒープ化 */
|
||||
void siftDown(List<int> nums, int n, int i) {
|
||||
while (true) {
|
||||
// ノード i, l, r のうち値が最大のノードを ma とする
|
||||
int l = 2 * i + 1;
|
||||
int r = 2 * i + 2;
|
||||
int 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 つのノードを交換
|
||||
int temp = nums[i];
|
||||
nums[i] = nums[ma];
|
||||
nums[ma] = temp;
|
||||
// ループで上から下へヒープ化
|
||||
i = ma;
|
||||
}
|
||||
}
|
||||
|
||||
/* ヒープソート */
|
||||
void heapSort(List<int> nums) {
|
||||
// ヒープ構築：葉ノード以外のすべてのノードをヒープ化する
|
||||
for (int i = nums.length ~/ 2 - 1; i >= 0; i--) {
|
||||
siftDown(nums, nums.length, i);
|
||||
}
|
||||
// ヒープから最大要素を取り出し、n-1 回繰り返す
|
||||
for (int i = nums.length - 1; i > 0; i--) {
|
||||
// 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
|
||||
int tmp = nums[0];
|
||||
nums[0] = nums[i];
|
||||
nums[i] = tmp;
|
||||
// 根ノードを起点に、上から下へヒープ化
|
||||
siftDown(nums, i, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> nums = [4, 1, 3, 1, 5, 2];
|
||||
heapSort(nums);
|
||||
print("ヒープソート完了後 nums = $nums");
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
/**
|
||||
* File: insertion_sort.dart
|
||||
* Created Time: 2023-02-14
|
||||
* Author: what-is-me (whatisme@outlook.jp)
|
||||
*/
|
||||
|
||||
/* 挿入ソート */
|
||||
void insertionSort(List<int> nums) {
|
||||
// 外側ループ：整列済み区間は [0, i-1]
|
||||
for (int i = 1; i < nums.length; i++) {
|
||||
int base = nums[i], 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 */
|
||||
void main() {
|
||||
List<int> nums = [4, 1, 3, 1, 5, 2];
|
||||
insertionSort(nums);
|
||||
print("挿入ソート完了後 nums = $nums");
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
/**
|
||||
* File: merge_sort.dart
|
||||
* Created Time: 2023-02-14
|
||||
* Author: what-is-me (whatisme@outlook.jp)
|
||||
*/
|
||||
|
||||
/* 左部分配列と右部分配列をマージ */
|
||||
void merge(List<int> nums, int left, int mid, int right) {
|
||||
// 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]
|
||||
// マージ結果を格納する一時配列 tmp を作成
|
||||
List<int> tmp = List.filled(right - left + 1, 0);
|
||||
// 左右の部分配列の開始インデックスを初期化する
|
||||
int 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];
|
||||
}
|
||||
}
|
||||
|
||||
/* マージソート */
|
||||
void mergeSort(List<int> nums, int left, int right) {
|
||||
// 終了条件
|
||||
if (left >= right) return; // 部分配列の長さが 1 になったら再帰を終了
|
||||
// 分割フェーズ
|
||||
int mid = left + (right - left) ~/ 2; // 中点を計算
|
||||
mergeSort(nums, left, mid); // 左部分配列を再帰処理
|
||||
mergeSort(nums, mid + 1, right); // 右部分配列を再帰処理
|
||||
// マージフェーズ
|
||||
merge(nums, left, mid, right);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* マージソート */
|
||||
List<int> nums = [7, 3, 2, 6, 0, 1, 5, 4];
|
||||
mergeSort(nums, 0, nums.length - 1);
|
||||
print("マージソート完了後 nums = $nums");
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
/**
|
||||
* File: quick_sort.dart
|
||||
* Created Time: 2023-02-14
|
||||
* Author: what-is-me (whatisme@outlook.jp)
|
||||
*/
|
||||
|
||||
/* クイックソートクラス */
|
||||
class QuickSort {
|
||||
/* 要素の交換 */
|
||||
static void _swap(List<int> nums, int i, int j) {
|
||||
int tmp = nums[i];
|
||||
nums[i] = nums[j];
|
||||
nums[j] = tmp;
|
||||
}
|
||||
|
||||
/* 番兵分割 */
|
||||
static int _partition(List<int> nums, int left, int right) {
|
||||
// nums[left] を基準値とする
|
||||
int i = left, j = right;
|
||||
while (i < j) {
|
||||
while (i < j && nums[j] >= nums[left]) j--; // 右から左へ基準値未満の最初の要素を探す
|
||||
while (i < j && nums[i] <= nums[left]) i++; // 左から右へ基準値より大きい最初の要素を探す
|
||||
_swap(nums, i, j); // この 2 つの要素を交換
|
||||
}
|
||||
_swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
|
||||
return i; // 基準値のインデックスを返す
|
||||
}
|
||||
|
||||
/* クイックソート */
|
||||
static void quickSort(List<int> nums, int left, int right) {
|
||||
// 部分配列の長さが 1 なら再帰を終了する
|
||||
if (left >= right) return;
|
||||
// 番兵分割
|
||||
int pivot = _partition(nums, left, right);
|
||||
// 左右の部分配列を再帰処理
|
||||
quickSort(nums, left, pivot - 1);
|
||||
quickSort(nums, pivot + 1, right);
|
||||
}
|
||||
}
|
||||
|
||||
/* クイックソートクラス（中央値ピボット最適化） */
|
||||
class QuickSortMedian {
|
||||
/* 要素の交換 */
|
||||
static void _swap(List<int> nums, int i, int j) {
|
||||
int tmp = nums[i];
|
||||
nums[i] = nums[j];
|
||||
nums[j] = tmp;
|
||||
}
|
||||
|
||||
/* 3つの候補要素の中央値を選ぶ */
|
||||
static int _medianThree(List<int> nums, int left, int mid, int right) {
|
||||
int l = nums[left], m = nums[mid], r = nums[right];
|
||||
if ((l <= m && m <= r) || (r <= m && m <= l))
|
||||
return mid; // m は l と r の間
|
||||
if ((m <= l && l <= r) || (r <= l && l <= m))
|
||||
return left; // l は m と r の間
|
||||
return right;
|
||||
}
|
||||
|
||||
/* 番兵による分割処理（3 点中央値） */
|
||||
static int _partition(List<int> nums, int left, int right) {
|
||||
// 3つの候補要素の中央値を選ぶ
|
||||
int med = _medianThree(nums, left, (left + right) ~/ 2, right);
|
||||
// 中央値を配列の最左端に交換する
|
||||
_swap(nums, left, med);
|
||||
// nums[left] を基準値とする
|
||||
int i = left, j = right;
|
||||
while (i < j) {
|
||||
while (i < j && nums[j] >= nums[left]) j--; // 右から左へ基準値未満の最初の要素を探す
|
||||
while (i < j && nums[i] <= nums[left]) i++; // 左から右へ基準値より大きい最初の要素を探す
|
||||
_swap(nums, i, j); // この 2 つの要素を交換
|
||||
}
|
||||
_swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
|
||||
return i; // 基準値のインデックスを返す
|
||||
}
|
||||
|
||||
/* クイックソート */
|
||||
static void quickSort(List<int> nums, int left, int right) {
|
||||
// 部分配列の長さが 1 なら再帰を終了する
|
||||
if (left >= right) return;
|
||||
// 番兵分割
|
||||
int pivot = _partition(nums, left, right);
|
||||
// 左右の部分配列を再帰処理
|
||||
quickSort(nums, left, pivot - 1);
|
||||
quickSort(nums, pivot + 1, right);
|
||||
}
|
||||
}
|
||||
|
||||
/* クイックソートクラス（再帰深度最適化） */
|
||||
class QuickSortTailCall {
|
||||
/* 要素の交換 */
|
||||
static void _swap(List<int> nums, int i, int j) {
|
||||
int tmp = nums[i];
|
||||
nums[i] = nums[j];
|
||||
nums[j] = tmp;
|
||||
}
|
||||
|
||||
/* 番兵分割 */
|
||||
static int _partition(List<int> nums, int left, int right) {
|
||||
// nums[left] を基準値とする
|
||||
int i = left, j = right;
|
||||
while (i < j) {
|
||||
while (i < j && nums[j] >= nums[left]) j--; // 右から左へ基準値未満の最初の要素を探す
|
||||
while (i < j && nums[i] <= nums[left]) i++; // 左から右へ基準値より大きい最初の要素を探す
|
||||
_swap(nums, i, j); // この 2 つの要素を交換
|
||||
}
|
||||
_swap(nums, i, left); // 基準値を 2 つの部分配列の境界へ交換する
|
||||
return i; // 基準値のインデックスを返す
|
||||
}
|
||||
|
||||
/* クイックソート（再帰深度最適化） */
|
||||
static void quickSort(List<int> nums, int left, int right) {
|
||||
// 部分配列の長さが 1 なら終了
|
||||
while (left < right) {
|
||||
// 番兵による分割処理
|
||||
int pivot = _partition(nums, left, right);
|
||||
// 2 つの部分配列のうち短いほうにクイックソートを適用する
|
||||
if (pivot - left < right - pivot) {
|
||||
quickSort(nums, left, pivot - 1); // 左部分配列を再帰的にソート
|
||||
left = pivot + 1; // 未ソート区間の残りは [pivot + 1, right]
|
||||
} else {
|
||||
quickSort(nums, pivot + 1, right); // 右部分配列を再帰的にソート
|
||||
right = pivot - 1; // 未ソート区間の残りは [left, pivot - 1]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* クイックソート */
|
||||
List<int> nums = [2, 4, 1, 0, 3, 5];
|
||||
QuickSort.quickSort(nums, 0, nums.length - 1);
|
||||
print("クイックソート完了後 nums = $nums");
|
||||
|
||||
/* クイックソート（中央値の基準値で最適化） */
|
||||
List<int> nums1 = [2, 4, 1, 0, 3, 5];
|
||||
QuickSortMedian.quickSort(nums1, 0, nums1.length - 1);
|
||||
print("クイックソート（中央値ピボット最適化）完了後 nums1 = $nums1");
|
||||
|
||||
/* クイックソート（再帰深度最適化） */
|
||||
List<int> nums2 = [2, 4, 1, 0, 3, 5];
|
||||
QuickSortTailCall.quickSort(nums2, 0, nums2.length - 1);
|
||||
print("クイックソート（再帰深度最適化）完了後 nums2 = $nums2");
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
/**
|
||||
* File: radix_sort.dart
|
||||
* Created Time: 2023-02-14
|
||||
* Author: what-is-me (whatisme@outlook.jp)
|
||||
*/
|
||||
|
||||
/* 要素 `_num` の第 k 桁を取得する。ここで `exp = 10^(k-1)` */
|
||||
int digit(int _num, int exp) {
|
||||
// ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す
|
||||
return (_num ~/ exp) % 10;
|
||||
}
|
||||
|
||||
/* 計数ソート（nums の k 桁目でソート） */
|
||||
void countingSortDigit(List<int> nums, int exp) {
|
||||
// 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要
|
||||
List<int> counter = List<int>.filled(10, 0);
|
||||
int n = nums.length;
|
||||
// 0~9 の各数字の出現回数を集計する
|
||||
for (int i = 0; i < n; i++) {
|
||||
int d = digit(nums[i], exp); // nums[i] の第 k 位を取得し、d とする
|
||||
counter[d]++; // 数字 d の出現回数を数える
|
||||
}
|
||||
// 累積和を求め、「出現回数」を「配列インデックス」に変換する
|
||||
for (int i = 1; i < 10; i++) {
|
||||
counter[i] += counter[i - 1];
|
||||
}
|
||||
// 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する
|
||||
List<int> res = List<int>.filled(n, 0);
|
||||
for (int i = n - 1; i >= 0; i--) {
|
||||
int d = digit(nums[i], exp);
|
||||
int j = counter[d] - 1; // d の配列内インデックス j を取得する
|
||||
res[j] = nums[i]; // 現在の要素をインデックス j に格納する
|
||||
counter[d]--; // d の個数を 1 減らす
|
||||
}
|
||||
// 結果で元の配列 nums を上書きする
|
||||
for (int i = 0; i < n; i++) nums[i] = res[i];
|
||||
}
|
||||
|
||||
/* 基数ソート */
|
||||
void radixSort(List<int> nums) {
|
||||
// 最大桁数の判定用に配列の最大要素を取得する
|
||||
// dart の `int` の長さは 64 ビット
|
||||
int m = -1 << 63;
|
||||
for (int _num in nums) if (_num > m) m = _num;
|
||||
// 下位桁から上位桁の順に走査する
|
||||
for (int exp = 1; exp <= m; exp *= 10)
|
||||
// 配列要素の k 桁目に対して計数ソートを行う
|
||||
// k = 1 -> exp = 1
|
||||
// k = 2 -> exp = 10
|
||||
// つまり exp = 10^(k-1)
|
||||
countingSortDigit(nums, exp);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
// 基数ソート
|
||||
List<int> nums = [
|
||||
10546151,
|
||||
35663510,
|
||||
42865989,
|
||||
34862445,
|
||||
81883077,
|
||||
88906420,
|
||||
72429244,
|
||||
30524779,
|
||||
82060337,
|
||||
63832996
|
||||
];
|
||||
radixSort(nums);
|
||||
print("基数ソート完了後 nums = $nums");
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
/**
|
||||
* File: selection_sort.dart
|
||||
* Created Time: 2023-06-01
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 選択ソート */
|
||||
void selectionSort(List<int> nums) {
|
||||
int n = nums.length;
|
||||
// 外側ループ：未整列区間は [i, n-1]
|
||||
for (int i = 0; i < n - 1; i++) {
|
||||
// 内側のループ：未ソート区間の最小要素を見つける
|
||||
int k = i;
|
||||
for (int j = i + 1; j < n; j++) {
|
||||
if (nums[j] < nums[k]) k = j; // 最小要素のインデックスを記録
|
||||
}
|
||||
// その最小要素を未整列区間の先頭要素と交換する
|
||||
int temp = nums[i];
|
||||
nums[i] = nums[k];
|
||||
nums[k] = temp;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
List<int> nums = [4, 1, 3, 1, 5, 2];
|
||||
selectionSort(nums);
|
||||
print("選択ソート完了後 nums = $nums");
|
||||
}
|
||||
@@ -0,0 +1,146 @@
|
||||
/**
|
||||
* File: array_deque.dart
|
||||
* Created Time: 2023-03-28
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 循環配列ベースの両端キュー */
|
||||
class ArrayDeque {
|
||||
late List<int> _nums; // 両端キューの要素を格納する配列
|
||||
late int _front; // 先頭ポインタ。先頭要素を指す
|
||||
late int _queSize; // 両端キューの長さ
|
||||
|
||||
/* コンストラクタ */
|
||||
ArrayDeque(int capacity) {
|
||||
this._nums = List.filled(capacity, 0);
|
||||
this._front = this._queSize = 0;
|
||||
}
|
||||
|
||||
/* 両端キューの容量を取得 */
|
||||
int capacity() {
|
||||
return _nums.length;
|
||||
}
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
int size() {
|
||||
return _queSize;
|
||||
}
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
bool isEmpty() {
|
||||
return _queSize == 0;
|
||||
}
|
||||
|
||||
/* 循環配列のインデックスを計算 */
|
||||
int index(int i) {
|
||||
// 剰余演算により配列の先頭と末尾をつなげる
|
||||
// i が配列の末尾を越えたら先頭に戻る
|
||||
// i が配列の先頭を越えて前に出たら末尾に戻る
|
||||
return (i + capacity()) % capacity();
|
||||
}
|
||||
|
||||
/* キュー先頭にエンキュー */
|
||||
void pushFirst(int _num) {
|
||||
if (_queSize == capacity()) {
|
||||
throw Exception("両端キューがいっぱいです");
|
||||
}
|
||||
// 先頭ポインタを左に 1 つ移動する
|
||||
// 剰余演算により _front が配列の先頭を越えたあと末尾に戻るようにする
|
||||
_front = index(_front - 1);
|
||||
// _num をキューの先頭に追加
|
||||
_nums[_front] = _num;
|
||||
_queSize++;
|
||||
}
|
||||
|
||||
/* キュー末尾にエンキュー */
|
||||
void pushLast(int _num) {
|
||||
if (_queSize == capacity()) {
|
||||
throw Exception("両端キューがいっぱいです");
|
||||
}
|
||||
// キュー末尾ポインタを計算し、末尾インデックス + 1 を指す
|
||||
int rear = index(_front + _queSize);
|
||||
// _num をキュー末尾に追加
|
||||
_nums[rear] = _num;
|
||||
_queSize++;
|
||||
}
|
||||
|
||||
/* キュー先頭からデキュー */
|
||||
int popFirst() {
|
||||
int _num = peekFirst();
|
||||
// 先頭ポインタを右に 1 つ移動する
|
||||
_front = index(_front + 1);
|
||||
_queSize--;
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* キュー末尾からデキュー */
|
||||
int popLast() {
|
||||
int _num = peekLast();
|
||||
_queSize--;
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
int peekFirst() {
|
||||
if (isEmpty()) {
|
||||
throw Exception("両端キューが空です");
|
||||
}
|
||||
return _nums[_front];
|
||||
}
|
||||
|
||||
/* キュー末尾の要素にアクセス */
|
||||
int peekLast() {
|
||||
if (isEmpty()) {
|
||||
throw Exception("両端キューが空です");
|
||||
}
|
||||
// 末尾要素のインデックスを計算
|
||||
int last = index(_front + _queSize - 1);
|
||||
return _nums[last];
|
||||
}
|
||||
|
||||
/* 出力用の配列を返す */
|
||||
List<int> toArray() {
|
||||
// 有効長の範囲内のリスト要素のみを変換
|
||||
List<int> res = List.filled(_queSize, 0);
|
||||
for (int i = 0, j = _front; i < _queSize; i++, j++) {
|
||||
res[i] = _nums[index(j)];
|
||||
}
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* 両端キューを初期化 */
|
||||
final ArrayDeque deque = ArrayDeque(10);
|
||||
deque.pushLast(3);
|
||||
deque.pushLast(2);
|
||||
deque.pushLast(5);
|
||||
print("両端キュー deque = ${deque.toArray()}");
|
||||
|
||||
/* 要素にアクセス */
|
||||
final int peekFirst = deque.peekFirst();
|
||||
print("先頭要素 peekFirst = $peekFirst");
|
||||
final int peekLast = deque.peekLast();
|
||||
print("末尾要素 peekLast = $peekLast");
|
||||
|
||||
/* 要素をエンキュー */
|
||||
deque.pushLast(4);
|
||||
print("要素 4 を末尾に追加した後 deque = ${deque.toArray()}");
|
||||
deque.pushFirst(1);
|
||||
print("要素 1 を先頭に追加した後 deque = ${deque.toArray()}");
|
||||
|
||||
/* 要素をデキュー */
|
||||
final int popLast = deque.popLast();
|
||||
print("末尾から取り出した要素 = $popLast ，末尾から取り出した後 deque = ${deque.toArray()}");
|
||||
final int popFirst = deque.popFirst();
|
||||
print("先頭から取り出した要素 = $popFirst ，先頭から取り出した後 deque = ${deque.toArray()}");
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
final int size = deque.size();
|
||||
print("両端キューの長さ size = $size");
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
final bool isEmpty = deque.isEmpty();
|
||||
print("両端キューが空かどうか = $isEmpty");
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
/**
|
||||
* File: array_queue.dart
|
||||
* Created Time: 2023-03-28
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 循環配列ベースのキュー */
|
||||
class ArrayQueue {
|
||||
late List<int> _nums; // キュー要素を格納する配列
|
||||
late int _front; // 先頭ポインタ。先頭要素を指す
|
||||
late int _queSize; // キューの長さ
|
||||
|
||||
ArrayQueue(int capacity) {
|
||||
_nums = List.filled(capacity, 0);
|
||||
_front = _queSize = 0;
|
||||
}
|
||||
|
||||
/* キューの容量を取得 */
|
||||
int capaCity() {
|
||||
return _nums.length;
|
||||
}
|
||||
|
||||
/* キューの長さを取得 */
|
||||
int size() {
|
||||
return _queSize;
|
||||
}
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
bool isEmpty() {
|
||||
return _queSize == 0;
|
||||
}
|
||||
|
||||
/* エンキュー */
|
||||
void push(int _num) {
|
||||
if (_queSize == capaCity()) {
|
||||
throw Exception("キューは満杯です");
|
||||
}
|
||||
// 末尾ポインタを計算し、末尾インデックス + 1 を指す
|
||||
// 剰余演算により、rear が配列末尾を越えた後に先頭へ戻るようにする
|
||||
int rear = (_front + _queSize) % capaCity();
|
||||
// _num をキュー末尾に追加
|
||||
_nums[rear] = _num;
|
||||
_queSize++;
|
||||
}
|
||||
|
||||
/* デキュー */
|
||||
int pop() {
|
||||
int _num = peek();
|
||||
// 先頭ポインタを1つ後ろへ進め、末尾を越えたら配列先頭に戻す
|
||||
_front = (_front + 1) % capaCity();
|
||||
_queSize--;
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
int peek() {
|
||||
if (isEmpty()) {
|
||||
throw Exception("キューが空です");
|
||||
}
|
||||
return _nums[_front];
|
||||
}
|
||||
|
||||
/* Array を返す */
|
||||
List<int> toArray() {
|
||||
// 有効長の範囲内のリスト要素のみを変換
|
||||
final List<int> res = List.filled(_queSize, 0);
|
||||
for (int i = 0, j = _front; i < _queSize; i++, j++) {
|
||||
res[i] = _nums[j % capaCity()];
|
||||
}
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* キューを初期化 */
|
||||
final int capacity = 10;
|
||||
final ArrayQueue queue = ArrayQueue(capacity);
|
||||
|
||||
/* 要素をエンキュー */
|
||||
queue.push(1);
|
||||
queue.push(3);
|
||||
queue.push(2);
|
||||
queue.push(5);
|
||||
queue.push(4);
|
||||
print("キュー queue = ${queue.toArray()}");
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
final int peek = queue.peek();
|
||||
print("先頭要素 peek = $peek");
|
||||
|
||||
/* 要素をデキュー */
|
||||
final int pop = queue.pop();
|
||||
print("デキューした要素 pop = $pop ，デキュー後の queue = ${queue.toArray()}");
|
||||
|
||||
/* キューの長さを取得 */
|
||||
final int size = queue.size();
|
||||
print("キューの長さ size = $size");
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
final bool isEmpty = queue.isEmpty();
|
||||
print("キューが空かどうか = $isEmpty");
|
||||
|
||||
/* 循環配列をテストする */
|
||||
for (int i = 0; i < 10; i++) {
|
||||
queue.push(i);
|
||||
queue.pop();
|
||||
print("$i 回目のエンキュー + デキュー後の queue = ${queue.toArray()}");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
/**
|
||||
* File: array_stack.dart
|
||||
* Created Time: 2023-03-28
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 配列ベースのスタック */
|
||||
class ArrayStack {
|
||||
late List<int> _stack;
|
||||
ArrayStack() {
|
||||
_stack = [];
|
||||
}
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
int size() {
|
||||
return _stack.length;
|
||||
}
|
||||
|
||||
/* スタックが空かどうかを判定 */
|
||||
bool isEmpty() {
|
||||
return _stack.isEmpty;
|
||||
}
|
||||
|
||||
/* プッシュ */
|
||||
void push(int _num) {
|
||||
_stack.add(_num);
|
||||
}
|
||||
|
||||
/* ポップ */
|
||||
int pop() {
|
||||
if (isEmpty()) {
|
||||
throw Exception("スタックが空です");
|
||||
}
|
||||
return _stack.removeLast();
|
||||
}
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
int peek() {
|
||||
if (isEmpty()) {
|
||||
throw Exception("スタックが空です");
|
||||
}
|
||||
return _stack.last;
|
||||
}
|
||||
|
||||
/* スタックを Array に変換して返す */
|
||||
List<int> toArray() => _stack;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* スタックを初期化 */
|
||||
final ArrayStack stack = ArrayStack();
|
||||
|
||||
/* 要素をプッシュ */
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
print("スタック stack = ${stack.toArray()}");
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
final int peek = stack.peek();
|
||||
print("スタックトップの要素 peek = $peek");
|
||||
|
||||
/* 要素をポップ */
|
||||
final int pop = stack.pop();
|
||||
print("ポップした要素 pop = $pop ，ポップ後の stack = ${stack.toArray()}");
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
final int size = stack.size();
|
||||
print("スタックの長さ size = $size");
|
||||
|
||||
/* 空かどうかを判定 */
|
||||
final bool isEmpty = stack.isEmpty();
|
||||
print("スタックが空かどうか = $isEmpty");
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
/**
|
||||
* File: deque.dart
|
||||
* Created Time: 2023-03-28
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:collection';
|
||||
|
||||
void main() {
|
||||
/* 両端キューを初期化 */
|
||||
final Queue<int> deque = Queue();
|
||||
deque.addFirst(3);
|
||||
deque.addLast(2);
|
||||
deque.addLast(5);
|
||||
print("両端キュー deque = $deque");
|
||||
|
||||
/* 要素にアクセス */
|
||||
final int peekFirst = deque.first;
|
||||
print("先頭要素 peekFirst = $peekFirst");
|
||||
final int peekLast = deque.last;
|
||||
print("末尾要素 peekLast = $peekLast");
|
||||
|
||||
/* 要素をエンキュー */
|
||||
deque.addLast(4);
|
||||
print("要素 4 を末尾にエンキューした後の deque = $deque");
|
||||
deque.addFirst(1);
|
||||
print("要素 1 を先頭にエンキューした後の deque = $deque");
|
||||
|
||||
/* 要素をデキュー */
|
||||
final int popLast = deque.removeLast();
|
||||
print("末尾からデキューした要素 = $popLast ，末尾からデキュー後の deque = $deque");
|
||||
final int popFirst = deque.removeFirst();
|
||||
print("先頭からデキューした要素 = $popFirst ，先頭からデキュー後の deque = $deque");
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
final int size = deque.length;
|
||||
print("両端キューの長さ size = $size");
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
final bool isEmpty = deque.isEmpty;
|
||||
print("両端キューが空かどうか = $isEmpty");
|
||||
}
|
||||
@@ -0,0 +1,167 @@
|
||||
/**
|
||||
* File: linkedlist_deque.dart
|
||||
* Created Time: 2023-03-28
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 双方向連結リストノード */
|
||||
class ListNode {
|
||||
int val; // ノード値
|
||||
ListNode? next; // 後続ノードへの参照
|
||||
ListNode? prev; // 前駆ノードへの参照
|
||||
|
||||
ListNode(this.val, {this.next, this.prev});
|
||||
}
|
||||
|
||||
/* 双方向連結リストに基づく双方向キュー */
|
||||
class LinkedListDeque {
|
||||
late ListNode? _front; // 先頭ノード _front
|
||||
late ListNode? _rear; // 末尾ノード _rear
|
||||
int _queSize = 0; // 両端キューの長さ
|
||||
|
||||
LinkedListDeque() {
|
||||
this._front = null;
|
||||
this._rear = null;
|
||||
}
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
int size() {
|
||||
return this._queSize;
|
||||
}
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
bool isEmpty() {
|
||||
return size() == 0;
|
||||
}
|
||||
|
||||
/* エンキュー操作 */
|
||||
void push(int _num, bool isFront) {
|
||||
final ListNode node = ListNode(_num);
|
||||
if (isEmpty()) {
|
||||
// 連結リストが空なら、`_front` と `_rear` の両方を `node` に向ける
|
||||
_front = _rear = node;
|
||||
} else if (isFront) {
|
||||
// 先頭へのエンキュー操作
|
||||
// node を連結リストの先頭に追加する
|
||||
_front!.prev = node;
|
||||
node.next = _front;
|
||||
_front = node; // 先頭ノードを更新する
|
||||
} else {
|
||||
// 末尾へのエンキュー操作
|
||||
// node を連結リストの末尾に追加する
|
||||
_rear!.next = node;
|
||||
node.prev = _rear;
|
||||
_rear = node; // 末尾ノードを更新する
|
||||
}
|
||||
_queSize++; // キューの長さを更新
|
||||
}
|
||||
|
||||
/* キュー先頭にエンキュー */
|
||||
void pushFirst(int _num) {
|
||||
push(_num, true);
|
||||
}
|
||||
|
||||
/* キュー末尾にエンキュー */
|
||||
void pushLast(int _num) {
|
||||
push(_num, false);
|
||||
}
|
||||
|
||||
/* デキュー操作 */
|
||||
int? pop(bool isFront) {
|
||||
// キューが空なら、そのまま `null` を返す
|
||||
if (isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
final int val;
|
||||
if (isFront) {
|
||||
// キュー先頭からの取り出し
|
||||
val = _front!.val; // 先頭ノードの値を一時保存
|
||||
// 先頭ノードを削除
|
||||
ListNode? fNext = _front!.next;
|
||||
if (fNext != null) {
|
||||
fNext.prev = null;
|
||||
_front!.next = null;
|
||||
}
|
||||
_front = fNext; // 先頭ノードを更新する
|
||||
} else {
|
||||
// キュー末尾からの取り出し
|
||||
val = _rear!.val; // 末尾ノードの値を一時保存
|
||||
// 末尾ノードを削除
|
||||
ListNode? rPrev = _rear!.prev;
|
||||
if (rPrev != null) {
|
||||
rPrev.next = null;
|
||||
_rear!.prev = null;
|
||||
}
|
||||
_rear = rPrev; // 末尾ノードを更新する
|
||||
}
|
||||
_queSize--; // キューの長さを更新
|
||||
return val;
|
||||
}
|
||||
|
||||
/* キュー先頭からデキュー */
|
||||
int? popFirst() {
|
||||
return pop(true);
|
||||
}
|
||||
|
||||
/* キュー末尾からデキュー */
|
||||
int? popLast() {
|
||||
return pop(false);
|
||||
}
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
int? peekFirst() {
|
||||
return _front?.val;
|
||||
}
|
||||
|
||||
/* キュー末尾の要素にアクセス */
|
||||
int? peekLast() {
|
||||
return _rear?.val;
|
||||
}
|
||||
|
||||
/* 出力用の配列を返す */
|
||||
List<int> toArray() {
|
||||
ListNode? node = _front;
|
||||
final List<int> res = [];
|
||||
for (int i = 0; i < _queSize; i++) {
|
||||
res.add(node!.val);
|
||||
node = node.next;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* 両端キューを初期化 */
|
||||
final LinkedListDeque deque = LinkedListDeque();
|
||||
deque.pushLast(3);
|
||||
deque.pushLast(2);
|
||||
deque.pushLast(5);
|
||||
print("両端キュー deque = ${deque.toArray()}");
|
||||
|
||||
/* 要素にアクセス */
|
||||
int? peekFirst = deque.peekFirst();
|
||||
print("先頭要素 peekFirst = $peekFirst");
|
||||
int? peekLast = deque.peekLast();
|
||||
print("末尾要素 peekLast = $peekLast");
|
||||
|
||||
/* 要素をエンキュー */
|
||||
deque.pushLast(4);
|
||||
print("要素 4 を末尾に追加した後 deque = ${deque.toArray()}");
|
||||
deque.pushFirst(1);
|
||||
print("要素 1 を先頭に追加した後 deque = ${deque.toArray()}");
|
||||
|
||||
/* 要素をデキュー */
|
||||
int? popLast = deque.popLast();
|
||||
print("末尾から取り出した要素 = $popLast ，末尾から取り出した後 deque = ${deque.toArray()}");
|
||||
int? popFirst = deque.popFirst();
|
||||
print("先頭から取り出した要素 = $popFirst ，先頭から取り出した後 deque = ${deque.toArray()}");
|
||||
|
||||
/* 両端キューの長さを取得 */
|
||||
int size = deque.size();
|
||||
print("両端キューの長さ size = $size");
|
||||
|
||||
/* 両端キューが空かどうかを判定 */
|
||||
bool isEmpty = deque.isEmpty();
|
||||
print("両端キューが空かどうか = $isEmpty");
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
/**
|
||||
* File: linkedlist_queue.dart
|
||||
* Created Time: 2023-03-28
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/list_node.dart';
|
||||
|
||||
/* 連結リストベースのキュー */
|
||||
class LinkedListQueue {
|
||||
ListNode? _front; // 先頭ノード _front
|
||||
ListNode? _rear; // 末尾ノード _rear
|
||||
int _queSize = 0; // キューの長さ
|
||||
|
||||
LinkedListQueue() {
|
||||
_front = null;
|
||||
_rear = null;
|
||||
}
|
||||
|
||||
/* キューの長さを取得 */
|
||||
int size() {
|
||||
return _queSize;
|
||||
}
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
bool isEmpty() {
|
||||
return _queSize == 0;
|
||||
}
|
||||
|
||||
/* エンキュー */
|
||||
void push(int _num) {
|
||||
// 末尾ノードの後ろに _num を追加
|
||||
final node = ListNode(_num);
|
||||
// キューが空なら、先頭・末尾ノードをともにそのノードに設定
|
||||
if (_front == null) {
|
||||
_front = node;
|
||||
_rear = node;
|
||||
} else {
|
||||
// キューが空でなければ、そのノードを末尾ノードの後ろに追加
|
||||
_rear!.next = node;
|
||||
_rear = node;
|
||||
}
|
||||
_queSize++;
|
||||
}
|
||||
|
||||
/* デキュー */
|
||||
int pop() {
|
||||
final int _num = peek();
|
||||
// 先頭ノードを削除
|
||||
_front = _front!.next;
|
||||
_queSize--;
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
int peek() {
|
||||
if (_queSize == 0) {
|
||||
throw Exception('キューが空です');
|
||||
}
|
||||
return _front!.val;
|
||||
}
|
||||
|
||||
/* 連結リストを Array に変換して返す */
|
||||
List<int> toArray() {
|
||||
ListNode? node = _front;
|
||||
final List<int> queue = [];
|
||||
while (node != null) {
|
||||
queue.add(node.val);
|
||||
node = node.next;
|
||||
}
|
||||
return queue;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* キューを初期化 */
|
||||
final queue = LinkedListQueue();
|
||||
|
||||
/* 要素をエンキュー */
|
||||
queue.push(1);
|
||||
queue.push(3);
|
||||
queue.push(2);
|
||||
queue.push(5);
|
||||
queue.push(4);
|
||||
print("キュー queue = ${queue.toArray()}");
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
final int peek = queue.peek();
|
||||
print("先頭要素 peek = $peek");
|
||||
|
||||
/* 要素をデキュー */
|
||||
final int pop = queue.pop();
|
||||
print("デキューした要素 pop = $pop ，デキュー後の queue = ${queue.toArray()}");
|
||||
|
||||
/* キューの長さを取得 */
|
||||
final int size = queue.size();
|
||||
print("キューの長さ size = $size");
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
final bool isEmpty = queue.isEmpty();
|
||||
print("キューが空かどうか = $isEmpty");
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
/**
|
||||
* File: linkedlist_stack.dart
|
||||
* Created Time: 2023-03-27
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/list_node.dart';
|
||||
|
||||
/* 連結リストクラスに基づくスタック */
|
||||
class LinkedListStack {
|
||||
ListNode? _stackPeek; // 先頭ノードをスタックトップとする
|
||||
int _stkSize = 0; // スタックの長さ
|
||||
|
||||
LinkedListStack() {
|
||||
_stackPeek = null;
|
||||
}
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
int size() {
|
||||
return _stkSize;
|
||||
}
|
||||
|
||||
/* スタックが空かどうかを判定 */
|
||||
bool isEmpty() {
|
||||
return _stkSize == 0;
|
||||
}
|
||||
|
||||
/* プッシュ */
|
||||
void push(int _num) {
|
||||
final ListNode node = ListNode(_num);
|
||||
node.next = _stackPeek;
|
||||
_stackPeek = node;
|
||||
_stkSize++;
|
||||
}
|
||||
|
||||
/* ポップ */
|
||||
int pop() {
|
||||
final int _num = peek();
|
||||
_stackPeek = _stackPeek!.next;
|
||||
_stkSize--;
|
||||
return _num;
|
||||
}
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
int peek() {
|
||||
if (_stackPeek == null) {
|
||||
throw Exception("スタックが空です");
|
||||
}
|
||||
return _stackPeek!.val;
|
||||
}
|
||||
|
||||
/* 連結リストを List に変換して返す */
|
||||
List<int> toList() {
|
||||
ListNode? node = _stackPeek;
|
||||
List<int> list = [];
|
||||
while (node != null) {
|
||||
list.add(node.val);
|
||||
node = node.next;
|
||||
}
|
||||
list = list.reversed.toList();
|
||||
return list;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* スタックを初期化 */
|
||||
final LinkedListStack stack = LinkedListStack();
|
||||
|
||||
/* 要素をプッシュ */
|
||||
stack.push(1);
|
||||
stack.push(3);
|
||||
stack.push(2);
|
||||
stack.push(5);
|
||||
stack.push(4);
|
||||
print("スタック stack = ${stack.toList()}");
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
final int peek = stack.peek();
|
||||
print("スタックトップの要素 peek = $peek");
|
||||
|
||||
/* 要素をポップ */
|
||||
final int pop = stack.pop();
|
||||
print("ポップした要素 pop = $pop ，ポップ後の stack = ${stack.toList()}");
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
final int size = stack.size();
|
||||
print("スタックの長さ size = $size");
|
||||
|
||||
/* 空かどうかを判定 */
|
||||
final bool isEmpty = stack.isEmpty();
|
||||
print("スタックが空かどうか = $isEmpty");
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* File: queue.dart
|
||||
* Created Time: 2023-03-28
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:collection';
|
||||
|
||||
void main() {
|
||||
/* キューを初期化 */
|
||||
// Dart では、通常は両端キュー Queue をキューとして使う
|
||||
final Queue<int> queue = Queue();
|
||||
|
||||
/* 要素をエンキュー */
|
||||
queue.add(1);
|
||||
queue.add(3);
|
||||
queue.add(2);
|
||||
queue.add(5);
|
||||
queue.add(4);
|
||||
print("キュー queue = $queue");
|
||||
|
||||
/* キュー先頭の要素にアクセス */
|
||||
final int peek = queue.first;
|
||||
print("先頭要素 peek = $peek");
|
||||
|
||||
/* 要素をデキュー */
|
||||
final int pop = queue.removeFirst();
|
||||
print("デキューした要素 pop = $pop ，デキュー後の queue = $queue");
|
||||
|
||||
/* キューの長さを取得 */
|
||||
final int size = queue.length;
|
||||
print("キューの長さ size = $size");
|
||||
|
||||
/* キューが空かどうかを判定 */
|
||||
final bool isEmpty = queue.isEmpty;
|
||||
print("キューが空かどうか = $isEmpty");
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
/**
|
||||
* File: stack.dart
|
||||
* Created Time: 2023-03-27
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
void main() {
|
||||
/* スタックを初期化 */
|
||||
// Dart には組み込みのスタッククラスがないため、List をスタックとして使える
|
||||
final List<int> stack = [];
|
||||
|
||||
/* 要素をプッシュ */
|
||||
stack.add(1);
|
||||
stack.add(3);
|
||||
stack.add(2);
|
||||
stack.add(5);
|
||||
stack.add(4);
|
||||
print("スタック stack = $stack");
|
||||
|
||||
/* スタックトップの要素にアクセス */
|
||||
final int peek = stack.last;
|
||||
print("スタックトップの要素 peek = $peek");
|
||||
|
||||
/* 要素をポップ */
|
||||
final int pop = stack.removeLast();
|
||||
print("ポップした要素 pop = $pop ，ポップ後の stack = $stack");
|
||||
|
||||
/* スタックの長さを取得 */
|
||||
final int size = stack.length;
|
||||
print("スタックの長さ size = $size");
|
||||
|
||||
/* 空かどうかを判定 */
|
||||
final bool isEmpty = stack.isEmpty;
|
||||
print("スタックが空かどうか = $isEmpty");
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
/**
|
||||
* File: array_binary_tree.dart
|
||||
* Created Time: 2023-08-15
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
/* 配列表現による二分木クラス */
|
||||
class ArrayBinaryTree {
|
||||
late List<int?> _tree;
|
||||
|
||||
/* コンストラクタ */
|
||||
ArrayBinaryTree(this._tree);
|
||||
|
||||
/* リスト容量 */
|
||||
int size() {
|
||||
return _tree.length;
|
||||
}
|
||||
|
||||
/* インデックス i のノードの値を取得 */
|
||||
int? val(int i) {
|
||||
// インデックスが範囲外なら、空きを表す null を返す
|
||||
if (i < 0 || i >= size()) {
|
||||
return null;
|
||||
}
|
||||
return _tree[i];
|
||||
}
|
||||
|
||||
/* インデックス i のノードの左子ノードのインデックスを取得 */
|
||||
int? left(int i) {
|
||||
return 2 * i + 1;
|
||||
}
|
||||
|
||||
/* インデックス i のノードの右子ノードのインデックスを取得 */
|
||||
int? right(int i) {
|
||||
return 2 * i + 2;
|
||||
}
|
||||
|
||||
/* インデックス i のノードの親ノードのインデックスを取得 */
|
||||
int? parent(int i) {
|
||||
return (i - 1) ~/ 2;
|
||||
}
|
||||
|
||||
/* レベル順走査 */
|
||||
List<int> levelOrder() {
|
||||
List<int> res = [];
|
||||
for (int i = 0; i < size(); i++) {
|
||||
if (val(i) != null) {
|
||||
res.add(val(i)!);
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 深さ優先探索 */
|
||||
void dfs(int i, String order, List<int?> res) {
|
||||
// 空きスロットなら返す
|
||||
if (val(i) == null) {
|
||||
return;
|
||||
}
|
||||
// 先行順走査
|
||||
if (order == 'pre') {
|
||||
res.add(val(i));
|
||||
}
|
||||
dfs(left(i)!, order, res);
|
||||
// 中順走査
|
||||
if (order == 'in') {
|
||||
res.add(val(i));
|
||||
}
|
||||
dfs(right(i)!, order, res);
|
||||
// 後順走査
|
||||
if (order == 'post') {
|
||||
res.add(val(i));
|
||||
}
|
||||
}
|
||||
|
||||
/* 先行順走査 */
|
||||
List<int?> preOrder() {
|
||||
List<int?> res = [];
|
||||
dfs(0, 'pre', res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 中順走査 */
|
||||
List<int?> inOrder() {
|
||||
List<int?> res = [];
|
||||
dfs(0, 'in', res);
|
||||
return res;
|
||||
}
|
||||
|
||||
/* 後順走査 */
|
||||
List<int?> postOrder() {
|
||||
List<int?> res = [];
|
||||
dfs(0, 'post', res);
|
||||
return res;
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
// 二分木を初期化
|
||||
// ここでは、配列から直接二分木を生成する関数を利用する
|
||||
List<int?> arr = [
|
||||
1,
|
||||
2,
|
||||
3,
|
||||
4,
|
||||
null,
|
||||
6,
|
||||
7,
|
||||
8,
|
||||
9,
|
||||
null,
|
||||
null,
|
||||
12,
|
||||
null,
|
||||
null,
|
||||
15
|
||||
];
|
||||
|
||||
TreeNode? root = listToTree(arr);
|
||||
print("\n二分木を初期化\n");
|
||||
print("二分木の配列表現：");
|
||||
print(arr);
|
||||
print("二分木の連結リスト表現：");
|
||||
printTree(root);
|
||||
|
||||
// 配列表現による二分木クラス
|
||||
ArrayBinaryTree abt = ArrayBinaryTree(arr);
|
||||
|
||||
// ノードにアクセス
|
||||
int i = 1;
|
||||
int? l = abt.left(i);
|
||||
int? r = abt.right(i);
|
||||
int? p = abt.parent(i);
|
||||
print("\n現在のノードのインデックスは $i ，値は ${abt.val(i)}");
|
||||
print("その左子ノードのインデックスは $l ，値は ${(l == null ? "null" : abt.val(l))}");
|
||||
print("その右子ノードのインデックスは $r ，値は ${(r == null ? "null" : abt.val(r))}");
|
||||
print("その親ノードのインデックスは $p ，値は ${(p == null ? "null" : abt.val(p))}");
|
||||
|
||||
// 木を走査
|
||||
List<int?> res = abt.levelOrder();
|
||||
print("\nレベル順走査：$res");
|
||||
res = abt.preOrder();
|
||||
print("先行順走査は $res");
|
||||
res = abt.inOrder();
|
||||
print("中間順走査は $res");
|
||||
res = abt.postOrder();
|
||||
print("後行順走査は $res");
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
/**
|
||||
* File: avl_tree.dart
|
||||
* Created Time: 2023-04-04
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:math';
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
class AVLTree {
|
||||
TreeNode? root;
|
||||
|
||||
/* コンストラクタ */
|
||||
AVLTree() {
|
||||
root = null;
|
||||
}
|
||||
|
||||
/* ノードの高さを取得 */
|
||||
int height(TreeNode? node) {
|
||||
// 空ノードの高さは -1、葉ノードの高さは 0
|
||||
return node == null ? -1 : node.height;
|
||||
}
|
||||
|
||||
/* ノードの高さを更新する */
|
||||
void updateHeight(TreeNode? node) {
|
||||
// ノードの高さは最も高い部分木の高さ + 1 に等しい
|
||||
node!.height = max(height(node.left), height(node.right)) + 1;
|
||||
}
|
||||
|
||||
/* 平衡係数を取得 */
|
||||
int balanceFactor(TreeNode? node) {
|
||||
// 空ノードの平衡係数は 0
|
||||
if (node == null) return 0;
|
||||
// ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ
|
||||
return height(node.left) - height(node.right);
|
||||
}
|
||||
|
||||
/* 右回転 */
|
||||
TreeNode? rightRotate(TreeNode? node) {
|
||||
TreeNode? child = node!.left;
|
||||
TreeNode? grandChild = child!.right;
|
||||
// child を支点として node を右回転させる
|
||||
child.right = node;
|
||||
node.left = grandChild;
|
||||
// ノードの高さを更新する
|
||||
updateHeight(node);
|
||||
updateHeight(child);
|
||||
// 回転後の部分木の根ノードを返す
|
||||
return child;
|
||||
}
|
||||
|
||||
/* 左回転 */
|
||||
TreeNode? leftRotate(TreeNode? node) {
|
||||
TreeNode? child = node!.right;
|
||||
TreeNode? grandChild = child!.left;
|
||||
// child を支点として node を左回転させる
|
||||
child.left = node;
|
||||
node.right = grandChild;
|
||||
// ノードの高さを更新する
|
||||
updateHeight(node);
|
||||
updateHeight(child);
|
||||
// 回転後の部分木の根ノードを返す
|
||||
return child;
|
||||
}
|
||||
|
||||
/* 回転操作を行い、この部分木の平衡を回復する */
|
||||
TreeNode? rotate(TreeNode? node) {
|
||||
// ノード node の平衡係数を取得
|
||||
int factor = balanceFactor(node);
|
||||
// 左に偏った木
|
||||
if (factor > 1) {
|
||||
if (balanceFactor(node!.left) >= 0) {
|
||||
// 右回転
|
||||
return rightRotate(node);
|
||||
} else {
|
||||
// 左回転してから右回転
|
||||
node.left = leftRotate(node.left);
|
||||
return rightRotate(node);
|
||||
}
|
||||
}
|
||||
// 右に偏った木
|
||||
if (factor < -1) {
|
||||
if (balanceFactor(node!.right) <= 0) {
|
||||
// 左回転
|
||||
return leftRotate(node);
|
||||
} else {
|
||||
// 右回転してから左回転
|
||||
node.right = rightRotate(node.right);
|
||||
return leftRotate(node);
|
||||
}
|
||||
}
|
||||
// 平衡木なので回転不要、そのまま返す
|
||||
return node;
|
||||
}
|
||||
|
||||
/* ノードを挿入 */
|
||||
void insert(int val) {
|
||||
root = insertHelper(root, val);
|
||||
}
|
||||
|
||||
/* ノードを再帰的に挿入する（補助メソッド） */
|
||||
TreeNode? insertHelper(TreeNode? node, int val) {
|
||||
if (node == null) return TreeNode(val);
|
||||
/* 1. 挿入位置を探索してノードを挿入 */
|
||||
if (val < node.val)
|
||||
node.left = insertHelper(node.left, val);
|
||||
else if (val > node.val)
|
||||
node.right = insertHelper(node.right, val);
|
||||
else
|
||||
return node; // 重複ノードは挿入せず、そのまま返す
|
||||
updateHeight(node); // ノードの高さを更新する
|
||||
/* 2. 回転操作を行い、部分木の平衡を回復する */
|
||||
node = rotate(node);
|
||||
// 部分木の根ノードを返す
|
||||
return node;
|
||||
}
|
||||
|
||||
/* ノードを削除 */
|
||||
void remove(int val) {
|
||||
root = removeHelper(root, val);
|
||||
}
|
||||
|
||||
/* ノードを再帰的に削除する（補助メソッド） */
|
||||
TreeNode? removeHelper(TreeNode? node, int val) {
|
||||
if (node == null) return null;
|
||||
/* 1. ノードを探索して削除 */
|
||||
if (val < node.val)
|
||||
node.left = removeHelper(node.left, val);
|
||||
else if (val > node.val)
|
||||
node.right = removeHelper(node.right, val);
|
||||
else {
|
||||
if (node.left == null || node.right == null) {
|
||||
TreeNode? child = node.left ?? node.right;
|
||||
// 子ノード数 = 0 の場合、node をそのまま削除して返す
|
||||
if (child == null)
|
||||
return null;
|
||||
// 子ノード数 = 1 の場合、node をそのまま削除する
|
||||
else
|
||||
node = child;
|
||||
} else {
|
||||
// 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
|
||||
TreeNode? temp = node.right;
|
||||
while (temp!.left != null) {
|
||||
temp = temp.left;
|
||||
}
|
||||
node.right = removeHelper(node.right, temp.val);
|
||||
node.val = temp.val;
|
||||
}
|
||||
}
|
||||
updateHeight(node); // ノードの高さを更新する
|
||||
/* 2. 回転操作を行い、部分木の平衡を回復する */
|
||||
node = rotate(node);
|
||||
// 部分木の根ノードを返す
|
||||
return node;
|
||||
}
|
||||
|
||||
/* ノードを探索 */
|
||||
TreeNode? search(int val) {
|
||||
TreeNode? cur = root;
|
||||
// ループで探索し、葉ノードを越えたら抜ける
|
||||
while (cur != null) {
|
||||
// 目標ノードは cur の右部分木にある
|
||||
if (val < cur.val)
|
||||
cur = cur.left;
|
||||
// 目標ノードは cur の左部分木にある
|
||||
else if (val > cur.val)
|
||||
cur = cur.right;
|
||||
// 対象ノードが現在のノードと等しい
|
||||
else
|
||||
break;
|
||||
}
|
||||
return cur;
|
||||
}
|
||||
}
|
||||
|
||||
void testInsert(AVLTree tree, int val) {
|
||||
tree.insert(val);
|
||||
print("\nノード $val を挿入後、AVL 木は");
|
||||
printTree(tree.root);
|
||||
}
|
||||
|
||||
void testRemove(AVLTree tree, int val) {
|
||||
tree.remove(val);
|
||||
print("\nノード $val を削除後、AVL 木は");
|
||||
printTree(tree.root);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* 空の AVL 木を初期化する */
|
||||
AVLTree avlTree = 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 のノードを削除する
|
||||
|
||||
/* ノードを検索 */
|
||||
TreeNode? node = avlTree.search(7);
|
||||
print("\n見つかったノードオブジェクトは $node ，ノードの値 = ${node!.val}");
|
||||
}
|
||||
@@ -0,0 +1,153 @@
|
||||
/**
|
||||
* File: binary_search_tree.dart
|
||||
* Created Time: 2023-04-04
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
/* 二分探索木 */
|
||||
class BinarySearchTree {
|
||||
late TreeNode? _root;
|
||||
|
||||
/* コンストラクタ */
|
||||
BinarySearchTree() {
|
||||
// 空の木を初期化する
|
||||
_root = null;
|
||||
}
|
||||
|
||||
/* 二分木の根ノードを取得する */
|
||||
TreeNode? getRoot() {
|
||||
return _root;
|
||||
}
|
||||
|
||||
/* ノードを探索 */
|
||||
TreeNode? search(int _num) {
|
||||
TreeNode? cur = _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;
|
||||
}
|
||||
|
||||
/* ノードを挿入 */
|
||||
void insert(int _num) {
|
||||
// 木が空なら、根ノードを初期化する
|
||||
if (_root == null) {
|
||||
_root = TreeNode(_num);
|
||||
return;
|
||||
}
|
||||
TreeNode? cur = _root;
|
||||
TreeNode? pre = null;
|
||||
// ループで探索し、葉ノードを越えたら抜ける
|
||||
while (cur != null) {
|
||||
// 重複ノードが見つかったら、直ちに返す
|
||||
if (cur.val == _num) return;
|
||||
pre = cur;
|
||||
// 挿入位置は cur の右部分木にある
|
||||
if (cur.val < _num)
|
||||
cur = cur.right;
|
||||
// 挿入位置は cur の左部分木にある
|
||||
else
|
||||
cur = cur.left;
|
||||
}
|
||||
// ノードを挿入
|
||||
TreeNode? node = TreeNode(_num);
|
||||
if (pre!.val < _num)
|
||||
pre.right = node;
|
||||
else
|
||||
pre.left = node;
|
||||
}
|
||||
|
||||
/* ノードを削除 */
|
||||
void remove(int _num) {
|
||||
// 木が空なら、そのまま早期リターンする
|
||||
if (_root == null) return;
|
||||
TreeNode? cur = _root;
|
||||
TreeNode? pre = 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 / その子ノード
|
||||
TreeNode? child = cur.left ?? cur.right;
|
||||
// ノード cur を削除する
|
||||
if (cur != _root) {
|
||||
if (pre!.left == cur)
|
||||
pre.left = child;
|
||||
else
|
||||
pre.right = child;
|
||||
} else {
|
||||
// 削除ノードが根ノードなら、根ノードを再設定
|
||||
_root = child;
|
||||
}
|
||||
} else {
|
||||
// 子ノード数 = 2
|
||||
// 中順走査における cur の次のノードを取得
|
||||
TreeNode? tmp = cur.right;
|
||||
while (tmp!.left != null) {
|
||||
tmp = tmp.left;
|
||||
}
|
||||
// ノード tmp を再帰的に削除
|
||||
remove(tmp.val);
|
||||
// tmp で cur を上書きする
|
||||
cur.val = tmp.val;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* 二分探索木を初期化 */
|
||||
BinarySearchTree bst = BinarySearchTree();
|
||||
// 注意：挿入順序が異なると異なる二分木が生成される。このシーケンスからは完全二分木を生成できる
|
||||
List<int> nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15];
|
||||
for (int _num in nums) {
|
||||
bst.insert(_num);
|
||||
}
|
||||
print("\n初期化した二分木は\n");
|
||||
printTree(bst.getRoot());
|
||||
|
||||
/* ノードを探索 */
|
||||
TreeNode? node = bst.search(7);
|
||||
print("\n見つかったノードオブジェクトは $node ，ノードの値 = ${node?.val}");
|
||||
|
||||
/* ノードを挿入 */
|
||||
bst.insert(16);
|
||||
print("\nノード 16 を挿入後、二分木は\n");
|
||||
printTree(bst.getRoot());
|
||||
|
||||
/* ノードを削除 */
|
||||
bst.remove(1);
|
||||
print("\nノード 1 を削除後、二分木は\n");
|
||||
printTree(bst.getRoot());
|
||||
bst.remove(2);
|
||||
print("\nノード 2 を削除後、二分木は\n");
|
||||
printTree(bst.getRoot());
|
||||
bst.remove(4);
|
||||
print("\nノード 4 を削除後、二分木は\n");
|
||||
printTree(bst.getRoot());
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
/**
|
||||
* File: binary_tree.dart
|
||||
* Created Time: 2023-04-03
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
void main() {
|
||||
/* 二分木を初期化 */
|
||||
// ノードをヒープ化
|
||||
TreeNode n1 = TreeNode(1);
|
||||
TreeNode n2 = TreeNode(2);
|
||||
TreeNode n3 = TreeNode(3);
|
||||
TreeNode n4 = TreeNode(4);
|
||||
TreeNode n5 = TreeNode(5);
|
||||
// ノード間の参照（ポインタ）を構築する
|
||||
n1.left = n2;
|
||||
n1.right = n3;
|
||||
n2.left = n4;
|
||||
n2.right = n5;
|
||||
print("\n二分木を初期化\n");
|
||||
printTree(n1);
|
||||
|
||||
/* ノードの挿入と削除 */
|
||||
TreeNode p = TreeNode(0);
|
||||
// n1 -> n2 の間にノード p を挿入する
|
||||
n1.left = p;
|
||||
p.left = n2;
|
||||
print("\nノード P を挿入後\n");
|
||||
printTree(n1);
|
||||
// ノード P を削除
|
||||
n1.left = n2;
|
||||
print("\nノード P を削除後\n");
|
||||
printTree(n1);
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
/**
|
||||
* File: binary_tree_bfs.dart
|
||||
* Created Time: 2023-04-03
|
||||
* Author: liuyuxin (gvenusleo@gmai.com)
|
||||
*/
|
||||
|
||||
import 'dart:collection';
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
/* レベル順走査 */
|
||||
List<int> levelOrder(TreeNode? root) {
|
||||
// キューを初期化し、ルートノードを追加する
|
||||
Queue<TreeNode?> queue = Queue();
|
||||
queue.add(root);
|
||||
// 走査順序を保存するためのリストを初期化する
|
||||
List<int> res = [];
|
||||
while (queue.isNotEmpty) {
|
||||
TreeNode? node = queue.removeFirst(); // デキュー
|
||||
res.add(node!.val); // ノードの値を保存する
|
||||
if (node.left != null) queue.add(node.left); // 左子ノードをキューに追加
|
||||
if (node.right != null) queue.add(node.right); // 右子ノードをキューに追加
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* 二分木を初期化 */
|
||||
// ここでは、配列から直接二分木を生成する関数を利用する
|
||||
TreeNode? root = listToTree([1, 2, 3, 4, 5, 6, 7]);
|
||||
print("\n二分木を初期化\n");
|
||||
printTree(root);
|
||||
|
||||
// レベル順走査
|
||||
List<int> res = levelOrder(root);
|
||||
print("\nレベル順走査のノード出力順 = $res");
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
/**
|
||||
* File: binary_tree_dfs.dart
|
||||
* Created Time: 2023-04-04
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
import '../utils/print_util.dart';
|
||||
import '../utils/tree_node.dart';
|
||||
|
||||
// 走査順序を格納するリストを初期化
|
||||
List<int> list = [];
|
||||
|
||||
/* 先行順走査 */
|
||||
void preOrder(TreeNode? node) {
|
||||
if (node == null) return;
|
||||
// 訪問順序：根ノード -> 左部分木 -> 右部分木
|
||||
list.add(node.val);
|
||||
preOrder(node.left);
|
||||
preOrder(node.right);
|
||||
}
|
||||
|
||||
/* 中順走査 */
|
||||
void inOrder(TreeNode? node) {
|
||||
if (node == null) return;
|
||||
// 訪問優先順: 左部分木 -> 根ノード -> 右部分木
|
||||
inOrder(node.left);
|
||||
list.add(node.val);
|
||||
inOrder(node.right);
|
||||
}
|
||||
|
||||
/* 後順走査 */
|
||||
void postOrder(TreeNode? node) {
|
||||
if (node == null) return;
|
||||
// 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
|
||||
postOrder(node.left);
|
||||
postOrder(node.right);
|
||||
list.add(node.val);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
void main() {
|
||||
/* 二分木を初期化 */
|
||||
// ここでは、配列から直接二分木を生成する関数を利用する
|
||||
TreeNode? root = listToTree([1, 2, 3, 4, 5, 6, 7]);
|
||||
print("\n二分木を初期化\n");
|
||||
printTree(root);
|
||||
|
||||
/* 先行順走査 */
|
||||
list.clear();
|
||||
preOrder(root);
|
||||
print("\n先行順走査のノード出力順 = $list");
|
||||
|
||||
/* 中順走査 */
|
||||
list.clear();
|
||||
inOrder(root);
|
||||
print("\n中間順走査のノード出力順 = $list");
|
||||
|
||||
/* 後順走査 */
|
||||
list.clear();
|
||||
postOrder(root);
|
||||
print("\n後行順走査のノード出力順 = $list");
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
/**
|
||||
* File: list_node.dart
|
||||
* Created Time: 2023-01-23
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
/* 連結リストノード */
|
||||
class ListNode {
|
||||
int val;
|
||||
ListNode? next;
|
||||
|
||||
ListNode(this.val, [this.next]);
|
||||
}
|
||||
|
||||
/* リストを連結リストにデシリアライズする */
|
||||
ListNode? listToLinkedList(List<int> list) {
|
||||
ListNode dum = ListNode(0);
|
||||
ListNode? head = dum;
|
||||
for (int val in list) {
|
||||
head?.next = ListNode(val);
|
||||
head = head?.next;
|
||||
}
|
||||
return dum.next;
|
||||
}
|
||||
@@ -0,0 +1,90 @@
|
||||
/**
|
||||
* File: print_util.dart
|
||||
* Created Time: 2023-01-23
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
import 'dart:io';
|
||||
|
||||
import 'list_node.dart';
|
||||
import 'tree_node.dart';
|
||||
|
||||
class Trunk {
|
||||
Trunk? prev;
|
||||
String str;
|
||||
|
||||
Trunk(this.prev, this.str);
|
||||
}
|
||||
|
||||
/* 行列を出力する (Array) */
|
||||
void printMatrix(List<List<int>> matrix) {
|
||||
print("[");
|
||||
for (List<int> row in matrix) {
|
||||
print(" $row,");
|
||||
}
|
||||
print("]");
|
||||
}
|
||||
|
||||
/* 連結リストを出力 */
|
||||
void printLinkedList(ListNode? head) {
|
||||
List<String> list = [];
|
||||
|
||||
while (head != null) {
|
||||
list.add('${head.val}');
|
||||
head = head.next;
|
||||
}
|
||||
|
||||
print(list.join(' -> '));
|
||||
}
|
||||
|
||||
/**
|
||||
* 二分木を出力
|
||||
* This tree printer is borrowed from TECHIE DELIGHT
|
||||
* https://www.techiedelight.com/c-program-print-binary-tree/
|
||||
*/
|
||||
void printTree(TreeNode? root, [Trunk? prev = null, bool isRight = false]) {
|
||||
if (root == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
String prev_str = ' ';
|
||||
Trunk trunk = Trunk(prev, prev_str);
|
||||
|
||||
printTree(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);
|
||||
print(' ${root.val}');
|
||||
|
||||
if (prev != null) {
|
||||
prev.str = prev_str;
|
||||
}
|
||||
trunk.str = ' |';
|
||||
|
||||
printTree(root.left, trunk, false);
|
||||
}
|
||||
|
||||
void showTrunks(Trunk? p) {
|
||||
if (p == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
showTrunks(p.prev);
|
||||
stdout.write(p.str);
|
||||
}
|
||||
|
||||
/* ヒープを出力 */
|
||||
void printHeap(List<int> heap) {
|
||||
print("ヒープの配列表現：$heap");
|
||||
print("ヒープの木構造表示：");
|
||||
TreeNode? root = listToTree(heap);
|
||||
printTree(root);
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
/**
|
||||
* File: tree_node.dart
|
||||
* Created Time: 2023-2-12
|
||||
* Author: Jefferson (JeffersonHuang77@gmail.com)
|
||||
*/
|
||||
|
||||
/* 二分木ノードクラス */
|
||||
class TreeNode {
|
||||
int val; // ノード値
|
||||
int height; // ノードの高さ
|
||||
TreeNode? left; // 左子ノードへの参照
|
||||
TreeNode? right; // 右子ノードへの参照
|
||||
|
||||
/* コンストラクタ */
|
||||
TreeNode(this.val, [this.height = 0, this.left, this.right]);
|
||||
}
|
||||
|
||||
/* リストを二分木にデシリアライズする: 再帰 */
|
||||
TreeNode? listToTreeDFS(List<int?> arr, int i) {
|
||||
if (i < 0 || i >= arr.length || arr[i] == null) {
|
||||
return null;
|
||||
}
|
||||
TreeNode? root = TreeNode(arr[i]!);
|
||||
root.left = listToTreeDFS(arr, 2 * i + 1);
|
||||
root.right = listToTreeDFS(arr, 2 * i + 2);
|
||||
return root;
|
||||
}
|
||||
|
||||
/* リストを二分木にデシリアライズする */
|
||||
TreeNode? listToTree(List<int?> arr) {
|
||||
return listToTreeDFS(arr, 0);
|
||||
}
|
||||
|
||||
/* 二分木をリストにシリアライズする: 再帰 */
|
||||
void treeToListDFS(TreeNode? root, int i, List<int?> res) {
|
||||
if (root == null) return;
|
||||
while (i >= res.length) {
|
||||
res.add(null);
|
||||
}
|
||||
res[i] = root.val;
|
||||
treeToListDFS(root.left, 2 * i + 1, res);
|
||||
treeToListDFS(root.right, 2 * i + 2, res);
|
||||
}
|
||||
|
||||
/* 二分木をリストにシリアライズする */
|
||||
List<int?> treeToList(TreeNode? root) {
|
||||
List<int?> res = [];
|
||||
treeToListDFS(root, 0, res);
|
||||
return res;
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
/**
|
||||
* File: Vertex.dart
|
||||
* Created Time: 2023-05-15
|
||||
* Author: liuyuxin (gvenusleo@gmail.com)
|
||||
*/
|
||||
|
||||
/* 頂点クラス */
|
||||
class Vertex {
|
||||
int val;
|
||||
Vertex(this.val);
|
||||
|
||||
/* 値リスト vals を入力し、頂点リスト vets を返す */
|
||||
static List<Vertex> valsToVets(List<int> vals) {
|
||||
List<Vertex> vets = [];
|
||||
for (int i in vals) {
|
||||
vets.add(Vertex(i));
|
||||
}
|
||||
return vets;
|
||||
}
|
||||
|
||||
/* 頂点リスト vets を入力し、値リスト vals を返す */
|
||||
static List<int> vetsToVals(List<Vertex> vets) {
|
||||
List<int> vals = [];
|
||||
for (Vertex vet in vets) {
|
||||
vals.add(vet.val);
|
||||
}
|
||||
return vals;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user