查找与二叉树
Posted jiaweixie
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了查找与二叉树相关的知识,希望对你有一定的参考价值。
查找与二叉树
我家园子有几棵树系列
Preface
前面我们学习了基于线性表的数据结构,如数组,链表,队列,栈等。现在我们要开始学习一种非线性的数据结构--树(tree),是不是很兴奋呢!让我们开始新的系列吧!
查找
先让我们回忆一下线性表的查找,首先最暴力的方法就是做一个线性扫描,一一对比是不是要找的值。这么做的时间复杂度显而易见的是 O(N),如表格第一行;更机智一点,我们采用二分法,首先将线性表排好顺序,然后每次对比中间的值就好了,这样做的时间复杂度就是 O(logN),如表格第二行。但上面的做法都是利用的线性数据结构,而它有致命的缺点;那就是进行动态的操作时,比如插入,删除;无法同时实现迅速的查找,只能等重新排序以后再查,效率就低了很多,无法满足日常需求(如下表)。这个时候我们的主角就闪亮登场了——二叉查找树。
二叉查找树的实现
首先我放几张图说明一下什么是二叉树,树的高度,深度等等,详细的介绍我已经放在这里,有兴趣的话也可以看看别人的博客。
图源 转载学习,如侵权则联系我删除!
废话不多说我们开始实现一颗二叉查找树(BST)吧!
[注] 为了方便理解大部分代码都提供了递归实现!
定义数据结构
public class BST<Key extends Comparable<Key>, Value>
private Node root; // root of BST
private class Node
private Key key; // sorted by key
private Value val; // associated data
private Node left, right; // left and right subtrees
private int size; // number of nodes in subtree
public Node(Key key, Value val, int size)
this.key = key;
this.val = val;
this.size = size;
/**
* Initializes an empty symbol table.
*/
public BST()
/**
* Returns the number of key-value pairs in this symbol table.
* @return the number of key-value pairs in this symbol table
*/
public int size()
return size(root);
// return number of key-value pairs in BST rooted at x
private int size(Node x)
if (x == null) return 0;
else return x.size;
中序遍历
我们知道二叉查找树的任一个节点,他的左子结点比他小,右子节点比他大,哈,那么我们只要进行一波中序遍历就可以完成数据的排序啦!
/***************************************************************************
* 中序遍历,非递归版本
***************************************************************************/
public Iterable<Key> keys()
Stack<Node> stack = new Stack<Node>();
Queue<Key> queue = new Queue<Key>();
Node x = root;
while (x != null || !stack.isEmpty())
if (x != null)
stack.push(x);
x = x.left;
else
x = stack.pop();
queue.enqueue(x.key);
x = x.right;
return queue;
/************************************************************************
* 中序遍历,递归打印
************************************************************************/
public void inOrder(Node* root)
if (root == null) return;
inOrder(root.left);
print root // 此处为伪代码,表示打印 root 节点
inOrder(root.right);
查找操作
/************************************************************************
* 非递归
************************************************************************/
Value get(Key key)
Node x = root;
while(x != null)
int cmp = key.compareTo(x.key);
if(cmp<0)
x = x.left;
else if(cmp>0)
x = x.right;
else return
x.value;
return null;
/************************************************************************
* 递归
************************************************************************/
public Value get(Key key)
return get(root, key);
private Value get(Node x, Key key)
if (x == null) return null;
int cmp = key.compareTo(x.key);
if (cmp < 0) return get(x.left, key);
else if (cmp > 0) return get(x.right, key);
else return x.val;
插入
/************************************************************************
* 非递归
************************************************************************/
public void put(Key key, Value val)
Node z = new Node(key, val);
if (root == null)
root = z;
return;
Node parent = null, x = root;
while (x != null)
parent = x;
int cmp = key.compareTo(x.key);
if (cmp < 0)
x = x.left;
else if (cmp > 0)
x = x.right;
else
x.val = val;
return;
int cmp = key.compareTo(parent.key);
if (cmp < 0)
parent.left = z;
else
parent.right = z;
/************************************************************************
* 递归版本
************************************************************************/
public void put(Key key, Value value)
root = put(root, key, value);
private Node put(Node x, Key key, Value value)
if (x == null)
return new Node(key, value, 1);
int cmp = key.compareTo(x.key);
if (cmp < 0)
x.left = put(x.left, key, value);
else if (cmp > 0)
x.right = put(x.right, key, value);
else
x.value = value;
x.size = 1 + size(x.left) + size(x.right);
return x;
删除
删除有两种方式,一种是合并删除
,另一种是复制删除
,这里我主要讲第二种,想了解第一种可以点这里
删除最小值
在正式的删除之前让我们先热身一下,看看怎么删除一棵树的最小值(如图)。
步骤
- 我们先找到最小值,即不断查找节点的左子节点,若无左节点,那他就是最小值。
- 找到最小的节点后,返回他的右子节点给上一层,最小节点会被GC机制回收
- 因为用的是递归方法,所以依次更新节点数量
public void deleteMin()
root = deleteMin(root);
private Node deleteMin(Node x)
if (x.left == null) return x.right;
x.left = deleteMin(x.left);
x.N = size(x.left) + size(x.right) + 1;
return x;
复制(拷贝)删除
在说复制删除之前,我们需要先熟悉二叉查找树的前驱和后继(根据中序遍历衍生出来的概念)。
- 前驱:A节点的前驱是其左子树中最右侧节点。
- 后继:A节点的后继是其右子树中最左侧节点。
上图是复制删除的原理,我们既可以用前驱节点 14 代替,又可以用后继节点 18 代替。
步骤
如图所示,我们分为四个步骤
- 将指向即将被删除的节点的链接保存为t;
- 将 x 指向它的后继节点
min(t.right)
; - 将 x 的右链接(原本指向一颗所有节点都大于 x.key 的二叉查找树) 指向
deleteMin(t.right)
,也就是在删除后所有节点仍然都大于 x.key 的子二叉查找树。 - 将 x 的左链接(本为空) 设为 t.left
public void delete(Key key)
root = delete(root,key);
private Node min(Node x)
if(x.left == null) return x;
else return min(x.left);
private Node delete(Node x, Key key)
if(x==null) return null;
int cmp = key.compareTo(x.key);
if(cmp < 0) x.left = delete(x.left, key);
else if(cmp > 0) x.right = delete(x.right, key);
else
if(x.right == null) return x.left;
if(x.left == null) return x.right;
Node t = x;
x = min(t.right);
x.right = deleteMin(t.right);
x.left = t.left;
x.N = size(x.left) + size(x.right) + 1;
return x;
在前面的代码中,我们总是删除node中的后继结点,这样必然会降低右子树的高度,在前面中我们知道,我们也可以使用前驱结点来代替被删除的结点。所以我们可以交替的使用前驱和后继来代替被删除的结点。
J.Culberson从理论证实了使用非对称删除, IPL(内部路径长度)的期望值是 O(n√n), 平均查找时间为 O(√n),而使用对称删除, IPL的期望值为 O(nlgn),平均查找时间为 O(lgn)。
Rank
查找节点 x 的排名
public int rank(Key key)
return rank(key, root);
private int rank(Key key, Node x)
// 返回以 x 为根节点的子树中小于x.key的数量
if(x == null) return 0;
int cmp = key.compareTo(x.key);
if(cmp<0) return rank(key,x.left);
else if(cmp>0) return 1 + size(x.left) + rank(key,x.right);
else return size(x.left);
2-3查找树
通过前面的分析我们知道,一般情况下二叉查找树的查找,插入,删除都是 O(lgn)的时间复杂度,但是二叉查找树的时间复杂度是和树的高度是密切相关的,如果我们以升序的元素进行二叉树的插入,我们会发现,此时的二叉树已经退化成链表了,查找的时间复杂度变成了 O(n),这在性能上是不可容忍的退化!那么我们该怎么解决这个问题呢?
答案相信大家都知道了,那就是构建一颗始终平衡的二叉查找树。那么有哪些平衡二叉查找树呢?如何实现?
这些我们留到下节再讲。
总结
这一节我们学会了使用非线性的数据结构--二叉查找树来高效的实现查找,插入,删除操作。分析了它的性能,在随机插入的情况下,二叉查找树的高度趋近于 2.99lgN
,平均查找时间复杂度为 1.39lgN(2lnN)
,而且在升序插入的情况下,树会退化成链表。这些知识为我们后面学习2-3查找树和红黑树打下了基础。
以上是关于查找与二叉树的主要内容,如果未能解决你的问题,请参考以下文章