Work with binary search trees in Racket

Question

I want to create a binary search tree in Racket. The structure for tree looks like this:

(define-struct tree-node (left right root))

Now I want to add these numbers in the tree:

(define ex-list (list 1 4 6 2 7 8))

My Code for the insert procedure:

(define (insert-in-tree list tree) 
  (cond
    [(empty? tree) 
      (insert-in-tree (cons (second list) (rest (rest list))) 
                      (make-tree-node empty empty (first list)))]
    [(empty? list) 
      tree]
    [(> (first list) (tree-node-root tree)) 
      (insert-in-tree (cons (second list) (rest (rest list))) 
                      (make-tree-node 
                          (tree-node-left tree) 
                          (make-tree-node empty empty (first list)) 
                          (tree-node-root tree)))]
    [(< (first list) (tree-node-root tree)) 
      (insert-in-tree (cons (second list) (rest (rest list))) 
                      (make-tree-node 
                          (make-tree-node empty empty (first list)) 
                          (tree-node-right tree) 
                          (tree-node-root tree)))]
    [(= (first list) (tree-node-root tree)) 
      (insert-in-tree (cons (second list) (rest (rest list))) tree)]
    [else tree]))

What is my idea of the code:

First it checks wether the given tree is empty, if so a new one will be created
When the first number in the list is bigger than the root of the tree, it will be added on the right hand side, for smaller on the left side
Equal numbers will be ignored

My Problem: When the tree is just the 1 and the procedure adds the 4 its added as a new root element in the right side. When I then add the 6 it will replace the 4 but it should add a new node for the 6.

I know that this version of code is not working because in the case when the list is just one element this code won't work.

The level of code is Intermediate Student

Will Ness · Accepted Answer · 2017-11-12T15:32:50.780

This:

(cons (second list) (rest (rest list)))

is a very strange way to write (rest list), which also ensures an error if list is shorter than two elements.

Changing that, we notice that it will still cause an error for empty lists; so the clause handling this eventuality must be moved to the top

(define (insert-in-tree list tree)
  (cond
    [ (empty? list)
      tree ]
    [ (empty? tree)
      (insert-in-tree (rest list)
                      (make-tree-node empty empty (first list))) ]
    [ (> (first list) (tree-node-root tree))
      (insert-in-tree (rest list)
                      (make-tree-node
    ........

At least now it doesn't cause an error:

> (insert-in-tree (list 1 2 3) empty)
(make-tree-node '() (make-tree-node '() '() 3) 1)
> (insert-in-tree (list 1 2 3 4 3 5) empty)
(make-tree-node '() (make-tree-node '() '() 5) 1)
>

But scratch all that, your approach is all wrong. Your code mixes up two essentially separate issues: enumerating list elements, and inserting an element into a tree.

Separate your concerns. Each task deserves its own, dedicated function. Writing it that way will make it easy for you to combine the two tasks, by making small alterations in the list enumeration function, to make use of the insertion function.

The insertion function will implement the comparison logic, and make use of ... the insertion function, to insert into a branch if need be, since the branches are trees, themselves.

Thank you for your answer. It's very helpful! But what I did not understand, how can I prevent the replacing of branches? — , Nov 12 '17 at 15:49
what replacing of branches? why prevent it? if you insert into a branch, the result will (might...) be a different tree, won't it, so the updated branch will need to be used instead of the old branch, in the updated tree. Try to write this insertion function (*one* element into a tree... which may or may not be empty). ask new question if you encounter any problems. Please be specific, include the new code and the output. — Will Ness, Nov 12 '17 at 15:54
so, did you mean how to prevent the replacement in case there already was this element in the branch, and the result is the same? better to ignore this detail on first attempt. — Will Ness, Nov 12 '17 at 16:40

Work with binary search trees in Racket

1 Answers1