手写实现二叉树
最近被各种树各种摧残,还好如今挺过来了。今天试着自己写一个二叉树。
参考来源: https://zhuanlan.zhihu.com/p/90309039
树的节点属性类
一个二叉树,要知道左侧节点,和右侧节点,和值,这样能知道,二叉树的所有节点,左侧节点小于右侧节点的特性。
public class Node {
/**
* 值
*/
int value;
/**
* 右子树节点
*/
Node rightNode;
/**
* 左子树节点
*/
Node leftNode;
public Node(int value, Node rightNode, Node leftNode) {
this.value = value;
this.rightNode = rightNode;
this.leftNode = leftNode;
}
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public Node getRightNode() {
return rightNode;
}
public void setRightNode(Node rightNode) {
this.rightNode = rightNode;
}
public Node getLeftNode() {
return leftNode;
}
public void setLeftNode(Node leftNode) {
this.leftNode = leftNode;
}
}
二叉树新增
public class BinaryTree {
private static Node rootNode;
/**
* 新增节点
* @param currentNode
* @param value
* @return
*/
public static Node addNode(Node currentNode, int value){
if(currentNode == null){
return new Node(value,null,null);
}
if(currentNode.getValue() < value){
currentNode.rightNode = addNode(currentNode.getRightNode(),value);
}
if(currentNode.getValue() > value){
currentNode.leftNode = addNode(currentNode.getLeftNode(),value);
}
return currentNode;
}
public static void main(String[] args) {
rootNode = addNode(rootNode,8);
rootNode = addNode(rootNode,18);
rootNode = addNode(rootNode,3);
rootNode = addNode(rootNode,5);
rootNode = addNode(rootNode,3);
rootNode = addNode(rootNode,6);
rootNode = addNode(rootNode,9);
rootNode = addNode(rootNode,2);
}
删除节点
删除是二叉树比较特殊的操作,删除后还是要满足从左到右,依此值变大。
有三种情况:
1.被删除的节点,没有子节点,此时直接删除即可
2.被删除的节点,有一个节点,此时将存在的节点返回
3.被删除的节点,存在两个子节点,由于二叉树的排序特性,右侧节点,比左侧节点值大,所以将右侧最左的节点,替换到将要删除的节点,次是可以保证从左到右依此值变大。
package com.searchtree.BinaryTree;
import java.util.LinkedList;
public class BinaryTree {
private static Node rootNode;
/**
* 删除节点
* @param currentNode
* @param value
*/
public static Node deleteNode(Node currentNode, int value){
if(currentNode == null){
return currentNode;
}
if(currentNode.getValue() == value){
//被删除节点的左右子节点都为空
if(currentNode.rightNode == null && currentNode.leftNode == null){
return null;
}
//被删除节点有一个子节点
if(currentNode.rightNode == null){
return currentNode.leftNode;
}
if(currentNode.leftNode == null){
return currentNode.rightNode;
}
//被删除节点有两个子节点。
//获取节点最小值
int minValue = getLeftNodeValue(currentNode.rightNode);
//将最小值替换到删除的节点
currentNode.setValue(minValue);
//删除替换的节点
currentNode.rightNode = deleteNode(currentNode.rightNode,minValue);
}
if(currentNode.getValue() > value){
currentNode.leftNode = deleteNode(currentNode.leftNode,value);
}
if(currentNode.getValue() < value){
currentNode.rightNode = deleteNode(currentNode.rightNode,value);
}
return currentNode;
}
/**
* 获取节点最小值
* @param currentNode
* @return
*/
public static int getLeftNodeValue(Node currentNode){
if(currentNode.leftNode != null){
return getLeftNodeValue(currentNode.leftNode);
}
return currentNode.getValue();
}
public static void main(String[] args) {
rootNode = deleteNode(rootNode,8);
}
}
查询二叉树中是否有特定值
public class BinaryTree {
private static Node rootNode;
/**
* 查询树中是否有特定值
* @param currentNode
* @param value
* @return
*/
public static boolean containsNodeRecursive(Node currentNode,int value){
boolean flag = false;
if(currentNode == null){
return false;
}
if(currentNode.getValue() > value){
flag =containsNodeRecursive(currentNode.leftNode,value);
}
if(currentNode.getValue() < value){
flag = containsNodeRecursive(currentNode.rightNode,value);
}
if(currentNode.getValue() == value){
return true;
}
return flag;
}
public static void main(String[] args) {
System.out.println(containsNodeRecursive(rootNode,1));
System.out.println(containsNodeRecursive(rootNode,10));
System.out.println(containsNodeRecursive(rootNode,18));
System.out.println(containsNodeRecursive(rootNode,2));
}
从最左侧节点开始遍历树
public class BinaryTree {
private static Node rootNode;
/**
* 遍历 从最左侧节点开始
* @param currentNode
*/
public static void traverseInOrder(Node currentNode){
if(currentNode != null){
traverseInOrder(currentNode.leftNode);
System.out.print(currentNode.getValue()+ "--");
traverseInOrder(currentNode.rightNode);
}
}
public static void main(String[] args) {
System.out.print("从最左侧节点开始遍历:");
traverseInOrder(rootNode);
}
}
首先访问根节点,然后是左子树,最后是右子树
public class BinaryTree {
private static Node rootNode;
/**
* 首先访问根节点,然后是左子树,最后是右子树
* @param currentNode
*/
public static void traversePreOrder(Node currentNode){
if(currentNode != null){
System.out.print(currentNode.getValue()+ "--");
traversePreOrder(currentNode.leftNode);
traversePreOrder(currentNode.rightNode);
}
}
public static void main(String[] args) {
System.out.print("首先访问根节点,然后是左子树,最后是右子树:");
traversePreOrder(rootNode);
}
}
访问左子树,右子树,最后访问根节点
public class BinaryTree {
private static Node rootNode;
/**
* 访问左子树,右子树,最后访问根节点
* @param currentNode
*/
public static void traversePostOrder(Node currentNode){
if(currentNode != null){
traversePostOrder(currentNode.leftNode);
traversePostOrder(currentNode.rightNode);
System.out.print(currentNode.getValue()+ "--");
}
}
public static void main(String[] args) {
System.out.print("访问左子树,右子树,最后访问根节点:");
traversePostOrder(rootNode);
}
}
按层级遍历
public class BinaryTree {
private static Node rootNode;
/**
* 按层级遍历
* @param currentNode
*/
public static void traverseLevelOrder(Node currentNode){
if(currentNode == null){
return ;
}
LinkedList<Node> nodes = new LinkedList();
nodes.add(currentNode);
while (!nodes.isEmpty()){
Node node = nodes.remove();
System.out.print(node.getValue()+ "--");
if(node.leftNode != null){
nodes.add(node.leftNode);
}
if(node.rightNode != null){
nodes.add(node.rightNode);
}
}
}
public static void main(String[] args) {
System.out.print("按层级遍历:");
traverseLevelOrder(rootNode);
}
}