Scribd
Upload
885 views24 pages

General Trees

1) General trees can be represented using nodes that point to their children via leftmost child pointers and right sibling pointers, avoiding extra space for a child count. 2) The general tree node ADT specifies functions for traversing and manipulating trees like getting children, siblings, and parents of nodes. 3) Equivalence classes of nodes can be determined by finding the root nodes that nodes point to indirectly via parent pointers. 4) General trees can be implemented using arrays or linked lists to store child nodes efficiently while supporting needed operations like getting children and siblings. 5) Sequential representations store trees in linear order which saves space but only allows sequential access; the tree structure must be reconstructed.

Uploaded by

Jeyakumar Venugopal
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
885 views24 pages

General Trees

1) General trees can be represented using nodes that point to their children via leftmost child pointers and right sibling pointers, avoiding extra space for a child count. 2) The general tree node ADT specifies functions for traversing and manipulating trees like getting children, siblings, and parents of nodes. 3) Equivalence classes of nodes can be determined by finding the root nodes that nodes point to indirectly via parent pointers. 4) General trees can be implemented using arrays or linked lists to store child nodes efficiently while supporting needed operations like getting children and siblings. 5) Sequential representations store trees in linear order which saves space but only allows sequential access; the tree structure must be reconstructed.

Uploaded by

Jeyakumar Venugopal
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 24

CS 400/600 – Data Structures

General Trees
General Trees

General Trees 2
How to access children?
• We could have a node contain an integer value
indicating how many children it points to.
• Space for each node.
• Or, we could provide a function that return the
first child of a node, and a function that returns
the right sibling of a node.
• No extra storage.

General Trees 3
Tree Node ADT
// General tree node ADT
template <class Elem> class GTNode {
public:
GTNode(const Elem&); // Constructor
~GTNode(); // Destructor
Elem value(); // Return value
bool isLeaf(); // TRUE if is a leaf
GTNode* parent(); // Return parent
GTNode* leftmost_child(); // First child
GTNode* right_sibling(); // Right
sibling
void setValue(Elem&); // Set value
void insert_first(GTNode<Elem>* n);
void insert_next(GTNode<Elem>* n);
void remove_first(); // Remove first
child
void remove_next(); // Remove sibling
};
General Trees 4
General Tree Traversal
template <class Elem>
void GenTree<Elem>::
printhelp(GTNode<Elem>* subroot) {
// Visit current node:
if (subroot->isLeaf()) cout << "Leaf: ";
else cout << "Internal: ";
cout << subroot->value() << "\n";
// Visit children:
for (GTNode<Elem>* temp =
subroot->leftmost_child();
temp != NULL;
temp = temp->right_sibling())
printhelp(temp);
}

General Trees 5
Equivalence Class Problem

The parent pointer representation is good for 
answering:
• Are two elements in the same tree?

// Return TRUE if nodes in different trees


bool Gentree::differ(int a, int b) {
int root1 = FIND(a); // Find root for a
int root2 = FIND(b); // Find root for b
return root1 != root2; // Compare roots
}

General Trees 6
Parent Pointer Implementation

General Trees 7
Union/Find

void Gentree::UNION(int a, int b) {


int root1 = FIND(a); // Find root for a
int root2 = FIND(b); // Find root for b
if (root1 != root2) array[root2] = root1;
}
int Gentree::FIND(int curr) const {
while (array[curr]!=ROOT) curr = array[curr];
return curr; // At root
}

Want to keep the depth small.


Weighted union rule: Join the tree with fewer
nodes to the tree with more nodes.
General Trees 8
Equiv Class Processing (1)

(A, B), (C, H),


(G, F), (D, E),
and (I, F)

(H, A)
and (E, G)

General Trees 9
Equiv Class Processing (2)

(H, E)

General Trees 10
Path Compression
int Gentree::FIND(int
curr) const {
if (array[curr] == ROOT)
return curr;
return array[curr] =
FIND(array[curr]);
}
(H, E)

General Trees 11
General Tree Implementations
• How efficiently can the implementation
perform the operations in our ADT?
• Leftmost_child()
• Right_sibling()
• Parent()

• If we had chosen other operations, the answer


would be different
• Next_child() or Child(i)

General Trees 12
General Tree Strategies
• Tree is in an array (fixed number of nodes)
• Linked lists of children
• Children in array (leftmost child, right sibling)
• Tree is in a linked structure
• Array list of children
• Linked lists of children

General Trees 13
Lists of Children

Not very good for


Right_sibling()

General Trees 14
Leftmost Child/Right Sibling (1)

Note, two trees share the same array.


Max number of nodes may need to be fixed.
General Trees 15
Leftmost Child/Right Sibling (2)

Joining two trees is efficient.

General Trees 16
Linked Implementations (1)

An array-based list of children.

General Trees 17
Linked Implementations (2)

A linked-list of children.

General Trees 18
Sequential Implementations (1)
List node values in the order they would be
visited by a preorder traversal.
Saves space, but allows only sequential access.
Need to retain tree structure for reconstruction.
Example: For binary trees, use a symbol to mark
null links.
AB/D//CEG///FH//I//

General Trees 19
Binary Tree Sequential Implementation
reconstruct(int& i) { AB/D//CEG///FH//I//
if (array[i] == ‘/’){
i++;
return NULL;
}
else {
newnode = new node(array[i++]);
left = reconstruct(i);
right = reconstruct(i);
return(newnode)
}
}

int i = 0;
root = reconstruct(i);

General Trees 20
Sequential Implementations (2)
Example: For full binary trees, mark nodes 
as leaf or internal.
A’B’/DC’E’G/F’HI

Space savings over


previous method by
removing double
‘/’ marks.

General Trees 21
Sequential Implementations (2)
Example: For general trees, mark the end of 
each subtree.
RAC)D)E))BF)))

General Trees 22
Converting to a Binary Tree
Left child/right sibling representation essentially
stores a binary tree.
Use this process to convert any general tree to a
binary tree.
A forest is a collection of one or more general
trees.

General Trees 23
Converting to a Binary Tree
• Binary tree left child A
= leftmost child
B
• Binary tree right child
C
= right sibling
D
A
F E
B C D E G H

I
F G H
J
I J
General Trees 24

You might also like