mirror of
https://github.com/krahets/hello-algo.git
synced 2026-06-15 14:48:05 +08: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
@@ -12,49 +12,49 @@ from modules import TreeNode, list_to_tree, print_tree
|
||||
|
||||
|
||||
class ArrayBinaryTree:
|
||||
"""配列ベースの二分木クラス"""
|
||||
"""配列表現による二分木クラス"""
|
||||
|
||||
def __init__(self, arr: list[int | None]):
|
||||
"""コンストラクタ"""
|
||||
self._tree = list(arr)
|
||||
|
||||
def size(self):
|
||||
"""リストの容量"""
|
||||
"""リスト容量"""
|
||||
return len(self._tree)
|
||||
|
||||
def val(self, i: int) -> int | None:
|
||||
"""インデックスiのノードの値を取得"""
|
||||
# インデックスが範囲外の場合、Noneを返し、空席を表す
|
||||
"""インデックス i のノードの値を取得"""
|
||||
# インデックスが範囲外なら、空きを表す None を返す
|
||||
if i < 0 or i >= self.size():
|
||||
return None
|
||||
return self._tree[i]
|
||||
|
||||
def left(self, i: int) -> int | None:
|
||||
"""インデックスiのノードの左の子のインデックスを取得"""
|
||||
"""インデックス i のノードの左子ノードのインデックスを取得"""
|
||||
return 2 * i + 1
|
||||
|
||||
def right(self, i: int) -> int | None:
|
||||
"""インデックスiのノードの右の子のインデックスを取得"""
|
||||
"""インデックス i のノードの右子ノードのインデックスを取得"""
|
||||
return 2 * i + 2
|
||||
|
||||
def parent(self, i: int) -> int | None:
|
||||
"""インデックスiのノードの親のインデックスを取得"""
|
||||
"""インデックス i のノードの親ノードのインデックスを取得"""
|
||||
return (i - 1) // 2
|
||||
|
||||
def level_order(self) -> list[int]:
|
||||
"""レベル順走査"""
|
||||
self.res = []
|
||||
# 配列を走査
|
||||
# 配列を直接走査する
|
||||
for i in range(self.size()):
|
||||
if self.val(i) is not None:
|
||||
self.res.append(self.val(i))
|
||||
return self.res
|
||||
|
||||
def dfs(self, i: int, order: str):
|
||||
"""深さ優先走査"""
|
||||
"""深さ優先探索"""
|
||||
if self.val(i) is None:
|
||||
return
|
||||
# 前順走査
|
||||
# 先行順走査
|
||||
if order == "pre":
|
||||
self.res.append(self.val(i))
|
||||
self.dfs(self.left(i), order)
|
||||
@@ -67,7 +67,7 @@ class ArrayBinaryTree:
|
||||
self.res.append(self.val(i))
|
||||
|
||||
def pre_order(self) -> list[int]:
|
||||
"""前順走査"""
|
||||
"""先行順走査"""
|
||||
self.res = []
|
||||
self.dfs(0, order="pre")
|
||||
return self.res
|
||||
@@ -85,35 +85,35 @@ class ArrayBinaryTree:
|
||||
return self.res
|
||||
|
||||
|
||||
"""ドライバコード"""
|
||||
"""Driver Code"""
|
||||
if __name__ == "__main__":
|
||||
# 二分木を初期化
|
||||
# 特定の関数を使用して配列を二分木に変換
|
||||
# ここでは、配列から直接二分木を生成する関数を利用する
|
||||
arr = [1, 2, 3, 4, None, 6, 7, 8, 9, None, None, 12, None, None, 15]
|
||||
root = list_to_tree(arr)
|
||||
print("\n二分木を初期化\n")
|
||||
print("二分木の配列表現:")
|
||||
print("二分木の配列表現：")
|
||||
print(arr)
|
||||
print("二分木の連結リスト表現:")
|
||||
print("二分木の連結リスト表現：")
|
||||
print_tree(root)
|
||||
|
||||
# 配列ベースの二分木クラス
|
||||
# 配列表現による二分木クラス
|
||||
abt = ArrayBinaryTree(arr)
|
||||
|
||||
# ノードにアクセス
|
||||
i = 1
|
||||
l, r, p = abt.left(i), abt.right(i), abt.parent(i)
|
||||
print(f"\n現在のノードのインデックスは {i}、値は {abt.val(i)}")
|
||||
print(f"その左の子ノードのインデックスは {l}、値は {abt.val(l)}")
|
||||
print(f"その右の子ノードのインデックスは {r}、値は {abt.val(r)}")
|
||||
print(f"その左子ノードのインデックスは {l}、値は {abt.val(l)}")
|
||||
print(f"その右子ノードのインデックスは {r}、値は {abt.val(r)}")
|
||||
print(f"その親ノードのインデックスは {p}、値は {abt.val(p)}")
|
||||
|
||||
# 木を走査
|
||||
res = abt.level_order()
|
||||
print("\nレベル順走査:", res)
|
||||
print("\nレベル順走査：", res)
|
||||
res = abt.pre_order()
|
||||
print("前順走査:", res)
|
||||
print("先行順走査：", res)
|
||||
res = abt.in_order()
|
||||
print("中順走査:", res)
|
||||
print("中間順走査：", res)
|
||||
res = abt.post_order()
|
||||
print("後順走査:", res)
|
||||
print("後行順走査：", res)
|
||||
|
||||
@@ -12,67 +12,67 @@ from modules import TreeNode, print_tree
|
||||
|
||||
|
||||
class AVLTree:
|
||||
"""AVL木"""
|
||||
"""AVL 木"""
|
||||
|
||||
def __init__(self):
|
||||
"""コンストラクタ"""
|
||||
self._root = None
|
||||
|
||||
def get_root(self) -> TreeNode | None:
|
||||
"""二分木のルートノードを取得"""
|
||||
"""二分木の根ノードを取得"""
|
||||
return self._root
|
||||
|
||||
def height(self, node: TreeNode | None) -> int:
|
||||
"""ノードの高さを取得"""
|
||||
# 空ノードの高さは-1、葉ノードの高さは0
|
||||
# 空ノードの高さは -1、葉ノードの高さは 0
|
||||
if node is not None:
|
||||
return node.height
|
||||
return -1
|
||||
|
||||
def update_height(self, node: TreeNode | None):
|
||||
"""ノードの高さを更新"""
|
||||
# ノードの高さ = 最も高い部分木の高さ + 1
|
||||
"""ノードの高さを更新する"""
|
||||
# ノードの高さは最も高い部分木の高さ + 1 に等しい
|
||||
node.height = max([self.height(node.left), self.height(node.right)]) + 1
|
||||
|
||||
def balance_factor(self, node: TreeNode | None) -> int:
|
||||
"""バランス因子を取得"""
|
||||
# 空ノードのバランス因子は0
|
||||
"""平衡係数を取得"""
|
||||
# 空ノードの平衡係数は 0
|
||||
if node is None:
|
||||
return 0
|
||||
# ノードのバランス因子 = 左部分木の高さ - 右部分木の高さ
|
||||
# ノードの平衡係数 = 左部分木の高さ - 右部分木の高さ
|
||||
return self.height(node.left) - self.height(node.right)
|
||||
|
||||
def right_rotate(self, node: TreeNode | None) -> TreeNode | None:
|
||||
"""右回転操作"""
|
||||
"""右回転"""
|
||||
child = node.left
|
||||
grand_child = child.right
|
||||
# childを中心にnodeを右に回転
|
||||
# child を支点として node を右回転させる
|
||||
child.right = node
|
||||
node.left = grand_child
|
||||
# ノードの高さを更新
|
||||
# ノードの高さを更新する
|
||||
self.update_height(node)
|
||||
self.update_height(child)
|
||||
# 回転後の部分木のルートを返す
|
||||
# 回転後の部分木の根ノードを返す
|
||||
return child
|
||||
|
||||
def left_rotate(self, node: TreeNode | None) -> TreeNode | None:
|
||||
"""左回転操作"""
|
||||
"""左回転"""
|
||||
child = node.right
|
||||
grand_child = child.left
|
||||
# childを中心にnodeを左に回転
|
||||
# child を支点として node を左回転させる
|
||||
child.left = node
|
||||
node.right = grand_child
|
||||
# ノードの高さを更新
|
||||
# ノードの高さを更新する
|
||||
self.update_height(node)
|
||||
self.update_height(child)
|
||||
# 回転後の部分木のルートを返す
|
||||
# 回転後の部分木の根ノードを返す
|
||||
return child
|
||||
|
||||
def rotate(self, node: TreeNode | None) -> TreeNode | None:
|
||||
"""回転操作を実行して部分木のバランスを復元"""
|
||||
# nodeのバランス因子を取得
|
||||
"""回転操作を行い、この部分木の平衡を回復する"""
|
||||
# ノード node の平衡係数を取得
|
||||
balance_factor = self.balance_factor(node)
|
||||
# 左偏り木
|
||||
# 左に偏った木
|
||||
if balance_factor > 1:
|
||||
if self.balance_factor(node.left) >= 0:
|
||||
# 右回転
|
||||
@@ -81,7 +81,7 @@ class AVLTree:
|
||||
# 左回転してから右回転
|
||||
node.left = self.left_rotate(node.left)
|
||||
return self.right_rotate(node)
|
||||
# 右偏り木
|
||||
# 右に偏った木
|
||||
elif balance_factor < -1:
|
||||
if self.balance_factor(node.right) <= 0:
|
||||
# 左回転
|
||||
@@ -90,7 +90,7 @@ class AVLTree:
|
||||
# 右回転してから左回転
|
||||
node.right = self.right_rotate(node.right)
|
||||
return self.left_rotate(node)
|
||||
# バランスの取れた木、回転不要、戻る
|
||||
# 平衡木なので回転不要、そのまま返す
|
||||
return node
|
||||
|
||||
def insert(self, val):
|
||||
@@ -98,20 +98,20 @@ class AVLTree:
|
||||
self._root = self.insert_helper(self._root, val)
|
||||
|
||||
def insert_helper(self, node: TreeNode | None, val: int) -> TreeNode:
|
||||
"""再帰的にノードを挿入（ヘルパーメソッド）"""
|
||||
"""ノードを再帰的に挿入する（補助メソッド）"""
|
||||
if node is None:
|
||||
return TreeNode(val)
|
||||
# 1. 挿入位置を見つけてノードを挿入
|
||||
# 1. 挿入位置を探索してノードを挿入
|
||||
if val < node.val:
|
||||
node.left = self.insert_helper(node.left, val)
|
||||
elif val > node.val:
|
||||
node.right = self.insert_helper(node.right, val)
|
||||
else:
|
||||
# 重複ノードは挿入しない、戻る
|
||||
# 重複ノードは挿入せず、そのまま返す
|
||||
return node
|
||||
# ノードの高さを更新
|
||||
# ノードの高さを更新する
|
||||
self.update_height(node)
|
||||
# 2. 回転操作を実行して部分木のバランスを復元
|
||||
# 2. 回転操作を行い、部分木の平衡を回復する
|
||||
return self.rotate(node)
|
||||
|
||||
def remove(self, val: int):
|
||||
@@ -119,10 +119,10 @@ class AVLTree:
|
||||
self._root = self.remove_helper(self._root, val)
|
||||
|
||||
def remove_helper(self, node: TreeNode | None, val: int) -> TreeNode | None:
|
||||
"""再帰的にノードを削除（ヘルパーメソッド）"""
|
||||
"""ノードを再帰的に削除する（補助メソッド）"""
|
||||
if node is None:
|
||||
return None
|
||||
# 1. ノードを見つけて削除
|
||||
# 1. ノードを探索して削除
|
||||
if val < node.val:
|
||||
node.left = self.remove_helper(node.left, val)
|
||||
elif val > node.val:
|
||||
@@ -130,71 +130,71 @@ class AVLTree:
|
||||
else:
|
||||
if node.left is None or node.right is None:
|
||||
child = node.left or node.right
|
||||
# 子ノード数 = 0、ノードを削除して戻る
|
||||
# 子ノード数 = 0 の場合、node をそのまま削除して返す
|
||||
if child is None:
|
||||
return None
|
||||
# 子ノード数 = 1、ノードを削除
|
||||
# 子ノード数 = 1 の場合、node をそのまま削除する
|
||||
else:
|
||||
node = child
|
||||
else:
|
||||
# 子ノード数 = 2、中順走査の次のノードを削除し、それで現在のノードを置き換え
|
||||
# 子ノード数 = 2 の場合、中順走査の次のノードを削除し、そのノードで現在のノードを置き換える
|
||||
temp = node.right
|
||||
while temp.left is not None:
|
||||
temp = temp.left
|
||||
node.right = self.remove_helper(node.right, temp.val)
|
||||
node.val = temp.val
|
||||
# ノードの高さを更新
|
||||
# ノードの高さを更新する
|
||||
self.update_height(node)
|
||||
# 2. 回転操作を実行して部分木のバランスを復元
|
||||
# 2. 回転操作を行い、部分木の平衡を回復する
|
||||
return self.rotate(node)
|
||||
|
||||
def search(self, val: int) -> TreeNode | None:
|
||||
"""ノードを探索"""
|
||||
cur = self._root
|
||||
# ループで探索、葉ノードを通過した後にブレーク
|
||||
# ループで探索し、葉ノードを越えたら抜ける
|
||||
while cur is not None:
|
||||
# ターゲットノードはcurの右部分木にある
|
||||
# 目標ノードは cur の右部分木にある
|
||||
if cur.val < val:
|
||||
cur = cur.right
|
||||
# ターゲットノードはcurの左部分木にある
|
||||
# 目標ノードは cur の左部分木にある
|
||||
elif cur.val > val:
|
||||
cur = cur.left
|
||||
# ターゲットノードを発見、ループをブレーク
|
||||
# 目標ノードが見つかったらループを抜ける
|
||||
else:
|
||||
break
|
||||
# ターゲットノードを返す
|
||||
# 目標ノードを返す
|
||||
return cur
|
||||
|
||||
|
||||
"""ドライバコード"""
|
||||
"""Driver Code"""
|
||||
if __name__ == "__main__":
|
||||
|
||||
def test_insert(tree: AVLTree, val: int):
|
||||
tree.insert(val)
|
||||
print("\nノード {} を挿入後、AVL木は".format(val))
|
||||
print("\nノード {} を挿入した後、AVL 木は".format(val))
|
||||
print_tree(tree.get_root())
|
||||
|
||||
def test_remove(tree: AVLTree, val: int):
|
||||
tree.remove(val)
|
||||
print("\nノード {} を削除後、AVL木は".format(val))
|
||||
print("\nノード {} を削除した後、AVL 木は".format(val))
|
||||
print_tree(tree.get_root())
|
||||
|
||||
# 空のAVL木を初期化
|
||||
# 空の AVL 木を初期化する
|
||||
avl_tree = AVLTree()
|
||||
|
||||
# ノードを挿入
|
||||
# AVL木がノード挿入後にバランスを維持する様子に注目
|
||||
# ノードを挿入する
|
||||
# ノード挿入後に AVL 木がどのように平衡を保つかに注目
|
||||
for val in [1, 2, 3, 4, 5, 8, 7, 9, 10, 6]:
|
||||
test_insert(avl_tree, val)
|
||||
|
||||
# 重複ノードを挿入
|
||||
# 重複ノードを挿入する
|
||||
test_insert(avl_tree, 7)
|
||||
|
||||
# ノードを削除
|
||||
# AVL木がノード削除後にバランスを維持する様子に注目
|
||||
test_remove(avl_tree, 8) # 次数0のノードを削除
|
||||
test_remove(avl_tree, 5) # 次数1のノードを削除
|
||||
test_remove(avl_tree, 4) # 次数2のノードを削除
|
||||
# ノードを削除する
|
||||
# ノード削除後に AVL 木がどのように平衡を保つかに注目
|
||||
test_remove(avl_tree, 8) # 次数 0 のノードを削除する
|
||||
test_remove(avl_tree, 5) # 次数 1 のノードを削除する
|
||||
test_remove(avl_tree, 4) # 次数 2 のノードを削除する
|
||||
|
||||
result_node = avl_tree.search(7)
|
||||
print("\n発見されたノードオブジェクト: {}、ノードの値 = {}".format(result_node, result_node.val))
|
||||
print("\n見つかったノードオブジェクトは {}、ノードの値 = {}".format(result_node, result_node.val))
|
||||
|
||||
@@ -16,46 +16,46 @@ class BinarySearchTree:
|
||||
|
||||
def __init__(self):
|
||||
"""コンストラクタ"""
|
||||
# 空の木を初期化
|
||||
# 空の木を初期化する
|
||||
self._root = None
|
||||
|
||||
def get_root(self) -> TreeNode | None:
|
||||
"""二分木のルートノードを取得"""
|
||||
"""二分木の根ノードを取得"""
|
||||
return self._root
|
||||
|
||||
def search(self, num: int) -> TreeNode | None:
|
||||
"""ノードを探索"""
|
||||
cur = self._root
|
||||
# ループで探索、葉ノードを通過した後にブレーク
|
||||
# ループで探索し、葉ノードを越えたら抜ける
|
||||
while cur is not None:
|
||||
# ターゲットノードはcurの右部分木にある
|
||||
# 目標ノードは cur の右部分木にある
|
||||
if cur.val < num:
|
||||
cur = cur.right
|
||||
# ターゲットノードはcurの左部分木にある
|
||||
# 目標ノードは cur の左部分木にある
|
||||
elif cur.val > num:
|
||||
cur = cur.left
|
||||
# ターゲットノードを発見、ループをブレーク
|
||||
# 目標ノードが見つかったらループを抜ける
|
||||
else:
|
||||
break
|
||||
return cur
|
||||
|
||||
def insert(self, num: int):
|
||||
"""ノードを挿入"""
|
||||
# 木が空の場合、ルートノードを初期化
|
||||
# 木が空なら、根ノードを初期化する
|
||||
if self._root is None:
|
||||
self._root = TreeNode(num)
|
||||
return
|
||||
# ループで探索、葉ノードを通過した後にブレーク
|
||||
# ループで探索し、葉ノードを越えたら抜ける
|
||||
cur, pre = self._root, None
|
||||
while cur is not None:
|
||||
# 重複ノードを発見したため、戻る
|
||||
# 重複ノードが見つかったら、直ちに返す
|
||||
if cur.val == num:
|
||||
return
|
||||
pre = cur
|
||||
# 挿入位置はcurの右部分木にある
|
||||
# 挿入位置は cur の右部分木にある
|
||||
if cur.val < num:
|
||||
cur = cur.right
|
||||
# 挿入位置はcurの左部分木にある
|
||||
# 挿入位置は cur の左部分木にある
|
||||
else:
|
||||
cur = cur.left
|
||||
# ノードを挿入
|
||||
@@ -67,80 +67,80 @@ class BinarySearchTree:
|
||||
|
||||
def remove(self, num: int):
|
||||
"""ノードを削除"""
|
||||
# 木が空の場合、戻る
|
||||
# 木が空なら、そのまま早期リターンする
|
||||
if self._root is None:
|
||||
return
|
||||
# ループで探索、葉ノードを通過した後にブレーク
|
||||
# ループで探索し、葉ノードを越えたら抜ける
|
||||
cur, pre = self._root, None
|
||||
while cur is not None:
|
||||
# 削除するノードを発見、ループをブレーク
|
||||
# 削除対象のノードが見つかったら、ループを抜ける
|
||||
if cur.val == num:
|
||||
break
|
||||
pre = cur
|
||||
# 削除するノードはcurの右部分木にある
|
||||
# 削除対象ノードは cur の右部分木にある
|
||||
if cur.val < num:
|
||||
cur = cur.right
|
||||
# 削除するノードはcurの左部分木にある
|
||||
# 削除対象ノードは cur の左部分木にある
|
||||
else:
|
||||
cur = cur.left
|
||||
# 削除するノードが存在しない場合、戻る
|
||||
# 削除対象ノードがなければそのまま返す
|
||||
if cur is None:
|
||||
return
|
||||
|
||||
# 子ノード数 = 0 または 1
|
||||
# 子ノード数 = 0 or 1
|
||||
if cur.left is None or cur.right is None:
|
||||
# 子ノード数 = 0/1の場合、child = null/その子ノード
|
||||
# 子ノード数が 0 / 1 のとき、child = null / その子ノード
|
||||
child = cur.left or cur.right
|
||||
# ノードcurを削除
|
||||
# ノード cur を削除する
|
||||
if cur != self._root:
|
||||
if pre.left == cur:
|
||||
pre.left = child
|
||||
else:
|
||||
pre.right = child
|
||||
else:
|
||||
# 削除されるノードがルートの場合、ルートを再割り当て
|
||||
# 削除ノードが根ノードなら、根ノードを再設定
|
||||
self._root = child
|
||||
# 子ノード数 = 2
|
||||
else:
|
||||
# curの中順走査の次のノードを取得
|
||||
# 中順走査における cur の次ノードを取得
|
||||
tmp: TreeNode = cur.right
|
||||
while tmp.left is not None:
|
||||
tmp = tmp.left
|
||||
# 再帰的にノードtmpを削除
|
||||
# ノード tmp を再帰的に削除
|
||||
self.remove(tmp.val)
|
||||
# curをtmpで置き換え
|
||||
# tmp で cur を上書きする
|
||||
cur.val = tmp.val
|
||||
|
||||
|
||||
"""ドライバコード"""
|
||||
"""Driver Code"""
|
||||
if __name__ == "__main__":
|
||||
# 二分探索木を初期化
|
||||
bst = BinarySearchTree()
|
||||
nums = [8, 4, 12, 2, 6, 10, 14, 1, 3, 5, 7, 9, 11, 13, 15]
|
||||
# 注意：異なる挿入順序により、様々な木構造が生成される可能性がある。この特定のシーケンスは完全二分木を作成する
|
||||
# 注意：挿入順序が異なると異なる二分木が生成される。このシーケンスからは完全二分木を生成できる
|
||||
for num in nums:
|
||||
bst.insert(num)
|
||||
print("\n初期化された二分木は\n")
|
||||
print("\n初期化した二分木は\n")
|
||||
print_tree(bst.get_root())
|
||||
|
||||
# ノードを探索
|
||||
node = bst.search(7)
|
||||
print("\n発見されたノードオブジェクト: {}, ノードの値 = {}".format(node, node.val))
|
||||
print("\n見つかったノードオブジェクトは: {}、ノードの値 = {}".format(node, node.val))
|
||||
|
||||
# ノードを挿入
|
||||
bst.insert(16)
|
||||
print("\nノード16を挿入後の二分木は\n")
|
||||
print("\nノード 16 を挿入した後、二分木は\n")
|
||||
print_tree(bst.get_root())
|
||||
|
||||
# ノードを削除
|
||||
bst.remove(1)
|
||||
print("\nノード1を削除後の二分木は\n")
|
||||
print("\nノード 1 を削除した後、二分木は\n")
|
||||
print_tree(bst.get_root())
|
||||
|
||||
bst.remove(2)
|
||||
print("\nノード2を削除後の二分木は\n")
|
||||
print("\nノード 2 を削除した後、二分木は\n")
|
||||
print_tree(bst.get_root())
|
||||
|
||||
bst.remove(4)
|
||||
print("\nノード4を削除後の二分木は\n")
|
||||
print_tree(bst.get_root())
|
||||
print("\nノード 4 を削除した後、二分木は\n")
|
||||
print_tree(bst.get_root())
|
||||
|
||||
@@ -11,16 +11,16 @@ sys.path.append(str(Path(__file__).parent.parent))
|
||||
from modules import TreeNode, print_tree
|
||||
|
||||
|
||||
"""ドライバコード"""
|
||||
"""Driver Code"""
|
||||
if __name__ == "__main__":
|
||||
# 二分木を初期化
|
||||
# ノードを初期化
|
||||
# 二分木を初期化する
|
||||
# ノードを初期化する
|
||||
n1 = TreeNode(val=1)
|
||||
n2 = TreeNode(val=2)
|
||||
n3 = TreeNode(val=3)
|
||||
n4 = TreeNode(val=4)
|
||||
n5 = TreeNode(val=5)
|
||||
# ノードの参照（ポインタ）を構築
|
||||
# ノード間の参照（ポインタ）を構築する
|
||||
n1.left = n2
|
||||
n1.right = n3
|
||||
n2.left = n4
|
||||
@@ -30,12 +30,12 @@ if __name__ == "__main__":
|
||||
|
||||
# ノードの挿入と削除
|
||||
P = TreeNode(0)
|
||||
# ノードPを n1 -> n2 の間に挿入
|
||||
# n1 -> n2 の間にノード P を挿入
|
||||
n1.left = P
|
||||
P.left = n2
|
||||
print("\nノードPを挿入後\n")
|
||||
print("\nノード P を挿入した後\n")
|
||||
print_tree(n1)
|
||||
# ノードを削除
|
||||
n1.left = n2
|
||||
print("\nノードPを削除後\n")
|
||||
print_tree(n1)
|
||||
print("\nノード P を削除した後\n")
|
||||
print_tree(n1)
|
||||
|
||||
@@ -14,29 +14,29 @@ from collections import deque
|
||||
|
||||
def level_order(root: TreeNode | None) -> list[int]:
|
||||
"""レベル順走査"""
|
||||
# キューを初期化し、ルートノードを追加
|
||||
# キューを初期化し、ルートノードを追加する
|
||||
queue: deque[TreeNode] = deque()
|
||||
queue.append(root)
|
||||
# 走査シーケンスを格納するリストを初期化
|
||||
# 走査順序を保存するためのリストを初期化する
|
||||
res = []
|
||||
while queue:
|
||||
node: TreeNode = queue.popleft() # キューからデキュー
|
||||
res.append(node.val) # ノードの値を保存
|
||||
node: TreeNode = queue.popleft() # デキュー
|
||||
res.append(node.val) # ノードの値を保存する
|
||||
if node.left is not None:
|
||||
queue.append(node.left) # 左の子ノードをエンキュー
|
||||
queue.append(node.left) # 左子ノードをキューに追加
|
||||
if node.right is not None:
|
||||
queue.append(node.right) # 右の子ノードをエンキュー
|
||||
queue.append(node.right) # 右子ノードをキューに追加
|
||||
return res
|
||||
|
||||
|
||||
"""ドライバコード"""
|
||||
"""Driver Code"""
|
||||
if __name__ == "__main__":
|
||||
# 二分木を初期化
|
||||
# 特定の関数を使用して配列を二分木に変換
|
||||
# ここでは、配列から直接二分木を生成する関数を利用する
|
||||
root: TreeNode = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
|
||||
print("\n二分木を初期化\n")
|
||||
print_tree(root)
|
||||
|
||||
# レベル順走査
|
||||
res: list[int] = level_order(root)
|
||||
print("\nレベル順走査のノードシーケンスを出力 = ", res)
|
||||
print("\nレベル順走査のノード出力シーケンス = ", res)
|
||||
|
||||
@@ -12,10 +12,10 @@ from modules import TreeNode, list_to_tree, print_tree
|
||||
|
||||
|
||||
def pre_order(root: TreeNode | None):
|
||||
"""前順走査"""
|
||||
"""先行順走査"""
|
||||
if root is None:
|
||||
return
|
||||
# 訪問順序: ルートノード -> 左部分木 -> 右部分木
|
||||
# 訪問順序：根ノード -> 左部分木 -> 右部分木
|
||||
res.append(root.val)
|
||||
pre_order(root=root.left)
|
||||
pre_order(root=root.right)
|
||||
@@ -25,7 +25,7 @@ def in_order(root: TreeNode | None):
|
||||
"""中順走査"""
|
||||
if root is None:
|
||||
return
|
||||
# 訪問順序: 左部分木 -> ルートノード -> 右部分木
|
||||
# 訪問優先順: 左部分木 -> 根ノード -> 右部分木
|
||||
in_order(root=root.left)
|
||||
res.append(root.val)
|
||||
in_order(root=root.right)
|
||||
@@ -35,31 +35,31 @@ def post_order(root: TreeNode | None):
|
||||
"""後順走査"""
|
||||
if root is None:
|
||||
return
|
||||
# 訪問順序: 左部分木 -> 右部分木 -> ルートノード
|
||||
# 訪問優先順: 左部分木 -> 右部分木 -> 根ノード
|
||||
post_order(root=root.left)
|
||||
post_order(root=root.right)
|
||||
res.append(root.val)
|
||||
|
||||
|
||||
"""ドライバコード"""
|
||||
"""Driver Code"""
|
||||
if __name__ == "__main__":
|
||||
# 二分木を初期化
|
||||
# 特定の関数を使用して配列を二分木に変換
|
||||
# ここでは、配列から直接二分木を生成する関数を利用する
|
||||
root = list_to_tree(arr=[1, 2, 3, 4, 5, 6, 7])
|
||||
print("\n二分木を初期化\n")
|
||||
print_tree(root)
|
||||
|
||||
# 前順走査
|
||||
# 先行順走査
|
||||
res = []
|
||||
pre_order(root)
|
||||
print("\n前順走査のノードシーケンスを出力 = ", res)
|
||||
print("\n先行順走査のノード出力シーケンス = ", res)
|
||||
|
||||
# 中順走査
|
||||
res.clear()
|
||||
in_order(root)
|
||||
print("\n中順走査のノードシーケンスを出力 = ", res)
|
||||
print("\n中間順走査のノード出力シーケンス = ", res)
|
||||
|
||||
# 後順走査
|
||||
res.clear()
|
||||
post_order(root)
|
||||
print("\n後順走査のノードシーケンスを出力 = ", res)
|
||||
print("\n後行順走査のノード出力シーケンス = ", res)
|
||||
|
||||
Reference in New Issue
Block a user