Merge pull request #10 from RyosukeDTomita/feature/sort

feature/sort

Author: RyosukeDTomita

math/README.md

@@ -0,0 +1,5 @@
+# 数学ぽいやつ
+
+## ユークリッドの互助法
+
+## エラトステネスのふるい

math/eratosthenes.hs

@@ -0,0 +1,17 @@
+primes :: [Int]
+primes = 2 : sieve [3, 5 ..] -- 2と奇数の無限配列
+  where
+    sieve (p : xs) =
+      p
+        : sieve
+          [ x
+            | x <- xs,
+              x `mod` p /= 0
+          ]
+
+main :: IO ()
+main = do
+  print $ take 20 primes
+  print $ 7 `elem` primes
+
+-- print $ 102 `elem` primes -- 素数でない数を探索すると止まらない

math/euclidean.hs

@@ -0,0 +1,10 @@
+-- ユークリッドの互助法
+euclidean :: Int -> Int -> Int
+euclidean a b
+  | a `mod` b == 0 = b
+  | otherwise = euclidean b (a `mod` b)
+
+main :: IO ()
+main = do
+  print $ euclidean 5 21
+  print $ euclidean 10 100

search/depth_first_search/depth_first_search.hs

@@ -0,0 +1,2 @@
+main :: IO ()
+main = do

search/linear_search/linear_search.hs

@@ -0,0 +1,14 @@
+linearSearch :: [Int] -> Int -> Int
+linearSearch xs target =
+  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

sort/README.md

@@ -4,10 +4,15 @@
 
 - 隣り合う要素の大小を比較しながら整列させる。
 - アルゴリズムが単純で実装が用意なため、並列処理との親和性が高い。
-- バブルソートを 1 回行うと最後の要素が最大になるため、次回のスキャン範囲を 1 狭めることができる。
-- そのため、平均計算時間は、n-1+n-2...1=n(n-1)/2 である。
-- よって計算量は O(n^2)
-- 最後に要素の交換を行った位置から、スキャン範囲の最後の要素にたどり着くまでの間に連続して要素の交換が発生しない場合にはスキャン回数を大幅に狭めることができる。--> つまり、ソート済みの部分があると実行速度が上がる。
+- バブルソートを 1 回行うと右端(もしくは左端)の要素がソートされるため、次回のスキャン範囲を 1 狭めることができる。
+- 最良ケース、平均ケース、最悪ケースともにO(n^2) (交換回数ではなく、比較回数)
+  - n - 1 + n - 2 ... 1 = n(n - 1) / 2 = (n^2 - n) / 2
+
+### 実装例
+
+- [x] C
+- [x] Python
+- [x] Haskell
 
 ---
 
@@ -21,6 +26,12 @@
 - 最悪ケース(逆順に整列されている場合)はO(n^2)
   - i番目の挿入で毎回右端まで移動するので、1 + 2 + 3 ... + (n-1) = n(n-1)/2 回の比較が必要になる。
 
+### 実装例
+
+- [x] C
+- [x] Python
+- [x] Haskell
+
 ---
 
 ## 選択ソート(Selection Sort)
@@ -30,13 +41,21 @@
 - リストサイズを n とすると、1 回目は n 回の探索、2 回目は n-1 回の探索が必要になる。そのため、ステップ数は n + (n-1) + (n -2) ... 1 = n(n+1)/2 　となる。
 - よって計算量は O(n^2)となる。
 
+### 実装例
+
+- [x] C
+- [x] Python
+- [x] Haskell
+
 ---
 
 ## マージゾート(Merge Sort)
 
-- 2 つのソート済みの配列をつなげてソートする方法。配列を 1 個ずつに分解して，マージする過程で順番を並べることを繰り返す。
-- そのため，まず配列をサイズ 1 まで小さくしてそれを結合する過程でマージする操作を繰り返す。
-- 問題を細かく分割し、簡単な問題を解くことを積み重ねて全体の回を得るマージソートのような問題を分割統治法(divide-and-conquer method)と呼ぶ。
+- 2 つのソート済みの配列をつなげてソートする方法。配列をサイズ1まで一度分解し，マージする過程で順番を並べることを繰り返す。
+- 最良ケース、平均ケース、最悪ケースともにO(nlog2 n)である。
+
+> [!NOTE]
+> 問題を細かく分割し、簡単な問題を解くことを積み重ねて全体の回を得るマージソートのような問題を分割統治法(divide-and-conquer method)と呼ぶ。
 
 ### マージソートの計算量
 
@@ -54,7 +73,7 @@
 - この木の高さ log2 n に対して、2 分木の高さを半分にするには，おおよそ n/2 回のマージが必用である。
 - このことからマージソートの計算量は O(nlog2 n) であることがわかる。
 
