树结构
在计算机科学中,树(英语:tree)是一种抽象数据类型(ADT)或是实作这种抽象数据类型的数据结构,用来模拟具有树状结构性质的数据集合。它是由n(n>0)个有限节点组成一个具有层次关系的集合。
二叉树
二叉树(英语:Binary tree)是每个节点最多只有两个分支(即不存在分支度大于2的节点)的树结构。通常分支被称作“左子树”或“右子树”。二叉树的分支具有左右次序,不能随意颠倒。
二叉搜索树(Binary Search Tree)
二叉查找树相比于其他数据结构的优势在于查找、插入的时间复杂度较低。为O(log n)。二叉查找树是基础性数据结构,用于构建更为抽象的数据结构,如集合、多重集、关联数组等。
- 若任意节点的左子树不空,则左子树上所有节点的值均小于它的根节点的值;
- 若任意节点的右子树不空,则右子树上所有节点的值均大于它的根节点的值;
- 任意节点的左、右子树也分别为二叉查找树;
- 没有键值相等的节点。
java实践
1. 简单书写
ps:这里要注意一点,由于二叉搜索树要求存入的元素必须有可比性,所以我们选择继承Comparable,让泛型具有可比性。我们这里的二分搜索树是假定不允许有相同元素存在的,当然你要允许也不影响
public class BST<E extends Comparable<E>> { private class Node { public E e; public Node left, right; public Node(E e) { this.e = e; left = null; right = null; } } private Node root; private int size; public BST(){ root = null; size = 0; } public int size(){ return size; } public boolean isEmpty(){ return size == 0; } }
2. 添加新元素
这里用到递归性要好实现一些,递归要先考虑递归的终止条件,然后再书写递归的函数。
// 向二分搜索树中添加新的元素e public void add(E e){ if(root == null){ root = new Node(e); size ++; } else add(root, e); } // 向以node为根的二分搜索树中插入元素e,递归算法 private void add(Node node, E e){ if(e.equals(node.e)) return; else if(e.compareTo(node.e) < 0 && node.left == null){ node.left = new Node(e); size ++; return; } else if(e.compareTo(node.e) > 0 && node.right == null){ node.right = new Node(e); size ++; return; } if(e.compareTo(node.e) < 0) add(node.left, e); else //e.compareTo(node.e) > 0 add(node.right, e); }
优化策略
这里我们把NUll看成一个树,就不需要管
if(root == null){ root = new Node(e); size ++; }
这个条件了
// 向二分搜索树中添加新的元素e public void add(E e){ root = add(root, e); } // 向以node为根的二分搜索树中插入元素e,递归算法 // 返回插入新节点后二分搜索树的根 private Node add(Node node, E e){ if(node == null){ size ++; return new Node(e); } if(e.compareTo(node.e) < 0) node.left = add(node.left, e); else if(e.compareTo(node.e) > 0) node.right = add(node.right, e); return node; }
3. 查找元素
和插入类似
// 看二分搜索树中是否包含元素e public boolean contains(E e){ return contains(root, e); } // 看以node为根的二分搜索树中是否包含元素e, 递归算法 private boolean contains(Node node, E e){ if(node == null) return false; if(e.compareTo(node.e) == 0) return true; else if(e.compareTo(node.e) < 0) return contains(node.left, e); else // e.compareTo(node.e) > 0 return contains(node.right, e); }
4. 遍历操作
深度优先遍历
深度优先遍历的基本思想:对每一个可能的分支路径深入到不能再深入为止,而且每个结点只能访问一次。深度优先遍历的非递归的通用做法是采用栈。要特别注意的是,二分搜索树的深度优先遍历比较特殊,可以细分为前序遍历、中序遍历、后序遍历。1.前序遍历:先访问当前节点,再依次递归访问左右子树 ,访问到前面节点才继续 2.中序遍历:先递归访问左子树,再访问自身,再递归访问右子树,访问到中间节点才继续 3.后序遍历:先递归访问左右子树,再访问自身节点,访问到后面节点才继续
例如,对于下面的这个二分搜索树,其前序遍历结果是:28 16 13 22 30 29 42,其中序遍历结果是:13 16 22 28 29 30 42,其后序遍历结果是:13 22 16 29 42 30 28。分为前序遍历,中序遍历,后序遍历
- 前序遍历
public void preOrder(){ preOrder(root); } // 前序遍历以node为根的二分搜索树, 递归算法 private void preOrder(Node node){ if(node == null) return; System.out.println(node.e); preOrder(node.left); preOrder(node.right); }
2.中序遍历
public void inOrder(){ inOrder(root); } // 中序遍历以node为根的二分搜索树, 递归算法 private void inOrder(Node node){ if(node == null) return; inOrder(node.left); System.out.println(node.e); inOrder(node.right); }
3.后序遍历
public void postOrder(){ postOrder(root); } // 后序遍历以node为根的二分搜索树, 递归算法 private void postOrder(Node node){ if(node == null) return; postOrder(node.left); postOrder(node.right); System.out.println(node.e); }
- 非递归实现前序遍历 先把root节点压入其中,再取出节点,取出节点后,我们再看该节点有无左右子树,有则压入,无则取出下一个节点,这里注意一点,由于栈是先入后出,所以这里先压右子树,再压左子树。
public void preOrderNR(){ if(root == null) return; Stack<Node> stack = new Stack<>(); stack.push(root); while(!stack.isEmpty()){ Node cur = stack.pop(); System.out.println(cur.e); if(cur.right != null) stack.push(cur.right); if(cur.left != null) stack.push(cur.left); } }
广度优先遍历
深度优先遍历的基本思想:从上往下对每一层依次访问,在每一层中,从左往右(也可以从右往左)访问结点,访问完一层就进入下一层,直到没有结点可以访问为止。广度优先遍历的非递归的通用做法是采用队列。从根节点开始入队,出队后,该节点有无左右子树,有则从左到右一个个入队,然后再从队列里出队
public void levelOrder(){ if(root == null) return; Queue<Node> q = new LinkedList<>(); q.add(root); while(!q.isEmpty()){ Node cur = q.remove(); System.out.println(cur.e); if(cur.left != null) q.add(cur.left); if(cur.right != null) q.add(cur.right); } }
5. 删除节点
删除节点比较麻烦,这里进行拆解
删除最大最小值
先寻找二分搜索树的最小(大)元素,看改节点左(右)子树是否为空,若为空,则为最小(大)元素
再进行删除,1,该节点无左右子树,自接进行删除 2,该节点有左(右)子树,删除后进行拼接(类似于链表删除节点的拼接)
// 寻找二分搜索树的最小元素 public E minimum(){ if(size == 0) throw new IllegalArgumentException("BST is empty"); Node minNode = minimum(root); return minNode.e; } // 返回以node为根的二分搜索树的最小值所在的节点 private Node minimum(Node node){ if( node.left == null ) return node; return minimum(node.left); } // 寻找二分搜索树的最大元素 public E maximum(){ if(size == 0) throw new IllegalArgumentException("BST is empty"); return maximum(root).e; } // 返回以node为根的二分搜索树的最大值所在的节点 private Node maximum(Node node){ if( node.right == null ) return node; return maximum(node.right); } // 从二分搜索树中删除最小值所在节点, 返回最小值 public E removeMin(){ E ret = minimum(); root = removeMin(root); return ret; } // 删除掉以node为根的二分搜索树中的最小节点 // 返回删除节点后新的二分搜索树的根 private Node removeMin(Node node){ if(node.left == null){ Node rightNode = node.right; node.right = null; size --; return rightNode; } node.left = removeMin(node.left); return node; } // 从二分搜索树中删除最大值所在节点 public E removeMax(){ E ret = maximum(); root = removeMax(root); return ret; } // 删除掉以node为根的二分搜索树中的最大节点 // 返回删除节点后新的二分搜索树的根 private Node removeMax(Node node){ if(node.right == null){ Node leftNode = node.left; node.left = null; size --; return leftNode; } node.right = removeMax(node.right); return node; } 删除任意元素
1.该节点有左(或者右)子树或者无子树为空,删除后进行拼接(类似于链表删除节点的拼接) 2.删除左右子树都有的节点,这里采用Hibbard Deletion方法。先删除该节点,对查找出该节点的左子树的最大(右子树的最小)元素(这里就可以复用上面的代码),然其代替该删除的节点
// 从二分搜索树中删除元素为e的节点 public void remove(E e){ root = remove(root, e); } // 删除掉以node为根的二分搜索树中值为e的节点, 递归算法 // 返回删除节点后新的二分搜索树的根 private Node remove(Node node, E e){ if( node == null ) return null; if( e.compareTo(node.e) < 0 ){ node.left = remove(node.left , e); return node; } else if(e.compareTo(node.e) > 0 ){ node.right = remove(node.right, e); return node; } else{ // e.compareTo(node.e) == 0 // 待删除节点左子树为空的情况 if(node.left == null){ Node rightNode = node.right; node.right = null; size --; return rightNode; } // 待删除节点右子树为空的情况 if(node.right == null){ Node leftNode = node.left; node.left = null; size --; return leftNode; } // 待删除节点左右子树均不为空的情况 // 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点 // 用这个节点顶替待删除节点的位置 Node successor = minimum(node.right); successor.right = removeMin(node.right); successor.left = node.left; node.left = node.right = null; return successor; } }
原文:https://mp.weixin.qq.com/s/DWguYPi3Y3cBIPB7qa8Rqg作者: 原映雪来源:微信公众号
免费分享java技术资料,需要的朋友可以在关注后私信我