added travels.c - meant to implement the depth first and breadth first routines

Author: U-SANTHOSH-PC\SANTHOSH

Binary-Trees/Makefile

@@ -14,22 +14,22 @@ CFLAGS = -O0 -g -std=c99 -Wall -Wextra -Wshadow -pedantic -Werror
 CXXFLAGS = -O0 -g -std=c++11 -Wall -Wextra -Wshadow -pedantic -Weffc++ -Werror
 # define any directories containing header files other than /usr/include
 #
-INCLUDES = 
+INCLUDES =
 
 # define library paths in addition to /usr/lib
 #   if I wanted to include libraries not in /usr/lib I'd specify
 #   their path using -Lpath, something like:
-LFLAGS = 
+LFLAGS =
 
 # define any libraries to link into executable:
-#   if I want to link in libraries (libx.so or libx.a) I use the -llibname 
+#   if I want to link in libraries (libx.so or libx.a) I use the -llibname
 #   option, something like (this will link in libmylib.so and libm.so:
-LIBS = 
+LIBS =
 
 # define the C source files
-SRCS = main.c utilityFunctions.c stanfordProblems.c graphVizPrintBST.c
+SRCS = main.c utilityFunctions.c stanfordProblems.c graphVizPrintBST.c  traversals.c
 
-# define the C object files 
+# define the C object files
 #
 # This uses Suffix Replacement within a macro:
 #   $(name:string1=string2)
@@ -39,11 +39,11 @@ SRCS = main.c utilityFunctions.c stanfordProblems.c graphVizPrintBST.c
 #
 OBJS = $(SRCS:.c=.o)
 
-# define the executable file 
+# define the executable file
 MAIN = binaryTreeExe
 
 #
-# The following part of the makefile is generic; it can be used to 
+# The following part of the makefile is generic; it can be used to
 # build any executable just by changing the definitions above and by
 # deleting dependencies appended to the file from 'make depend'
 #
@@ -53,12 +53,12 @@ MAIN = binaryTreeExe
 all: $(MAIN)
 	@echo  $(MAIN) has been compiled
 
-$(MAIN): $(OBJS) 
+$(MAIN): $(OBJS)
 	$(CC) $(CFLAGS) $(INCLUDES) -o $(MAIN) $(OBJS) $(LFLAGS) $(LIBS)
 
 # this is a suffix replacement rule for building .o's from .c's
 # it uses automatic variables $<: the name of the prerequisite of
-# the rule(a .c file) and $@: the name of the target of the rule (a .o file) 
+# the rule(a .c file) and $@: the name of the target of the rule (a .o file)
 # (see the gnu make manual section about automatic variables)
 .c.o:
 	$(CC) $(CFLAGS) $(INCLUDES) -c $<  -o $@
@@ -71,4 +71,4 @@ depend: $(SRCS)
 
 # DO NOT DELETE THIS LINE -- make depend needs it
 
-# Tutorial: http://www.cs.swarthmore.edu/~newhall/unixhelp/howto_makefiles.html
+# Tutorial: http://www.cs.swarthmore.edu/~newhall/unixhelp/howto_makefiles.html

Binary-Trees/binaryTree.h

@@ -3,6 +3,7 @@
 #include <stdbool.h> // true and false
 #include <stdio.h>
 #include <stdlib.h>
