二叉树排序及二叉树节点的增删改查（java实现）

此处为二叉树节点类

package search.binaryTreeSearch;
/**
 * 二叉树节点
 * @author jeker-chen
 *
 */
public class Node {
	int data;
	Node leftNode ;
	Node rightNode ;
	public Node(int data, Node leftNode, Node rightNode) {
		super();
		this.data = data;
		this.leftNode = leftNode;
		this.rightNode = rightNode;
	}
	public Node() {
		super();
	}
	public Node(int data) {
		super();
		this.data = data;
	}
	
	
}

二叉排序树类

package search.binaryTreeSearch;

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

/**
 * 二叉树类
 * 
 * @author jeker-chen
 *
 */
public class BinaryTree {
	private static Node orignNode = new Node();

	/**
	 * 插入节点
	 * 
	 * @param 要插入的节点
	 * @param orign
	 *            目标节点
	 */
	public void InsertTree(Node node, Node orign) {
		if (node.data < orign.data) {
			if (orign.leftNode != null) {
				InsertTree(node, orign.leftNode);
			} else {
				orign.leftNode = new Node(node.data);
			}
		} else if (node.data > orign.data) {
			if (orign.rightNode != null) {
				InsertTree(node, orign.rightNode);
			} else {
				orign.rightNode = new Node(node.data);
			}
		} else {
			// do nothing
		}
	}

	/**
	 * 二叉树查找
	 * 
	 * @param mubiao
	 *            所要查找的数据
	 * @param orign
	 *            二叉树的根节点
	 */
	public Map<Node, Node> searchNode(int mubiao, Node orign, Node father) {
		if (orign == null) {
			System.out.println("查找节点不存在！");
			return null;
		}
		if (orign.data == mubiao) {
			Map<Node, Node> map = new HashMap<>();
			map.put(orign, father);
			return map;
		} else if (orign.data < mubiao) {
			return searchNode(mubiao, orign.rightNode, orign);
		} else {
			return searchNode(mubiao, orign.leftNode, orign);
		}
	}

	/**
	 * 删除二叉树中指定的元素
	 * 
	 * @param orign
	 *            二叉树根节点
	 * @param mubiao
	 *            索要删除节点的数据
	 */
	public void deleteNode(Map<Node, Node> nodeMap) {
		Node mubiao = nodeMap.keySet().iterator().next();
		Node father = nodeMap.get(mubiao);
		// 若不存在左子树
		if (mubiao.leftNode == null) {
			// 将右子节点的数据赋值给目标节点
			if (father.leftNode == mubiao) {
				father.leftNode = mubiao.rightNode;
			} else {
				father.rightNode = mubiao.rightNode;
			}
		} else if (mubiao.rightNode == null) {
			if (father.leftNode == mubiao) {
				father.leftNode = mubiao.leftNode;
			} else {
				father.rightNode = mubiao.leftNode;
			}
		} else {
			Node left = mubiao.leftNode;
			if (left.rightNode == null) {
				father.leftNode = mubiao.leftNode;
				mubiao = null;
			} else {
				father = left;
				// 获得目标节点相邻节点
				while (left.rightNode != null) {
					father = left;
					left = left.rightNode;
				}
				mubiao.data = left.data;
				father.rightNode = null;
			}
		}
	}

	public Node Create(List<Integer> integers) {
		for (int i = 0; i < integers.size(); i++) {
			if (i == 0) {
				orignNode.data = integers.get(i);
			} else {
				Node node = new Node(integers.get(i));
				InsertTree(node, orignNode);
			}
		}
		return orignNode;
	}

	/*
	 * 前序遍历二叉树的节点
	 */
	public void preorderTraversal(Node T, int level) {
		if (T != null) {
			System.out.println(T.data + "在第" + level + "层");
			preorderTraversal(T.leftNode, level + 1);
			preorderTraversal(T.rightNode, level + 1);
		}
	}

	public static void main(String[] args) {
		BinaryTree binaryTree = new BinaryTree();
		List<Integer> integers = new LinkedList<>();
		integers.add(5);
		integers.add(7);
		integers.add(3);
		integers.add(1);
		integers.add(2);
		integers.add(6);
		integers.add(4);
		
		binaryTree.Create(integers);
		binaryTree.preorderTraversal(orignNode, 0);
		System.out.println("=====================");
		Map<Node, Node> nodeMap = binaryTree.searchNode(1, orignNode, orignNode);
		// System.out.println(node.data);
		System.out.println(nodeMap.keySet().iterator().next().data);
		System.out.println(nodeMap.get(nodeMap.keySet().iterator().next()).data);
		binaryTree.deleteNode(nodeMap);
		binaryTree.preorderTraversal(orignNode, 0);

	}

}

---

关注笔者公众号，推送各类原创/优质技术文章 ⬇️