Solution for binary-search-tree

Author: Quentin Ménoret

binary-search-tree/README.md

@@ -0,0 +1,133 @@
+# Binary Search Tree
+
+Insert and search for numbers in a binary tree.
+
+When we need to represent sorted data, an array does not make a good
+data structure.
+
+Say we have the array `[1, 3, 4, 5]`, and we add 2 to it so it becomes
+`[1, 3, 4, 5, 2]` now we must sort the entire array again! We can
+improve on this by realizing that we only need to make space for the new
+item `[1, nil, 3, 4, 5]`, and then adding the item in the space we
+added. But this still requires us to shift many elements down by one.
+
+Binary Search Trees, however, can operate on sorted data much more
+efficiently.
+
+A binary search tree consists of a series of connected nodes. Each node
+contains a piece of data (e.g. the number 3), a variable named `left`,
+and a variable named `right`. The `left` and `right` variables point at
+`nil`, or other nodes. Since these other nodes in turn have other nodes
+beneath them, we say that the left and right variables are pointing at
+subtrees. All data in the left subtree is less than or equal to the
+current node's data, and all data in the right subtree is greater than
+the current node's data.
+
+For example, if we had a node containing the data 4, and we added the
+data 2, our tree would look like this:
+
+      4
+     /
+    2
+
+If we then added 6, it would look like this:
+
+      4
+     / \
+    2   6
+
+If we then added 3, it would look like this
+
+       4
+     /   \
+    2     6
+     \
+      3
+
+And if we then added 1, 5, and 7, it would look like this
+
+          4
+        /   \
+       /     \
+      2       6
+     / \     / \
+    1   3   5   7
+
+## Hints
+
+To complete this exercise you need to create the data type `BST`,
+with `Eq` and `Show` instances, and implement the functions:
+
+- `bstLeft`
+- `bstRight`
+- `bstValue`
+- `empty`
+- `fromList`
+- `insert`
+- `singleton`
+- `toList`
+
+You will find a dummy data declaration and type signatures already in place,
+but it is up to you to define the functions and create a meaningful data type,
+newtype or type synonym.
+
+
+## Getting Started
+
+For installation and learning resources, refer to the
+[exercism help page](http://exercism.io/languages/haskell).
+
+## Running the tests
+
+To run the test suite, execute the following command:
+
+```bash
+stack test
+```
+
+#### If you get an error message like this...
+
+```
+No .cabal file found in directory
+```
+
+You are probably running an old stack version and need
+to upgrade it.
+
+#### Otherwise, if you get an error message like this...
+
+```
+No compiler found, expected minor version match with...
+Try running "stack setup" to install the correct GHC...
+```
+
+Just do as it says and it will download and install
+the correct compiler version:
+
+```bash
+stack setup
+```
+
+## Running *GHCi*
+
+If you want to play with your solution in GHCi, just run the command:
+
+```bash
+stack ghci
+```
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/xhaskell](https://github.com/exercism/xhaskell) repository on
+GitHub is the home for all of the Haskell exercises.
+
+If you have feedback about an exercise, or want to help implementing a new
+one, head over there and create an issue.  We'll do our best to help you!
+
+## Source
+
+Josh Cheek [https://twitter.com/josh_cheek](https://twitter.com/josh_cheek)
+
+## Submitting Incomplete Problems
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+

binary-search-tree/binary-search-tree.cabal

@@ -0,0 +1,30 @@
+-- This file has been generated from package.yaml by hpack version 0.15.0.
+--
+-- see: https://github.com/sol/hpack
+
+name:           binary-search-tree
+version:        0.0.0
+build-type:     Simple
+cabal-version:  >= 1.10
+
+library
+  hs-source-dirs:
+      src
+  build-depends:
+      base
+  exposed-modules:
+      BST
+  other-modules:
+      Paths_binary_search_tree
+  default-language: Haskell2010
+
+test-suite test
+  type: exitcode-stdio-1.0
+  main-is: Tests.hs
+  hs-source-dirs:
+      test
+  build-depends:
+      base
+    , binary-search-tree
+    , hspec
+  default-language: Haskell2010

binary-search-tree/package.yaml

@@ -0,0 +1,19 @@
+name: binary-search-tree
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: BST
+  source-dirs: src
+  dependencies:
+  # - foo       # List here the packages you
+  # - bar       # want to use in your solution.
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - binary-search-tree
+      - hspec

binary-search-tree/src/BST.hs

@@ -0,0 +1,50 @@
+module BST
+    ( BST
+    , bstLeft
+    , bstRight
+    , bstValue
+    , empty
+    , fromList
+    , insert
+    , singleton
+    , toList
+    ) where
+
+data BST a = BST { left  :: BST a
+                 , right :: BST a
+                 , value :: a
+                 }
+            | Empty
+    deriving (Eq, Show)
+
+bstLeft :: BST a -> Maybe (BST a)
+bstLeft BST {left=Empty}  = Nothing
+bstLeft BST {left=l}      = Just l
+
+bstRight :: BST a -> Maybe (BST a)
+bstRight BST {right=Empty}  = Nothing
+bstRight BST {right=r}      = Just r
+
+bstValue :: BST a -> Maybe a
+bstValue Empty          = Nothing
+bstValue BST {value=x}  = Just x
+
+empty :: BST a
+empty = Empty
+
+fromList :: Ord a => [a] -> BST a
+fromList []     = Empty
+fromList (x:xs) = foldl (flip insert) (singleton x) xs
+
+insert :: Ord a => a -> BST a -> BST a
+insert x BST {right=r, left=l, value=v}
+    | v >= x    = BST{left=insert x l,   right=r,            value=v}
+    | otherwise = BST{left=l,            right=insert x r,   value=v}
+insert x empty = singleton x 
+
+singleton :: a -> BST a
+singleton x = BST {left=empty, right=empty, value=x}
+
+toList :: BST a -> [a]
+toList Empty = []
+toList BST{left=l, right=r, value=v} = toList l ++ (v:toList r)

binary-search-tree/stack.yaml

@@ -0,0 +1 @@
+resolver: lts-8.2

binary-search-tree/test/Tests.hs

@@ -0,0 +1,78 @@
+import Test.Hspec        (Spec, describe, it, shouldBe)
+import Test.Hspec.Runner (configFastFail, defaultConfig, hspecWith)
+
+import BST
+  ( bstLeft
+  , bstRight
+  , bstValue
+  , empty
+  , fromList
+  , insert
+  , singleton
+  , toList
+  )
+
+main :: IO ()
+main = hspecWith defaultConfig {configFastFail = True} specs
+
+specs :: Spec
+specs = describe "binary-seach-tree" $ do
+
+    -- As of 2016-08-03, there was no reference file
+    -- for the test cases in `exercism/x-common`.
+
+    let int4   = 4  ::  Int
+    let noInts = [] :: [Int]
+
+    it "data is retained" $
+      bstValue (singleton int4) `shouldBe` Just 4
+
+    it "inserting less" $ do
+      let t = insert 2 (singleton int4)
+      bstValue t `shouldBe` Just 4
+      (bstLeft t >>= bstValue) `shouldBe` Just 2
+
+    it "inserting same" $ do
+      let t = insert 4 (singleton int4)
+      bstValue t `shouldBe` Just 4
+      (bstLeft t >>= bstValue) `shouldBe` Just 4
+
+    it "inserting right" $ do
+      let t = insert 5 (singleton int4)
+      bstValue t `shouldBe` Just 4
+      (bstRight t >>= bstValue) `shouldBe` Just 5
+
+    it "empty list to tree" $
+      fromList noInts `shouldBe` empty
+
+    it "empty list has no value" $
+      bstValue (fromList noInts) `shouldBe` Nothing
+
+    it "inserting into empty" $ do
+      let t = insert int4 empty
+      bstValue t `shouldBe` Just 4
+
+    it "complex tree" $ do
+      let t = fromList [int4, 2, 6, 1, 3, 7, 5]
+      bstValue  t                            `shouldBe` Just 4
+      (bstLeft  t >>= bstValue             ) `shouldBe` Just 2
+      (bstLeft  t >>= bstLeft  >>= bstValue) `shouldBe` Just 1
+      (bstLeft  t >>= bstRight >>= bstValue) `shouldBe` Just 3
+      (bstRight t >>= bstValue             ) `shouldBe` Just 6
+      (bstRight t >>= bstLeft  >>= bstValue) `shouldBe` Just 5
+      (bstRight t >>= bstRight >>= bstValue) `shouldBe` Just 7
+
+    it "empty tree to list" $
+      length (toList empty) `shouldBe` 0
+
+    it "iterating one element" $
+      toList (singleton int4) `shouldBe` [4]
+
+    it "iterating over smaller element" $
+      toList (fromList [int4, 2]) `shouldBe` [2, 4]
+
+    it "iterating over larger element" $
+      toList (fromList [int4, 5]) `shouldBe` [4, 5]
+
+    it "iterating over complex tree" $
+      toList (fromList [int4, 2, 1, 3, 6, 7, 5]) `shouldBe` [1..7]