+#include <limits.h> // INT_MAX etc
 
 struct node {
     int data;
@@ -14,10 +15,10 @@ int lookup(struct node* node, int target);
 int lookup_nonRecursive(struct node* node, int target);
 struct node* NewNode(int data);
 struct node* insert(struct node* node, int data);
-struct node* insert_nonRecursive(struct node* node, int data)
+struct node* insert_nonRecursive(struct node* node, int data);
 struct node* build123();
 void bst_print_dot(struct node* tree, FILE* stream);
 struct node* buildN(int n);
 void deleteTree(struct node** node_ref);
-
+void structure ( struct node *tree );
 #endif

Binary-Trees/main.c

@@ -3,13 +3,16 @@
 /*
 http://cslibrary.stanford.edu/110/BinaryTrees.html
 */
+void graphviz_tree(struct node* tree){
+  FILE *fp;
+  fp = fopen("./tree.dot", "w+");
+  bst_print_dot(tree, fp);
+  printf("%s\n", "run: dot -Tpng tree.dot -o tree.png");
+  fclose(fp);
+}
 
 int main( void ) {
-    FILE *fp;
-    fp = fopen("./tree.dot", "w+");
     struct node* tree = build123();
-    bst_print_dot(tree, fp);
-    printf("%s\n", "run: dot -Tpng tree.dot -o tree.png");
-    fclose(fp);
+    structure(tree);
     deleteTree(&tree);
 }

Binary-Trees/stanfordProblems.c

@@ -5,21 +5,21 @@ struct node* build123(){
     root = insert(root, 2);
     root = insert(root, 1);
     root = insert(root, 3);
-    return(root); 
+    return(root);
 }
 
 struct node* buildN(int n){
     struct node* root = NULL;
     for (int i=1; i<=n ; i++ ) {
         insert(root, i);
     }
-    return(root); 
+    return(root);
 }
 
 /*
  Compute the number of nodes in a tree.
 */
-int size(struct node* node) { 
+int size(struct node* node) {
     if( node == NULL ) {
         return 0;
     }
@@ -46,78 +46,77 @@ int maxDepth(struct node* node) {
  return the minimum data value found in that tree.
  Note that the entire tree does not need to be searched.
 */
-int minValue(struct node* node) { 
+int minValue(struct node* node) {
     struct node* current = node;
     // loop down to find the leftmost leaf
     while (current->left != NULL) {
         current = current->left;
     }
-    return(current->data); 
+    return(current->data);
 }
 
 /*
  Given a non-empty binary search tree,
  return the maximum data value found in that tree.
  Note that the entire tree does not need to be searched.
 */
-int maxValue(struct node* node) { 
+int maxValue(struct node* node) {
     struct node* current = node;
     // loop down to find the leftmost leaf
     while (current->right != NULL) {
         current = current->right;
     }
-    return(current->data); 
+    return(current->data);
 }
 
 /*
  Given a binary search tree, print out
  its data elements in increasing
  sorted order.
- This is known as an "inorder" traversal of the tree. 
+ This is known as an "inorder" traversal of the tree.
 */
-void printTree(struct node* node) { 
+void printTree(struct node* node) {
     if (node == NULL) return;
     printTree(node->left);
     printf("%d ", node->data);
-    printTree(node->right); 
+    printTree(node->right);
 }
 
 /*
- Given a binary tree, print its nodes according to the "bottom-up" postorder 
+ Given a binary tree, print its nodes according to the "bottom-up" postorder
  traversal.
--- both subtrees of a node are printed out completely before the node itself 
- is printed, and each left subtree is printed before the right subtree. 
+-- both subtrees of a node are printed out completely before the node itself
+ is printed, and each left subtree is printed before the right subtree.
 */
-void printPostorder(struct node* node) { 
+void printPostorder(struct node* node) {
     if (node == NULL) return;
     printPostorder(node->left);
     printPostorder(node->right);
     printf("%d ", node->data);
 }
 
-/* 
- Given a binary tree and a sum, return true if the tree has a root-to-leaf 
- path such that adding up all the values along the path equals the given sum. 
+/*
+ Given a binary tree and a sum, return true if the tree has a root-to-leaf
+ path such that adding up all the values along the path equals the given sum.
  Return false if no such path can be found.
 
  Strategy: subtract the node value from the sum when recurring down,
- and check to see if the sum is 0 when you run out of tree. 
+ and check to see if the sum is 0 when you run out of tree.
 */
 int hasPathSum(struct node* node, int sum) {
     if (node == NULL) return sum == 0;
     else {
-        return hasPathSum(node->left, sum - node->data) 
-               || hasPathSum(node->right, sum - node->data)
+        return hasPathSum(node->left, sum - node->data)
+               || hasPathSum(node->right, sum - node->data);
     }
 }
 
-/*
- Given a binary tree, print out all of its root-to-leaf
- paths, one per line. Uses a recursive helper to do the work.
-*/
-void printPaths(struct node* node) {
-    int path[1000]; 
-    printPathsRecur(node, path, 0);
+// Utility that prints out an array on a line.
+void printArray(int ints[], int len) {
+  int i;
+  for (i=0; i<len; i++)
+    printf("%d ", ints[i]);
+    printf("\n");
 }
 
 /*
@@ -140,18 +139,20 @@ void printPathsRecur(struct node* node, int path[], int pathLen) {
         printPathsRecur(node->right, path, pathLen);
     }
 }
-
-// Utility that prints out an array on a line.
-void printArray(int ints[], int len) {
-  int i;
-  for (i=0; i<len; i++)
-      printf("%d ", ints[i]);
-  printf("\n");
+/*
+Given a binary tree, print out all of its root-to-leaf
+paths, one per line. Uses a recursive helper to do the work.
+*/
+void printPaths(struct node* node) {
+  int path[1000];
+  printPathsRecur(node, path, 0);
 }
 
+
+
 /*
-Change a tree so that the roles of the left and right pointers are swapped 
-at every node. 
+Change a tree so that the roles of the left and right pointers are swapped
+at every node.
 */
 void mirror(struct node* node) {
     if (node==NULL) return;
@@ -164,12 +165,12 @@ void mirror(struct node* node) {
     struct node* prevRight = node->right;
     node->right = node->left;
     node->left = prevRight;
-    
+
 }
 
 /*
-For each node in a binary search tree, create a new duplicate node, 
-and insert the duplicate as the left child of the original node. 
+For each node in a binary search tree, create a new duplicate node,
+and insert the duplicate as the left child of the original node.
 */
 void doubleTree(struct node* node) {
     if (node==NULL) return;
@@ -184,16 +185,16 @@ void doubleTree(struct node* node) {
     node->left->left = prevLeft;
 }
 
-/* 
+/*
 Given two binary trees, return true if they are structurally
-identical -- they are made of nodes with the same values 
-arranged in the same way. 
+identical -- they are made of nodes with the same values
+arranged in the same way.
  */
 int sameTree(struct node* a, struct node* b) {
     if( a == NULL && b == NULL) // both empty
-        return true; 
+        return true;
     else if( a != NULL && b != NULL ) // both non-empty, so compare
-        return( (a->data == b->data) && 
+        return( (a->data == b->data) &&
                 sameTree(a->left, b->left) &&
                 sameTree(a->right, b->right) );
     else
@@ -230,7 +231,7 @@ int countTrees(int numKeys) {
 
     return(sum);
   }
-} 
+}
 
 int isBST(struct node* node) {
   if (node==NULL) return(true);
@@ -240,7 +241,7 @@ int isBST(struct node* node) {
   // (bug -- an earlier version had min/max backwards here)
   if (node->left!=NULL && maxValue(node->left) > node->data)
     return(false);
- 
+
   // false if the min of the right is <= than us
   if (node->right!=NULL && minValue(node->right) <= node->data)
     return(false);
@@ -253,19 +254,11 @@ int isBST(struct node* node) {
     return true;
 }
 
-/*
- Returns true if the given tree is a binary search tree
- (efficient version).
-*/
-int isBST2(struct node* node) {
-  return(isBSTRecur(node, INT_MIN, INT_MAX));
-}
-
 /*
  Returns true if the given tree is a BST and its
  values are >= min and <= max.
 */
-int isBSTRecur(struct node* node, int min, int max) { 
+int isBSTRecur(struct node* node, int min, int max) {
     if (node==NULL) return(true);
     if (min > node->data)
         return(false);
@@ -276,4 +269,11 @@ int isBSTRecur(struct node* node, int min, int max) {
   // false if, recursively, the left or right is not a BST
     return (isBSTRecur(node->left, min, node->data) &&
         isBSTRecur(node->right, node->data+1, max)); // note the +1
-}
+}
+/*
+Returns true if the given tree is a binary search tree
+(efficient version).
+*/
+int isBST2(struct node* node) {
+  return(isBSTRecur(node, INT_MIN, INT_MAX));
+}