Binary Search-使用二叉搜索树
终于到二叉树了,每次面试时最担心面试官问题这块的算法问题,所以接下来就要好好攻克它~
关于二叉树的定义网上一大堆,这篇做为二叉树的开端,先了解一下基本概念,直接从网上抄袭:
先了解下树的概念,balabala~~:
更通俗的定义:
而二叉树就是树结构的一个经典树,也是要讨论的主题,下面再来看下二叉树的定义:
而用二叉树主要是用来干嘛呢?上次不是学习过了一个利用递归实现折半查找的算法(http://www.cnblogs.com/webor2006/p/7182756.html)么?而当时实现的前提是数列一定得有序,那如果数列是无序的,但是也想对它进行搜索,那就可以给它创建一个结构:二叉搜索树,它是二叉树的一种,那它的具体定义是怎么样的?
这里从两个围度来理解:
1、如何构建一个二叉搜索树?
给出一组元素:【5、8、3、4、1、7、6】,构建过程如下:
第一步:将第一个元素【5】做为根结点:
第二步:把第二个元素【8】拿出来与第一个元素做比较,如果比根节点大就放在右边,如果比根节点小就放在左边,由于8>5,则放在5的右边,如下:
第三步:同样的道理 拿出来第三个元素【3】再与根节点进行比较,结果如下:
第四步:上一步已经把二叉树的第二层填满了,接下来的元素【4】首先要与根节点进行比较,再与子树的节点进行比较,如下:
第五步:按照以上的方式,把接下来的元素依次插入到树中即可,下面是剩下元素的整个构建过程:
2、如何从二叉搜索树中查找一个元素?
比如搜“7”这个元素:
1、拿7跟根结点5比,比它大,则搜5的右节点,左节点抛弃;
2、拿7跟8比,比它小,所以必然是在8的左子孙里面,刚好就搜到了。
比如搜“2”这个元素:
1、拿2跟根结点5比,比它小,则搜5的左节点,右节点抛弃;
2、拿2跟3比,比它小,则搜3的左节点,右节点抛弃;
3、拿2跟1比,比它大,则需要转到1的右子孙里找,但是1没有右子孙所以2没有在这个树中,也就是未找到。
有了上面的思路之后,下面来看下具体代码实现,为了方便这里采用JAVA实现:
第一步:构建一个二叉搜索树:
public class BinarySearchTree { TreeNode root = null; class TreeNode{ int value; int position; TreeNode left = null, right = null; TreeNode(int value, int position){ this.value = value; this.position = position; } } public void add(int value, int position){ if(root == null){//生成一个根结点 root = new TreeNode(value, position); } else { //生成叶子结点 add(value, position, root); } } private void add(int value, int position, TreeNode node){ if(node == null) throw new RuntimeException("treenode cannot be null"); if(node.value == value) return; //ignore the duplicated value if(value < node.value){ if(node.left == null){ node.left = new TreeNode(value, position); }else{ add(value, position, node.left); } }else{ if(node.right == null){ node.right = new TreeNode(value, position); }else{ add(value, position, node.right); } } } //打印构建的二叉搜索树 static void printTreeNode(TreeNode node) { if(node == null) return; System.out.println("node:" + node.value); if(node.left != null) { printTreeNode(node.left); } if(node.right != null) { printTreeNode(node.right); } } public static void main(String[] args) { BinarySearchTree bst = new BinarySearchTree(); int a[] = { 5, 8, 3, 4, 1, 7, 6}; for(int i = 0; i < a.length; i++){ bst.add(a[i], i); } printTreeNode(bst.root); } }
编译运行:
刚好跟之前分析结果一样:
下面分析下具体构造流程:
Loop1:
其第一个add(int value, int position)的参数为:value=5、position=0;
①、,判断root结点是否为null,条件为真,执行循环体:root = TreeNode(5, 0);
#######################################################################
Loop2:
其第一个add(int value, int position)的参数为:value=8、position=1;
①、,判断root结点是否为null,条件为假,执行②;
②、,调用第二个add(int value, int position, TreeNode node)方法:add(8, 1, root=TreeNode(5, 0));
③、,其条件为假,继续执行④;
④、,其中要添加的元素在二叉树中木有重复,也就是得保证二叉树中不可能有相同的元素条件为假,继续⑤;
⑤、,判断要插入的值是否比指定的结点小,8 < 5 为假,继续⑥
⑥、
a、判断右接点是否为空,条件为真,于是乎直接生成右接点:node.right = TreeNode(8, 1)
所以此时的二叉树结果如下:
#######################################################################
Loop3:
其第一个add(int value, int position)的参数为:value=3、position=2;
①、,判断root结点是否为null,条件为假,执行②;
②、,调用第二个add(int value, int position, TreeNode node)方法:add(3, 2, root=TreeNode(5, 0));
③、,其条件为假,继续执行④;
④、,其中要添加的元素在二叉树中木有重复,也就是得保证二叉树中不可能有相同的元素条件为假,继续⑤;
⑤、,判断要插入的值是否比指定的结点小,3 < 5 为真,执行条件体:
a、判断左接点是否为空,条件为真,于是乎直接生成左接点:node.left = TreeNode(3, 2)
所以此时的二叉树结果如下:
#######################################################################
Loop4:
其第一个add(int value, int position)的参数为:value=4、position=3;
①、,判断root结点是否为null,条件为假,执行②;
②、,调用第二个add(int value, int position, TreeNode node)方法:add(4, 3, root=TreeNode(5, 0));
③、,其条件为假,继续执行④;
④、,其中要添加的元素在二叉树中木有重复,也就是得保证二叉树中不可能有相同的元素条件为假,继续⑤;
⑤、,判断要插入的值是否比指定的结点小,4 < 5 为真,执行条件体:
a、判断左接点是否为空,条件为假,执行b;
b、add(4, 3, node.left=(3, 2));继续递归:
b③、,其条件为假,继续执行④;
b④、,其中要添加的元素在二叉树中木有重复,也就是得保证二叉树中不可能有相同的元素条件为假,继续⑤;
b⑤、,判断要插入的值是否比指定的结点小,4 < 3 为假,继续执行⑥;
b⑥、
a、判断右接点是否为空,条件为真,于是乎直接生成右接点:node.right = TreeNode(4, 3)
所以此时的二叉树结果如下:
#######################################################################
Loop5:
其第一个add(int value, int position)的参数为:value=1、position=4;
①、,判断root结点是否为null,条件为假,执行②;
②、,调用第二个add(int value, int position, TreeNode node)方法:add(1, 4, root=TreeNode(5, 0));
③、,其条件为假,继续执行④;
④、,其中要添加的元素在二叉树中木有重复,也就是得保证二叉树中不可能有相同的元素条件为假,继续⑤;
⑤、,判断要插入的值是否比指定的结点小,1 < 5 为真,执行条件体:
a、判断左接点是否为空,条件为假,执行b;
b、add(1, 5, node.left=(3, 2));继续递归:
b③、,其条件为假,继续执行④;
b④、,其中要添加的元素在二叉树中木有重复,也就是得保证二叉树中不可能有相同的元素条件为假,继续⑤;
b⑤、,判断要插入的值是否比指定的结点小,1 < 3 为真,执行循环体;
a、判断左接点是否为空,条件为真,于是乎直接生成左接点:node.left = TreeNode(1, 4)
所以此时的二叉树结果如下:
#######################################################################
Loop6:
其第一个add(int value, int position)的参数为:value=7、position=5;
①、,判断root结点是否为null,条件为假,执行②;
②、,调用第二个add(int value, int position, TreeNode node)方法:add(7, 5, root=TreeNode(5, 0));
③、,其条件为假,继续执行④;
④、,其中要添加的元素在二叉树中木有重复,也就是得保证二叉树中不可能有相同的元素条件为假,继续⑤;
⑤、,判断要插入的值是否比指定的结点小,7 < 5 为假,继续执行⑥:
⑥、
a、判断右接点是否为空,条件为假,于是执行b;
b、add(7, 5, node.right=(8, 1));继续递归:
b③、,其条件为假,继续执行④;
b④、,其中要添加的元素在二叉树中木有重复,也就是得保证二叉树中不可能有相同的元素条件为假,继续⑤;
b⑤、,判断要插入的值是否比指定的结点小,7 < 8 为真,执行循环体;
a、判断左接点是否为空,条件为真,于是乎直接生成左接点:node.left = TreeNode(7, 5)
所以此时的二叉树结果如下:
#######################################################################
Loop7:
其第一个add(int value, int position)的参数为:value=6、position=6;
①、,判断root结点是否为null,条件为假,执行②;
②、,调用第二个add(int value, int position, TreeNode node)方法:add(6, 6, root=TreeNode(5, 0));
③、,其条件为假,继续执行④;
④、,其中要添加的元素在二叉树中木有重复,也就是得保证二叉树中不可能有相同的元素条件为假,继续⑤;
⑤、,判断要插入的值是否比指定的结点小,6 < 5 为假,继续执行⑥:
⑥、
a、判断右接点是否为空,条件为假,于是执行b;
b、add(6, 6, node.right=(8, 1));继续递归:
b③、,其条件为假,继续执行④;
b④、,其中要添加的元素在二叉树中木有重复,也就是得保证二叉树中不可能有相同的元素条件为假,继续⑤;
b⑤、,判断要插入的值是否比指定的结点小,6 < 8 为真,执行循环体;
a、判断左接点是否为空,条件为假,继续执行b;
b、add(6, 6, node.right=(7, 5));继续递归:
bb③、,其条件为假,继续执行④;
bb④、,其中要添加的元素在二叉树中木有重复,也就是得保证二叉树中不可能有相同的元素条件为假,继续⑤;
bb⑤、,判断要插入的值是否比指定的结点小,6 < 7 为真,执行循环体;
a、判断左接点是否为空,条件为真,于是乎直接生成左接点:node.left = TreeNode(6, 6)
所以此时的二叉树结果如下:
#######################################################################
于此二叉搜索树就已经完成了~~上面过程有点繁锁,重在体会!!!
第二步:从二叉树中进行数查找:
public class BinarySearchTree { TreeNode root = null; class TreeNode{ int value; int position; TreeNode left = null, right = null; TreeNode(int value, int position){ this.value = value; this.position = position; } } public void add(int value, int position){ if(root == null){//生成一个根结点 root = new TreeNode(value, position); } else { //生成叶子结点 add(value, position, root); } } private void add(int value, int position, TreeNode node){ if(node == null) throw new RuntimeException("treenode cannot be null"); if(node.value == value) return; //ignore the duplicated value if(value < node.value){ if(node.left == null){ node.left = new TreeNode(value, position); }else{ add(value, position, node.left); } }else{ if(node.right == null){ node.right = new TreeNode(value, position); }else{ add(value, position, node.right); } } } //打印构建的二叉搜索树 static void printTreeNode(TreeNode node) { if(node == null) return; System.out.println("node:" + node.value); if(node.left != null) { printTreeNode(node.left); } if(node.right != null) { printTreeNode(node.right); } } //搜索结点 public int search(int value){ return search(value, root); } private int search(int value, TreeNode node){ if(node == null) return -1; //not found else if(value < node.value){ System.out.println("Searching left"); return search(value, node.left); } else if(value > node.value){ System.out.println("Searching right"); return search(value, node.right); } else return node.position; } public static void main(String[] args) { BinarySearchTree bst = new BinarySearchTree(); int a[] = { 5, 8, 3, 4, 1, 7, 6}; for(int i = 0; i < a.length; i++){ bst.add(a[i], i); } // printTreeNode(bst.root); System.out.println(bst.search(8)); System.out.println(bst.search(3)); System.out.println(bst.search(6)); System.out.println(bst.search(30)); } }
编译运行:
从上面运行结果中,拿搜6来说,只经过了三部:右、左、左,就从无序的数组中找到了,可见其效率是非常高的,最后会对其复杂度进行分析的,下面先来分析一下整个查找的过程:
这里就以经过最多步找到“6”为例进行分析吧,
①、search(6, root=TreeNode(5, 0))
②、,其条件不满足,继续执行③;
③、,6 < 5条件为假,执行④;
④、,6 > 5条件为真,执行条件体:
打印一下“Searching right”;然后search(6, node.right=TreeNode(8, 0))继续递归:
④②、,其条件不满足,继续执行③;
④③、,6 < 8条件为真,执行条件体:
打印一下“Searching left”;然后search(6, node.left=TreeNode(7, 5))继续递归:
④③②、,其条件不满足,继续执行③;
④③③、,6 < 7条件为真,执行条件体:
打印一下“Searching left”;然后search(6, node.left=TreeNode(6, 6))继续递归:
④③③②、,其条件不满足,继续执行③;
④③③③、,6 < 6条件为假,继续执行④:
④、,6 > 6条件为假,继续执行⑤:
⑤、,搜索到了结果直接返回,整个递归结束。
时间复杂度分析:
如果写一个循环,从前匹配到尾,那时间复杂度是O(n),但是使用二叉树来搜索,它的复杂度肯定是小于n的,是跟树的深度有关的,每次递归一次树则向下走一层,那这个二叉搜索树的时间复杂度重点就是看一下树的深度是多少了,是多少呢?log ^ n ,所以说二叉搜索树查找的时间复杂度是O(log ^ n);