打印BST-C程序

Question

I am new to C and I am learning functions and pointers. I have to print Binary search tree in the requisite format below in the t_print method and I would be really grateful some could guide me how to go about it.

I have this code till now:

typedef struct tree {
  void* data;
  struct tree* left;
  struct tree* right;
} Tree;


/*set the data on the tree node */
void  t_set_data(Tree* t, void* data) {
t->data = data;}

/*let l be the left node of tree *t */
void  t_set_left(Tree* t, Tree* l){
 t->left = l;}

/*let r be the left node of tree *t */
void  t_set_right(Tree* t, Tree* r){
 t->right = r;}

/* simply return left node of the tree */
Tree* t_left(Tree* t){
    return t-> left;}

/* simply return right node of the tree */
Tree* t_right(Tree* t){
    return t-> right;}

/* simply return the data of the tree */
void* t_data(Tree* t){
    return t->data;}

/* make the node of the tree and allocate space for it*/
Tree* t_make(){
    Tree *t = (Tree*)malloc(sizeof(tree));
    t->left=NULL;
    t->right = NULL;
    t-> data = NULL;
    return t;
    }
/* 

print the whole tree in the following format

Root is printed with zero trailing spaces to the left
Every node/subtree is printed with one additional space
Below is an example for a tree with depth 2:

Root
<space>Left-Child
<space><space>Left-Left-Child
<space><space>Left-Right-Child
<space>Right-Child 
     .... and so on ...


Use (void(* p))(function pointer) to print.

 */
void  t_print( Tree* t ,int space, void(* p)(void*) ){
}

Answer 1

It depends on the order in which you want the data printed, but for a BST, 'in order' is appropriate (as opposed to pre-order or post-order).

To print a tree 'in order', the function does:

• If the current node is not null
  • print the left sub-tree in order
  • print the current node
  • print the right sub-tree in order

The 'print the xxx sub-tree in order' operations are recursive calls to the 'print in order' function with the left or right pointer.

The algorithm for pre-order is:

• If the current node is not null
  • print the current node
  • print the left sub-tree in pre-order
  • print the right sub-tree in pre-order

The algorithm for post-order is:

• If the current node is not null
  • print the left sub-tree in post-order
  • print the right sub-tree in post-order
  • print the current node

And it really is that simple.

Well, nearly that simple...

If you want to bracket the data or otherwise make it possible to identify the tree structure, you have to work a little harder. You also typically end up with a cover function that adds a prefix (tag identifying the output) and a suffix (maybe just a newline); this is not part of the recursive printing, usually. But the core of the algorithm is as simple as described.