Merge pull request #16 from RyosukeDTomita/feature/bst

feature/bst

Author: RyosukeDTomita

data_structure/tree/tree.hs

@@ -1,4 +1,4 @@
-data Tree a = Node a [Tree a] deriving (Show)
+data Tree a = Node a [Tree a] deriving (Show) -- 型コンストラクタとしてTreeをデータコンストラクタとしてNodeを作成
 
 -- 葉ノード（子を持たないノード）を作成
 leaf :: a -> Tree a
@@ -11,14 +11,14 @@ rootValue (Node x _) = x
 -- 特定の値を持つノードの子として新しい値を挿入
 -- 見つからない場合は元の木を返す
 insertAt :: (Eq a) => a -> a -> Tree a -> Tree a
-insertAt target newVal (Node x cs)
-  | x == target = Node x (leaf newVal : cs)
-  | otherwise = Node x (map (insertAt target newVal) cs)
+insertAt target newVal (Node x children)
+  | x == target = Node x (leaf newVal : children)
+  | otherwise = Node x (map (insertAt target newVal) children) -- mapするのはすべての子要素について調査するため
 
 -- 特定の値を持つノードを削除（子ノードは親に昇格）
 -- ルートノードは削除できない
 delete :: (Eq a) => a -> Tree a -> Tree a
