二叉树
二叉树的定义
二叉树也是一种动态的数据结构。每个节点只有两个叉，也就是两个孩子节点，分别叫做左孩子，右孩子，而没有一个孩子的节点叫做叶子节点。每个节点最多有一个父亲节点，最多有两个孩子节点(也可以没有孩子节点或者只有一个孩子节点)。对于二叉树的定义我们不通过复杂的数学表达式来叙述，而是通过简单的描述，让大家了解一个二叉树长什么样子。
1 只有一个根节点。
2 每个节点至多有两个孩子节点，分别叫左孩子或者右孩子。(左右孩子节点没有大小之分哦)
3 每个子树也都是一个二叉树
满足以上三条定义的就是一个二叉树。如下图所示，就是一颗二叉树
二叉树的类型
- 根据二叉树的节点分布大概可以分为以下三种二叉树：完全二叉树，满二叉树，平衡二叉树。对于以下树的描述不使用数学表达式或者专业术语，因为那样很难让人想象到一棵树到底长什么样子。
满二叉树： 从根节点到每一个叶子的结点距离相同所经过的节点数都是相同的。
如下图所示就是一颗满二叉树。
完全二叉树： 除去最后一层叶子节点，就是一颗完全二叉树，并且最后一层的节点只能集中在左侧。 - 对于上面的性质，我们从另一个角度来说就是将满二叉树的叶子节点从右往左删除若干个后就变成了一棵完全二叉树，也就是说，满二叉树一定是一棵完全二叉树，反之不成立。如下图所示：除了图3都是一棵完全二叉树。
平衡二叉树： 平衡二叉树又被称为AVL树（区别于AVL算法），它是一棵二叉树，又是一棵二分搜索树，平衡二叉树的任意一个节点的左右两个子树的高度差的绝对值不超过1，即左右两个子树都是一棵平衡二叉树。
二分搜索树
1 二分搜索树是一颗二叉树
2 二分搜索树每个节点的左子树的值都小于该节点的值，每个节点右子树的值都大于该节点的值
3 任意一个节点的每棵子树都满足二分搜索树的定义
二分搜索树种每个节点的值都要大于其左子树所有节点的值，小于其右子树所有节点的值，每一棵子树也是二分搜索树。正因为二分搜索树的这种性质，二分搜索树存储的元素必须具有可比较性。下图就是一棵二分搜索树：
我们可以根据二分搜索树的特点，构建一颗二分搜索树，代码实现如下：
/**
* 由于二分搜索树中的元素必须具有可比较性，所以二分搜索树中存储的数据必须要实现Comparable接口
* @param <E>
*/
package com.wj;
import java.util.LinkedList;
import java.util.Queue;
public class BST<Key extends Comparable<Key>, Value> {
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;
this.left = this.right = null;
}
}
private Node root;//根节点
private int count;
public BST() {
root = null;
count = 0;
}
public void insert(Key key, Value value) {
root = insert(root, key, value);
}
public boolean containsKey(Key key) {
return containsKey(root, key);
}
public Value get(Key key){
Node node = get(root, key);
if (node != null) {
return node.value;
}
return null;
}
private Node get(BST<Key, Value>.Node node, Key key) {
if (null == node) return null;
if (key.compareTo(node.key) == 0) {
return node;
} else if (key.compareTo(node.key) < 0) {
return get(node.left, key);
} else {
return get(node.right, key);
}
}
// 二分搜索树的前序遍历
public void preOrder(){
preOrder(root);
}
// 二分搜索树的中序遍历
public void inOrder(){
inOrder(root);
}
// 二分搜索树的后序遍历
public void postOrder(){
postOrder(root);
}
//层序遍历
public void leaveOrder() {
Queue<Node> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
Node node = queue.poll();
System.out.print(node.key + " ");
if (null != node.left) {
queue.add(node.left);
}
if (null != node.right) {
queue.add(node.right);
}
}
}
//查找最小节点key
public Key findMin(){
if (null == root) return null;
return findMin(root).key;
}
//查找最大节点key
public Key findMax(){
if (null == root) return null;
return findMax(root).key;
}
//删除最小值
public void deleteMin() {
root = deleteMin(root);
}
//删除最大值
public void deleteMax() {
root = deleteMax(root);
}
//删除任意值
public void remove(Key key){
root = remove(root, key);
}
public void remove2(Key key){
root = remove2(root, key);
}
private BST<Key, Value>.Node remove(BST<Key, Value>.Node node, Key key) {
if (null == node) return null;
if (key.compareTo(node.key) < 0) {
node.left = remove(node.left, key);
return node;
} else if (key.compareTo(node.key) > 0) {
node.right = remove(node.right, key);
return node;
} else {
if (node.left == null) {
Node nodeRight = node.right;
node.right = null;
--count;
return nodeRight;
} else if (node.right == null) {
Node nodeLeft = node.left;
node.left = null;
--count;
return nodeLeft;
} else {
Node nodeRightMin = findMin(node.right);
nodeRightMin.right = deleteMin(node.right);
nodeRightMin.left = node.left;
return nodeRightMin;
}
}
}
private BST<Key, Value>.Node remove2(BST<Key, Value>.Node node, Key key) {
if (null == node || !containsKey(key)) return node;
//获取key位置
Node currentNode = get(node, key);
if (currentNode.left == null) {
currentNode = currentNode.right;
currentNode.right = null;
--count;
} else if (currentNode.right == null) {
currentNode = currentNode.left;
currentNode.left = null;
--count;
} else {
Node nodeRightMin = findMin(currentNode.right);
nodeRightMin.right = deleteMin(currentNode.right);
nodeRightMin.left = currentNode.left;
currentNode = nodeRightMin;
}
return node;
}
private Node deleteMax(BST<Key, Value>.Node node) {
if (node.right == null) {
Node leftNode = node.left;
node.left = null;
--count;
return leftNode;
}
node.right = deleteMax(node.right);
return node;
}
private Node deleteMin(BST<Key, Value>.Node node) {
if (node.left == null) {
Node nodeRight = node.right;
node.right = null;
--count;
return nodeRight;
}
node.left = deleteMin(node.left);
return node;
}
private Node findMax(BST<Key, Value>.Node node) {
if (node.right == null) return node;
return findMax(node.right);
}
private Node findMin(BST<Key, Value>.Node node) {
if (node.left == null) return node;
return findMin(node.left);
}
//清空二分搜索树
// public void clear() {
// System.out.println(root);
// clear(root);
root = null;
count = 0;
// }
//
// private void clear(Node node) {
// System.out.println(node);
// node = null;
// count = 0;
//
// }
private void postOrder(BST<Key, Value>.Node node) {
if (null != node) {
postOrder(node.left);
postOrder(node.right);
System.out.print(node.value + " ");
}
}
private void inOrder(BST<Key, Value>.Node node) {
if (null != node) {
inOrder(node.left);
System.out.print(node.value + " ");
inOrder(node.right);
}
}
private void preOrder(BST<Key, Value>.Node node) {
if (null != node) {
System.out.print(node.value + " ");
preOrder(node.left);
preOrder(node.right);
}
}
private boolean containsKey(BST<Key, Value>.Node node, Key key) {
if (null == node) return false;
if (key.compareTo(node.key) == 0) {
return true;
} else if (key.compareTo(node.key) < 0) {
return containsKey(node.left, key);
} else {
return containsKey(node.right, key);
}
}
private Node insert(Node node, Key key, Value value) {
if (node == null) {
++count;
return new Node(key, value);
} else if (key.compareTo(node.key) == 0) {
node.value = value;
} else if (key.compareTo(node.key) < 0) {
node.left = insert(node.left, key, value);
} else {
node.right = insert(node.right, key, value);
}
return node;
}
public static void main(String[] args) throws InterruptedException {
// Map<String, String> map = new HashMap<>();
BST<Integer, Integer> bst = new BST<>();
bst.insert(1, 1);
bst.insert(2, 2);
bst.insert(16, 16);
bst.insert(13, 13);
bst.insert(49, 49);
bst.insert(38, 38);
bst.insert(3, 3);
bst.insert(3, 3);
bst.insert(61, 61);
bst.insert(17, 17);
// bst.deleteMin();
// bst.deleteMin();
// bst.deleteMin();
// bst.deleteMax();
// bst.deleteMax();
bst.remove2(16);
System.out.println(bst.root == null);
System.out.println(bst.count);
System.out.println(bst.containsKey(3));
System.out.println(bst.get(3));
System.out.println("前驱遍历");
bst.preOrder();
System.out.println();
System.out.println("中驱遍历");
bst.inOrder();
System.out.println();
System.out.println("后驱遍历");
bst.postOrder();
System.out.println();
System.out.println("层序遍历");
bst.leaveOrder();
System.out.println();
System.out.println("最小值" + bst.findMin());
System.out.println("最大值" + bst.findMax());
}
}
2684
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
