Chapter 8 Trees Discrete Structures Notes

Below is the directed graph represented by the structure above. Each node has a substructure the consists of a node name, weight to node and a pointer to the next adjacent node from the root. Using this structure, it is possible to keep track of the nodes, the weight to the node and a list of adjacent nodes. This data structure allows us to scan a graph. If we add information on nodes visited (see below) we can keep track of the nodes visited, the adjacent nodes and the nodes that are yet to be examined. These notes are from Baase, ch 3. These are the type of structures that will be covered in Data Structures and in Analysis of Algorithms. In C++, these structures can be defined using typed or as objects with properties. C++ works well since you can define pointers as part of your node's data structure.

VSET=1 if the vertex is already include, 2 if it is adjacent to an included vertex, and tree otherwise.

This structure allows us to keep track of the final weights at each vertex as well as the vertex included, adjacent vertices and those yet to be examined.

Scanning Trees

Another structure that is useful in tracking binary trees is a node that has a right link, left link and a parent link. The pointers for the graph are listed below. With the various search methods, the pointers can be set up so that each node has a pointer to the node that comes before and after it in the given ordering. This effectively makes the tree a linked list.   

This is a representation of a binary tree. Below is a dense list that represents the same tree. There are a number of ways to scan a tree. One way is known a a left-node-right(LNR) which visits the left side, the node and the the right side, recursively. In this graph, we would have f,e,g,i,b,c,h,j,d,a. This is also known as ignored, symmetrical or lexicographical (alphabetical) scans. This is a recursive scan since as we go on, each node the we reach is in tern searched in LNR or ignored.(Note: if the left node is missing, we assume it is null and then go to the root and rigth nodes.)

Another approach is a depth-first scan also known as (preorder). In this scan, you visit the node first, then scan the left subtree as far as you can go, backup and scan the right tree, then backup up a node and repeat the process. In this case, a,b,e,f,g,i,c,h,j,d. You are in effect going down on path, backing up and going all the way down the next path. This is a recursive procedure since we repeat the dept-first search as we progress down. For example, when we reach b, we use it as the root and do a depth first search from it. When we get to e, we do a depth first search from it. When we can't go any further, we backtrack to the nearest parent (e) in the case) and go down the right side in depth first order.

Another approach is to scan in breath-first order. In this method, you start with the root, then scan level 1 from left to right, then level 2 from left to right and the the next levels the same way. In this graph, it would be a,b,e,c,f,g,h,d,i,j. You are, in effect, taking all the nodes that are 1 away from the root, 2 away, 3 away etc. in that order.

Scans like these make up an important class  problems and are studied in depth in Data Structures along with their algorithms. For this course, you should know how to scan ignored, preorder, postorder(not shown) and breath-first and depth-first scans..

You are the visitor to this site.

Return to Main Page