-### スターリングの近似
+#### スターリングの近似
 
 > [スターリングの近似](https://ja.wikipedia.org/wiki/%E3%82%B9%E3%82%BF%E3%83%BC%E3%83%AA%E3%83%B3%E3%82%B0%E3%81%AE%E8%BF%91%E4%BC%BC)
 
@@ -65,29 +84,51 @@
 - つまり，2^k >= (n/e)^n \* √(2πn) である。
 - これを変形して，k >= nlog2 n - nlog2 e + 1/2log2(2πn) であるためマージソートの計算量は理論上最小であることがわかる。
 
+### 実装例
+
+- [x] C
+- [x] Python
+- [x] Haskell
+
 ---
 
 ## クイックソート(Quick Sort)
 
 - マージソートと同じ分割統治法(divide-and-conquer method)に分類される。
 - 配列から pivot を選択し、pivot より小さいか大きいかで配列を 2 つに分割し，分割した配列それぞれに対してこの操作を繰り返していくことでソートされる。
-- クイックソートは pivot からソート完了後の位置に配置されていく。
-- 計算量は O(nlog2 n)
-  > [!NOTE]
-  > クイックソートは高速だが，ピボットの位置を固定している場合にパフォーマンスが落ちてしまうことがある。これは，ピボットで配列を 2 つに分割した時に片方に配列のサイズが大きくなってしまった場合にパフォーマンスが悪くなる。
-  > つまり，ソート済みの配列に対しては毎回分割が発生するため，1 + 2 + 3 ... n-1 = (n)(n-1)/2 となるため最悪計算量は O(n^2)である。
+- 計算量は最良ケースでは、O(nlog2 n)
+- 平均ケースでも、O(nlog2 n)
+- 最悪ケースでは、O(n^2)
+
+> [!NOTE]
+> クイックソートは高速だが，ピボットの位置を固定している場合にパフォーマンスが落ちてしまうことがある。
+> これは，ピボットで配列を 2 つに分割した時に片方に配列のサイズが大きくなってしまった場合にパフォーマンスが悪くなる。
+> 左端をピボッドにするとした場合には，ソート済みの配列に対しては毎回分割が発生するため，1 + 2 + 3 ... n-1 = (n)(n-1)/2 となるため最悪計算量は O(n^2)である。
+
 - そこで pivot をランダムに選択するようにすることで、パフォーマンスが劇的に低下することを防ぐことができる。
 - このようにアルゴリズムの実行にランダムな要素を含むものを乱択アルゴリズムという。
 
+### 実装例
+
+- [x] C
+- [x] Python
+- [x] Haskell
+
 ---
 
 ## シェルソート(Shell Sort)
 
 - 挿入ソートの改良版。
-- クイックソートが発見されるまでは最も高速なソートアルゴリズムだった。
+- クイックソートが発見されるまでは最も高速なソートアルゴリズムだったらしい。
 - 挿入ソートがある程度整列済みのデータに関して高速であることを利用して予め整列度を高めるための前処理を行う。
 - h-ソート: 前処理として一定の距離(h)離れた要素を比較し，ソートする。
-- この例では h を 3n+1 としてループを回す毎に h を 3 で割る(切り捨て)しつつ，挿入ソートと同様に 2 つの値を比較して並べることを繰り返す。
+- この例ではKnuthの間隔列を用いる。
+
+### 実装例
+
+- [x] C
+- [x] Python
+- [x] Haskell
 
 ---
 
@@ -96,4 +137,12 @@
 - 木構造の一種であるヒープというデータ構造を用いて，データを並び替えるソート方法。
 - ヒープとは: 木のデータ構造のうち，どの親子も親>=子，あるいは親<=子の関係にあること。
 
+### 実装例
+
+- [x] C
+- [x] Python
+- [] Haskell
+
 ---
+
+## 計数ソート(Counting Sort)

sort/bubble_sort/bubbleSort.hs

@@ -0,0 +1,19 @@
+bubbleSort :: (Ord a) => [a] -> [a]
+bubbleSort xs =
+  -- リストの数だけ再帰する
+  go xs (length xs)
+  where
+    go xs 0 = xs
+    go xs n = go (bubble xs) (n - 1)
+
+    -- 隣同士を比較して交換する関数
+    bubble (x : y : zs)
+      | x > y = y : bubble (x : zs)
+      | otherwise = x : bubble (y : zs)
+    bubble xs = xs -- リストのサイズが2未満になった時
+
+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
+  print $ bubbleSort randomList

sort/merge_sort/mergeSort.hs

@@ -0,0 +1,20 @@
+mergeSort :: [Int] -> [Int]
+mergeSort [] = []
+mergeSort [x] = [x]
+mergeSort xs = merge (mergeSort left) (mergeSort right) -- 配列をサイズ1もしくは空になるまで分割する
+  where
+    (left, right) = splitAt (length xs `div` 2) xs -- 真ん中でリストを分割する
+
+-- 配列を合成する過程でソートする
+merge :: [Int] -> [Int] -> [Int]
+merge [] ys = ys
+merge xs [] = xs
+merge (x : xs) (y : ys)
+  | x <= y = x : merge xs (y : ys)
+  | otherwise = y : merge (x : xs) ys
+
+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
+  print $ mergeSort randomList

sort/quick_sort/quickSort.hs

@@ -0,0 +1,13 @@
+-- NOTE: pivotは雑に左端から選択している
+quickSort :: (Ord a) => [a] -> [a]
+quickSort [] = []
+quickSort (x : xs) = quickSort left ++ [x] ++ quickSort right
+  where
+    left = filter (< x) xs
+    right = filter (>= x) xs
+
+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
+  print $ quickSort randomList

sort/selection_sort/selectionSort.hs

@@ -0,0 +1,25 @@
+import Data.List (delete, unfoldr)
+
+selectionSort :: (Ord a) => [a] -> [a]
+selectionSort xs =
+  go xs
+  where
+    go [] = []
+    go xs = let m = minimum xs in m : go (delete m xs) -- deleteで特定の要素を消した配列を返している
+
+-- unfoldrを使って簡潔に書いたバージョン
+selectionSort' :: (Ord a) => [a] -> [a]
+selectionSort' xs = unfoldr go xs
+  where
+    go [] = Nothing -- 空なら停止
+    go xs =
+      let m = minimum xs
+          xs' = delete m xs
+       in Just (m, xs')
+
+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
+  print $ selectionSort randomList
+  print $ selectionSort' randomList