-delete target (Node x cs) = Node x (concatMap (deleteHelper target) cs)
+delete target (Node x children) = Node x (concatMap (deleteHelper target) children)
   where
     deleteHelper :: (Eq a) => a -> Tree a -> [Tree a]
     deleteHelper t (Node v children')
@@ -27,33 +27,33 @@ delete target (Node x cs) = Node x (concatMap (deleteHelper target) cs)
 
 -- 木に特定の値が含まれているか検索
 contains :: (Eq a) => a -> Tree a -> Bool
-contains target (Node x cs) = x == target || any (contains target) cs
+contains target (Node x children) = x == target || any (contains target) children
 
 -- 木のサイズ（ノード数）を取得
 size :: Tree a -> Int
-size (Node _ cs) = 1 + sum (map size cs)
+size (Node _ children) = 1 + sum (map size children)
 
 -- 木の深さを取得
 depth :: Tree a -> Int
 depth (Node _ []) = 1
-depth (Node _ cs) = 1 + maximum (map depth cs)
+depth (Node _ children) = 1 + maximum (map depth children)
 
 -- 木を整形して表示（枝を使って階層構造を明確化）
 prettyPrint :: (Show a) => Tree a -> String
 prettyPrint tree = go "" "" tree
   where
-    go prefix childPrefix (Node x cs) =
+    go prefix childPrefix (Node x children) =
       prefix
         ++ show x
         ++ "\n"
-        ++ drawChildren childPrefix cs
+        ++ drawChildren childPrefix children
 
     drawChildren _ [] = ""
     drawChildren prefix [c] =
       go (prefix ++ "└── ") (prefix ++ "    ") c
-    drawChildren prefix (c : cs') =
+    drawChildren prefix (c : children') =
       go (prefix ++ "├── ") (prefix ++ "│   ") c
-        ++ drawChildren prefix cs'
+        ++ drawChildren prefix children'
 
 main :: IO ()
 main = do

search/README.md

@@ -5,13 +5,25 @@
 - 先頭から対象となる値を探す。
 - 計算量は O(n)。
 
+### 実装例
+
+- [x] C
+- [x] Python
+- [x] Haskell
+
 ### 線形探索 with 番兵法(Sentinel loop)あり
 
 - 前提として線形探索においてループの終了条件は，以下の 2 つがある。
   - 探索する値が見つかったか
   - 探索する値が見つからなかった場合に配列の末尾に到達したか
 - 探索する配列に番兵として探索する値を末尾に追加することで，必ず探索する値が見つかるようになるため，ループの終了条件を探索する値が見つかったかの 1 つにすることができる。
 
+#### 実装例
+
+- [x] C
+- [x] Python
+- [x] Haskell(特にメリットはない)
+
 ---
 
 ## 二分探索(Binary search)
@@ -22,10 +34,38 @@
 - 配列を半分にわけて，ピボットを基準にターゲットとなる値が左右のどちらにあるか探索する。
 - 計算効率は、1 ステップごとに探索対象が半分になっていく。これは 2 進数においては 1 桁減ることを表しているので計算量は O(log2 n)と表せる。
 
-### 関数を満たす最大/最小の値の探索
+#### 実装例
+
+- [x] C
+- [x] Python
+- [x] Haskell
+
+### 関数を満たす最大/最小の値を二分探索で探す
 
 - 二分探索を使い、関数f(x)がピボットに対してTrueかFalseかを判定することで、関数f(x)を満たす最大/最小のxの範囲を探索できる。
 
+#### 実装例
+
+- [ ] C
+- [ ] Python
+- [x] Haskell
+
+---
+
+## BST(Binary Search Tree)
+
+- 二分木探索とも。
+- 各ノードに値が格納されており、左の子ノードは親ノードより小さい値、右の子ノードは親ノードより大きい値を持つという構造を維持する二分木。
+- ノードの削除時には、そのノードの右部分木の最小値を持つノードを削除するノードの位置に移動させることで、BSTの構造を維持する。
+  - 右部分技の最小値は、左部分木のどの値よりも大きいが、右部分木のどの値よりも小さいため、BSTの構造が維持される。
+  - (右部分木の最小値は、子ノードがないので移動させやすい。)
+
+### 実装例
+
+- [ ] C
+- [ ] Python
+- [x] Haskell
+
 ---
 
 ## bit 全探索(bit search)
@@ -43,5 +83,3 @@
 ## ｈ幅優先探索(Breadth First Search)
 
 ---
-
-## 2 分木探索(Binary search tree)

…arch/binary_search/binary_search_func.hs search/binary_search/binarySearchFunc.hssearch/binary_search/binary_search_func.hs renamed to search/binary_search/binarySearchFunc.hs search/binary_search/binary_search_func.hs renamed to search/binary_search/binarySearchFunc.hs

@@ -0,0 +1,141 @@
+{-# LANGUAGE CPP #-}
+{-# LANGUAGE OverloadedStrings #-}
+
+-- {-# OPTIONS_GHC -DATCODER #-}
+import Debug.Trace (traceShowId)
+
+#ifdef ATCODER
+debug :: Bool ; debug = False
+#else
+debug :: Bool ; debug = True
+#endif
+
+dbgId :: (Show a) => a -> a
+dbgId x
+  | debug = traceShowId x
+  | otherwise = x
+
+data BST a
+  = Empty
+  | Node a (BST a) (BST a)
+  deriving (Show)
+
+search :: (Ord a) => a -> BST a -> Bool
+search _ Empty = False
+search target (Node v left right)
+  | target == v = True
+  | target < v = search target left -- 自分より小さい値は左側の枝に
+  | otherwise = search target right
+
+insert :: (Ord a) => a -> BST a -> BST a
+insert x Empty = Node x Empty Empty
+insert x (Node v left right)
+  | x == v = Node v left right
+  | x < v = Node v (insert x left) right
+  | otherwise = Node v left (insert x right)
+
+-- 削除対象の位置にその位置からみた右部分木の最小値に置き換える。
+-- これにより、左部分技よりは小さく、右部分技のどの値よりも小さな値がトップにくるため二分木が破綻しない。
+delete :: (Ord a) => a -> BST a -> BST a
+delete _ Empty = Empty
+delete x (Node v left right)
+  | x < v = Node v (delete x left) right
+  | x > v = Node v left (delete x right)
+  | otherwise = removeNode (Node v left right)
+
+-- ノード削除ロジック
+removeNode :: (Ord a) => BST a -> BST a
+removeNode (Node _ Empty right) = right
+removeNode (Node _ left Empty) = left
+removeNode (Node _ left right) =
+  -- 右部分木の最小値を取り出し、そのノードを除いた木も返す
+  let (m, right') = detachMin right
+   in Node m left right'
+removeNode Empty = Empty
+
+detachMin :: BST a -> (a, BST a)
+detachMin Empty = error "detachMin: empty tree"
+detachMin (Node x Empty right) = (x, right)
+detachMin (Node x left right) =
+  let (m, left') = detachMin left
+   in (m, Node x left' right)
+
+-- 木を整形して表示（枝を使って階層構造を明確化）
+prettyPrint :: (Show a) => BST a -> String
+prettyPrint tree = go "" "" tree
+  where
+    go _ _ Empty = ""
+    go prefix childPrefix (Node x left right) =
+      prefix
+        ++ show x
+        ++ "\n"
+        ++ drawChildren childPrefix left right
+
+    drawChildren prefix Empty Empty = ""
+    drawChildren prefix left Empty =
+      go (prefix ++ "└── ") (prefix ++ "    ") left
+    drawChildren prefix Empty right =
+      go (prefix ++ "└── ") (prefix ++ "    ") right
+    drawChildren prefix left right =
+      go (prefix ++ "├── ") (prefix ++ "│   ") left
+        ++ go (prefix ++ "└── ") (prefix ++ "    ") right
+
+main :: IO ()
+main = do
+  let bTree =
+        Node
+          5
+          ( Node
+              3
+              ( Node
+                  1
+                  Empty
+                  Empty
+              )
+              ( Node
+                  4
+                  Empty
+                  Empty
+              )
+          )
+          ( Node
+              7
+              ( Node
+                  6
+                  Empty
+                  Empty
+              )
+              ( Node
+                  8
+                  Empty
+                  Empty
+              )
+          )
+  putStrLn "=====INITIAl====="
+  putStrLn $ prettyPrint bTree
+  print $ search 3 bTree -- 存在する
+  print $ search 10 bTree -- 存在しない
+
+  -- 追加
+  putStrLn "=====ADD 10====="
+  let bTree' = insert 10 bTree
+  putStrLn $ prettyPrint bTree'
+  print $ search 10 bTree'
+
+  -- 存在する要素を追加
+  putStrLn "=====ADD 3(already exists)====="
+  let bTree'' = insert 3 bTree
+  putStrLn $ prettyPrint bTree''
+  print $ search 3 bTree''
+
+  -- 削除
+  putStrLn "=====DELETE 5====="
+  let bTree''' = delete 5 bTree
+  putStrLn $ prettyPrint bTree'''
+  print $ search 5 bTree'''
+
+  -- 存在しない要素を削除する
+  putStrLn "=====DELETE 8(not exist)====="
+  let bTree'''' = delete 8 bTree
+  putStrLn $ prettyPrint bTree''''
+  print $ search 8 bTree''''

search/bst/bst.hs

@@ -0,0 +1,16 @@
+-- 高級言語の場合はやっても分岐の数は減らないので意味がない。
+linearSearch :: [Int] -> Int -> Int
+linearSearch xs target =
+  let xs' = xs ++ [target] -- 番兵を追加
+   in head
+        [ i
+          | i <- [0 .. length xs' - 1],
+            xs' !! i == target
+        ]
+
+main :: IO ()
+main = do
+  let randomList = [30, 75, 69, 16, 47, 77, 60, 80, 74, 8, 77, 1, 60, 33, 70, 29, 24, 91, 60, 69]
+  print randomList
+  let target = 77
+  print $ linearSearch randomList 77