Table of contents
Binary search tree level traversal
src/runoob/binary/LevelTraverse.java file code:
Binary search tree level traversal
The level-order traversal of the binary search tree is to traverse layer by layer, that is, the nodes of each layer are stored in the queue, and then the operations of dequeuing (removing nodes) and enqueuing (depositing nodes of the next layer) are performed to achieve traversal the goal of.
Support level-order traversal by introducing a queue:
-
If the root node is empty, there is no way to traverse;
-
If the root node is not empty:
-
First add the root node to the queue;
-
As long as the queue is not empty:
- Dequeue the first node and traverse;
- If the first node of the team has a left child, add the left child to the team;
- If the first node of the team has a right child, add the right child to the team;
-
The following steps are demonstrated below:
(1) First take out the root node and put it into the queue
(2) Take out 29, and join the left and right child nodes in the queue
(3) Team leader 17 leaves the team, and child nodes 14 and 23 join the team.
(4) 31 leaves the team, and child nodes 30 and 43 join the team.
(5) Finally everyone leaves the team
Core code example:
...
// Level order traversal of binary search tree
public void levelOrder(){ // We use LinkedList as our queue LinkedList<Node> q = new LinkedList<Node>(); q.add(root); while ( !q.isEmpty() ){ Node node = q.remove(); System.out.println(node.key); if( node.left != null ) q.add( node.left ); if( node .right != null ) q.add( node.right ); } } ...
Java example code
Source code package download: Download
src/runoob/binary/LevelTraverse.java file code:
package runoob.binary;
import java.util.LinkedList;
/**
* Level-order traversal
*/
public class LevelTraverse<Key extends Comparable<Key>, Value>{ // The nodes in the tree are private classes and do not need to be understood by the outside world. The specific implementation of binary search tree nodes private class Node { private Key key; private Value value; private Node left, right; public Node(Key key, Value value) { this.key = key; this.value = value; left = right = null; } } private Node root; // Root node private int count; // Number of nodes in the tree // Constructor, constructs an empty binary search tree by default public LevelTraverse() {
root = null;
count = 0;
}
// Returns the number of nodes in the binary search tree
public int size() { return count; } // Returns whether the binary search tree is empty public boolean isEmpty() { return count == 0; } // Insert a new (key, value) data pair into the binary search tree public void insert(Key key, Value value){ root = insert(root, key, value); } // Check whether the binary search tree The key key exists public boolean contain(Key key){ return contain(root, key); } // Search the value corresponding to the key key in the binary search tree. If this value does not exist, null is returned public Value search(Key key){ return search(root, key);
}
// Pre-order traversal of binary search tree
public void preOrder(){ preOrder(root); } // In-order traversal of binary search tree public void inOrder(){ inOrder(root); } // Post-order traversal of binary search tree Order traversal public void postOrder(){ postOrder(root); } // Level order traversal of binary search tree public void levelOrder(){ // We use LinkedList as our queue LinkedList<Node> q = new LinkedList<Node> (); q.add(root); while( !q.isEmpty() ){ Node node = q.remove(); System.out.println(node.key); if( node.left != null )
q.add( node.left );
if( node.right != null )
q.add( node.right );
}
}
//************************ *
//* Auxiliary function of binary search tree
//********************
// Insert node (key, value), use recursive algorithm
// Return the root of the binary search tree after inserting the new node
private Node insert(Node node, Key key, Value value){ if( node == null ){ count ++; return new Node(key , value); } if( key.compareTo(node.key) == 0 ) node.value = value; else if( key.compareTo(node.key) < 0 )
node.left = insert( node.left , key, value);
else // key > node->key
node.right = insert( node.right, key, value);
return node;
}
// View with node as the root Whether the binary search tree contains the node with the key value, use the recursive algorithm
private boolean contain(Node node, Key key){ if( node == null ) return false; if( key.compareTo(node.key) == 0 ) return true; else if( key.compareTo(node.key) < 0 ) return contain( node.left , key ); else // key > node->key return contain( node.right , key ); } / / Find the value corresponding to the key in the binary search tree with node as the root, recursive algorithm
// If value does not exist, return NULL
private Value search(Node node, Key key){ if( node == null ) return null; if( key.compareTo(node.key) == 0 ) return node.value; else if( key.compareTo(node.key) < 0 ) return search( node.left , key ); else // key > node->key return search( node.right, key ); } // For node The root binary search tree performs pre-order traversal, recursive algorithm private void preOrder(Node node){ if( node != null ){ System.out.println(node.key); preOrder(node.left); preOrder(node .right); } }
// Perform in-order traversal of the binary search tree rooted at node, recursive algorithm
private void inOrder(Node node){ if( node != null ){ inOrder(node.left); System.out.println(node. key); inOrder(node.right); } } // Perform post-order traversal on the binary search tree rooted at node, recursive algorithm private void postOrder(Node node){ if( node != null ){ postOrder(node .left); postOrder(node.right); System.out.println(node.key); } } }