CSCI 1120 (Low-Level Computing), Fall 2021:
Homework 9

Credit:

20 points.

Reading

Be sure you have read, or at least skimmed, the assigned readings for classes through 11/10.

Programming Problems

Do the following programming problems. You will end up with at least one code file per problem. Submit your program source (and any other needed files) one of two ways:

• using my mail-files script, linked from the course Web site under “Links”.
• by putting them in your course “TurnIn” folder on Google Drive. (Note that I want plain-text files, ideally with an extension appropriate for the language -- e.g., .c for C -- but if Google Drive balks at that, rename to have an extension of .txt. I want something I can compile as is, except for possibly a change of filename. So no screenshots!)

You can develop your programs on any system that provides the needed functionality, but I will test them on one of the department's Linux machines, so you should probably make sure they work in that environment before turning them in.

1. (20 points) Your mission for this assignment is to complete a partial implementation in C of a binary search tree (a.k.a. sorted binary tree) of ints. (I'm hoping that many of you know about this data structure from CS2 or another course. However, I'm aware that several of you are not in CS2; if that's you, be advised that one of the video lectures in group 12 is an introduction that I hope will be enough for you to do this assignment. Or this Wikipedia article is a reasonable description (but I really recommend that you not read the example code until you try to write your own).

   This partial implementation consists of a number of files:

   • Function declarations for tree: int-bst.h.
   • Starter file for function definitions: int-bst.c.
   • Test program and supporting files: test-int-bst.c, test-helper.c, test-helper.h.
   • Makefile for compiling (comments in the file tell you how to use it): Makefile.
   I've made a ZIP file containing all of these files, so it will probably be simplest just to download that and unzip it (command unzip on our machines). If you prefer to download individual files, NOTE that you should use your browser's “download” or “save” function to obtain the Makefile rather than copying and pasting text. This is because copy-and-paste will likely replace the tab characters in the file with spaces, with bad consequences (since tabs are semantically significant in makefiles.)

   NOTE that downloading files if you're using department computers remotely is problematical. You can do this from the commmand line if you have the full URL, however, using command wget. For example, to get the ZIP file:

   wget http://www.cs.trinity.edu/~bmassing/Classes/CS1120_2020spring/Homeworks/HW09/Problems/hw9.zip

   NOTE that this assignment really kind of relies on your having access to make. If you're not able to make (ha!) that work, talk to me about options. It's a big help if you also have access to valgrind; if you can't easily set that up, again, talk to me about options.

   Your job is to modify the file int-bst.c so it includes function definitions for all the functions declared in int-bst.h. The test program is self-contained and contains code to call the functions you will write, so you don't need to write any input/output code, aside from implementing two print functions. You compile the test program by typing make test-int-bst and run it by typing ./test-int-bst.

   Note that the function that removes a single element of the tree (int_bst_remove) is optional; you can provide an “implementation” that just prints an error message, or for extra credit you can actually implement this operation.

   You should not modify any other files, unless you want to add additional tests to test-int-bst.c.

   Sample output of the test program:
   

   inserting 40 into tree [ ]
   result [ 40 ]
   inserting 30 into tree [ 40 ]
   result [ 30 40 ]
   inserting 50 into tree [ 30 40 ]
   result [ 30 40 50 ]
   inserting 20 into tree [ 30 40 50 ]
   result [ 20 30 40 50 ]
   inserting 60 into tree [ 20 30 40 50 ]
   result [ 20 30 40 50 60 ]
   inserting 16 into tree [ 20 30 40 50 60 ]
   result [ 16 20 30 40 50 60 ]
   inserting 14 into tree [ 16 20 30 40 50 60 ]
   result [ 14 16 20 30 40 50 60 ]
   inserting 18 into tree [ 14 16 20 30 40 50 60 ]
   result [ 14 16 18 20 30 40 50 60 ]
   inserting 24 into tree [ 14 16 18 20 30 40 50 60 ]
   result [ 14 16 18 20 24 30 40 50 60 ]
   inserting 56 into tree [ 14 16 18 20 24 30 40 50 60 ]
   result [ 14 16 18 20 24 30 40 50 56 60 ]
   inserting 64 into tree [ 14 16 18 20 24 30 40 50 56 60 ]
   result [ 14 16 18 20 24 30 40 50 56 60 64 ]
   inserting 30 into tree [ 14 16 18 20 24 30 40 50 56 60 64 ]
   result [ 14 16 18 20 24 30 40 50 56 60 64 ]
   inserting 50 into tree [ 14 16 18 20 24 30 40 50 56 60 64 ]
   result [ 14 16 18 20 24 30 40 50 56 60 64 ]
   test data in order [ 14 16 18 20 24 30 30 40 50 50 56 60 64 ]
   40
     30
       20
         16
           14
             .
             .
           18
             .
             .
         24
           .
           .
       .
     50
       .
       60
         56
           .
           .
         64
           .
           .
   finding 0 in tree [ 14 16 18 20 24 30 40 50 56 60 64 ]
   result false
   finding 100 in tree [ 14 16 18 20 24 30 40 50 56 60 64 ]
   result false
   finding 10 in tree [ 14 16 18 20 24 30 40 50 56 60 64 ]
   result false
   finding 40 in tree [ 14 16 18 20 24 30 40 50 56 60 64 ]
   result true
   finding 14 in tree [ 14 16 18 20 24 30 40 50 56 60 64 ]
   result true
   finding 64 in tree [ 14 16 18 20 24 30 40 50 56 60 64 ]
   result true
   removing 0 from tree [ 14 16 18 20 24 30 40 50 56 60 64 ]
   result [ 14 16 18 20 24 30 40 50 56 60 64 ]
   removing 16 from tree [ 14 16 18 20 24 30 40 50 56 60 64 ]
   result [ 14 18 20 24 30 40 50 56 60 64 ]
   removing 60 from tree [ 14 18 20 24 30 40 50 56 60 64 ]
   result [ 14 18 20 24 30 40 50 56 64 ]
   removing 30 from tree [ 14 18 20 24 30 40 50 56 64 ]
   result [ 14 18 20 24 40 50 56 64 ]
   removing 50 from tree [ 14 18 20 24 40 50 56 64 ]
   result [ 14 18 20 24 40 56 64 ]
   40
     20
       14
         .
         18
           .
           .
       24
         .
         .
     64
       56
         .
         .
       .
   inserting 0 into tree [ 14 18 20 24 40 56 64 ]
   result [ 0 14 18 20 24 40 56 64 ]
   inserting 100 into tree [ 0 14 18 20 24 40 56 64 ]
   result [ 0 14 18 20 24 40 56 64 100 ]
   inserting 0 into tree [ 0 14 18 20 24 40 56 64 100 ]
   result [ 0 14 18 20 24 40 56 64 100 ]
   inserting 100 into tree [ 0 14 18 20 24 40 56 64 100 ]
   result [ 0 14 18 20 24 40 56 64 100 ]
   after removing all elements [ ]
   

   Output of the “print as tree” function is a bit obscure. Described recursively, it works as follows:
   • For an empty tree, print “.”.
   • For a non-empty tree, first print its root and then print its two subtrees, each indented two spaces.
   Partially annotated output:
   

   40 <-- root
     30 <-- left child of 40
       20 <-- left child of 30
         16
           14
             .
             .
           18
             .
             .
         24
           .
           .
       . <-- right child of 30 (empty)
     50 <-- right child of 40
       . <-- left child of 50 (empty)
       60 <-- right child of 60
         56
           .
           .
         64
           .
           .
   

   It may be worth noting that my code for “remove” does something a bit tricky that I don't really expect yours to do: For nodes with two children, one can replace the node with either the largest element to its left or the smallest to the right; my code alternates between the two. I do not expect you to do this too, so your results if you implement “remove” may differ from mine.

   Hints:

   • There are several functions you need to write -- the ones declared in int-bst.h. You might start by just writing stub versions that return something (anything) if they need to and otherwise do nothing; then you can compile and try the test program. It won't do anything very meaningful, but at least you can check that you know how to compile and run it. Then start filling in the functions one at a time, checking that each works or at least compiles before going on to the next.
   • You may want to add additional “helper” functions, but if so they should go only in int-bst.c. (This might be particularly useful for the “print as tree” function.)
   • You may find it helpful to look more closely at the sorted-list example shown in the video lectures and available on the course Web site under“sample programs”; it's meant to be a model for one way to implement a linked data structure in C, and the functions you need to write code for are meant to be tree versions of functions in sorted-int-list.c. It's up to you whether to use recursion or iteration or both, but I advise that recursion will probably be much easier for the two functions that print the tree and is effective for the others as well.
   • I recommend that at some point you run the completed test program with valgrind to check that you don't have memory leaks.

   What to turn in: Just send me your int-bst.c file, unless you added more tests to test-int-bst.c, in which case send that too (but be sure your code works with the provided version as well).

Pledge

This should include the Honor Code pledge, or just the word “pledged”, plus at least one of the following about collaboration and help (as many as apply). Text in italics is explanatory or something for you to fill in; you don't need to repeat it!

• I did not get outside help aside from course materials, including starter code, readings, sample programs, the instructor.
• I worked with names of other students on this assignment.
• I got help with this assignment from source of help -- ACM tutoring, another student in the course, etc. (Here, “help” means significant help, beyond a little assistance with tools or compiler errors.)
• I got help from outside source -- a book other than the textbook (give title and author), a Web site (give its URL), etc.. (Here too, you only need to mention significant help -- you don't need to tell me that you looked up an error message on the Web, but if you found an algorithm or a code sketch, tell me about that.)
• I provided help to names of students on this assignment. (And here too, you only need to tell me about significant help.)

Essay

This should be a brief essay (a sentence or two is fine, though you can write as much as you like) telling me what if anything you think you learned from the assignment, and what if anything you found interesting, difficult, or otherwise noteworthy.