算法导论示例-BinarySearchTree

原创 2006年06月09日 00:28:00
/**
 * Introduction to Algorithms, Second Edition 
 * 12 Binary Search Trees
 * @author 土豆爸爸
 * 
 */
import java.util.ArrayList;
import java.util.List;

public class BinarySearchTree {
    /**
     * 数据节点
     */
    public static class Node {
        int key;
        Node parent; //父节点
        Node left; //左子节点
        Node right; //右子节点
        
        public Node(int key) {
            this.key = key;
        }
    }
    
    private Node root;
    
    /**
     * 采用递归法查找键值为k的节点。
     * @param k 节点的键值
     * @return 返回键值为k的节点
     */
    public Node search(int k) {
        return search(root, k);
    }
    
    /**
     * 采用递归法查找键值为k的节点。
     * @param x 当前节点
     * @param k 节点的键值
     * @return 返回键值为k的节点
     */
    private Node search(Node x, int k) {
        if(x == null || k == x.key) {
            return x;
        } else if(k < x.key) {
            return search(x.left, k);
        } else {
            return search(x.right, k);
        }
    }
    
    /**
     * 采用迭代法查找键值为k的节点。
     * @param x 当前节点
     * @param k 节点的键值
     * @return 返回键值为k的节点
     */
    public Node iterativeSearch(int k) {
        return iterativeSearch(root, k);
    }
    
    /**
     * 采用迭代法查找键值为k的节点。
     * @param x 当前节点
     * @param k 节点的键值
     * @return 返回键值为k的节点
     */
    private Node iterativeSearch(Node x, int k) {
        while(x != null && k != x.key) {
            if(k < x.key) {
                x = x.left;
            } else {
                x = x.right;
            }
        }
        return x;
    }
    
    /**
     * 返回树的最小键值的节点。
     * @return 最小键值的节点
     */
    public Node minimum() {
        return minimum(root);
    }
    
    /**
     * 返回树的最小键值的节点。
     * @param x 当前节点
     * @return 最小键值的节点
     */
    private Node minimum(Node x) {
        while(x.left != null) {
            x = x.left;
        }
        return x;
    }
    
    /**
     * 返回树的最大键值的节点。
     * @return 最大键值的节点
     */
    public Node maximum() {
        return maximum(root);
    }
    
    /**
     * 返回树的最大键值的节点。
     * @param x 当前节点
     * @return 最大键值的节点
     */
    private Node maximum(Node x) {
        while(x.right != null) {
            x = x.right;
        }
        return x;
    }
    
    /**
     * 返回指定节点x的后继节点。
     * @param x 当前节点
     * @return x的后继节点;如果x具有最大键值,返回null
     */
    public Node successor(Node x) {
        if(x.right != null) {
            return minimum(x);
        }
        Node y = x.parent;
        while(y != null && x == y.right) {
            x = y;
            y = y.parent;
        }
        return y;
    }
    
    /**
     * 返回指定节点x的前驱节点。
     * @param x 当前节点
     * @return x的前驱节点;如果x具有最小键值,返回null
     */
    public Node predecessor(Node x) {
        if(x.left != null) {
            return maximum(x);
        }
        Node y = x.parent;
        while(y != null && x == y.left) {
            x = y;
            y = y.parent;
        }
        return y;
    }
    
    /**
     * 插入节点。
     * @param z 待插入节点
     */
    public void insert(Node z) {
        Node y = null; //当前节点的父节点
        Node x = root; //当前节点
        while(x != null) { //迭代查寻z应该所在的位置
            y = x;
            if(z.key < x.key) {
                x = x.left;
            } else {
                x = x.right;
            }
        }
        z.parent = y;
        if(y == null) { 
            root = z; //如果没有父节点,则插入的节点是根节点。
        } else if(z.key < y.key) {
            y.left = z;
        } else {
            y.right = z;
        }
    }
    
    /**
     * 删除节点。
     * @param z 待删除节点
     */
    public Node delete(Node z) {
        Node y = null;
        Node x = null;
        if (z.left == null || z.right == null) {
            y = z;
        } else {
            y = successor(z);
        }

        if (y != null) {
            x = y.left;
        } else {
            x = y.right;
        }

        if (x != null) {
            x.parent = y.parent;
        }

        if (y.parent == null) {
            root = x;
        } else if (y == y.parent.left) {
            y.parent.left = x;
        } else {
            y.parent.right = x;
        }

        if (y != z) { //如果z包含两个子节点,用y替换z的位置
            y.parent = z.parent;
            if (z == z.parent.left) {
                z.parent.left = y;
            } else {
                z.parent.right = y;
            }

            y.left = z.left;
            y.right = z.right;
        }
        return y;
    }
    
    /**
     * 中序历遍。即从小到大排序。
     * @return 返回已排序的节点列表
     */
    public List<Node> inorderWalk() {
        List<Node> list = new ArrayList<Node>();
        inorderWalk(root, list);
        return list;
    }
    
    /**
     * 中序历遍。
     * @param x 当前节点
     * @param list 历遍结果存储在list中
     */
    private void inorderWalk(Node x, List<Node> list) {
        if(x != null) {
            inorderWalk(x.left, list);
            list.add(x);
            inorderWalk(x.right, list);
        }
    }
}

import java.util.List;

import junit.framework.TestCase;

public class BinarySearchTreeTest extends TestCase {
    public void testLinkedList() {
        BinarySearchTree tree = new BinarySearchTree();
        // 插入100个随机节点
        for (int i = 0; i < 100; i++) {
            int key = (int) (Math.random() * 1000);
            if (tree.search(key) == null) {
                tree.insert(new BinarySearchTree.Node(key));
            }
        }

        verifyOrdered(tree.inorderWalk());
        
        BinarySearchTree.Node node = null;
        for (int i = 0; i < 1000; i++) {
            node = tree.search(i);
            if (node != null) {
                break;
            }
        }
        assertNotNull(node);
        tree.delete(node);
        assertEquals(null, tree.search(node.key));
        
        verifyOrdered(tree.inorderWalk());
    }
    
    private boolean verifyOrdered(List<BinarySearchTree.Node> list) {
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i - 1).key > list.get(i).key) {
                return false;
            }
        }
        return true;
    }
}

相关文章推荐

根据树的前序遍历、中序遍历、后序遍历中的两种遍历求第三种遍历结果

学过数据结构,都知道二叉树有四种遍历手段,前序遍历、中序遍历、后序遍历以及层序遍历,而前三种遍历存在较强的关联,即:知道中序遍历及另外两种遍历中的一种时,可以求第三种,简单的讲就是根据中序遍历和前序遍...
  • f_zyj
  • f_zyj
  • 2016年04月15日 00:08
  • 1673

链式哈希表(Hash Table)--算法导论示例

In computer science, a hash table is an associative array data structure that associates keys with v...

算法导论 之 B树(B-树) - 创建、插入[C语言]

在计算机科学中,B树在查找、访问、插入、删除操作上时间复杂度为O(log2~n)(2为底数 n为对数),不像自平衡二叉查找树,其可以有效的优化系统对大块的数据读写的性能,其通常在数据库和文件系统中被使...

【算法导论之六】二叉排序树(Binary Search Tree)

1. 二叉排序树的定义     它或者是一棵空树;或者是具有下列性质的二叉树:            (1)若左子树不空,则左子树上所有结点的值均小于它的根结点的值;            (2)...

二叉查找树(来自算法导论)

#include using namespace std; typedef struct TreeNode{ int val; TreeNode*left; TreeNode*r...
  • huruzun
  • huruzun
  • 2014年03月13日 15:56
  • 664

《算法导论》15-3:编辑距离

(1)初始化: cost[i][0] = deleteCost * i cost[0][j] = insertCost * i(2)递推公式: (3)kill操作 public class...

算法导论—中位数与顺序统计量

华电北风吹 天津大学认知计算与应用重点实验室 日期:2015/7/7 一、选择最大值或者最小值的最优算法 对于长度为n的数组,已证找最大值或者最小值比较操作下界就是n-1。所以只需要让第一个...

《算法导论》第12章 二叉查找树

摘要:   本章介绍了二叉查找树的概念及操作。主要内容包括二叉查找树的性质,如何在二叉查找树中查找最大值、最小值和给定的值,如何找出某一个元素的前驱和后继,如何在二叉查找树中进行插入和删除操作。在二...

【算法导论】02——渐近符号、递归及解法

渐近符号 1、Θ记号  Θ(g(n)) = { f(n) : 若存在正常数c1,c2和n0,使对所有n>=n0时有0 其效果相当于删除f(n)中的低阶项,并忽略最高阶项的系数。 ...
  • muyimo
  • muyimo
  • 2014年07月27日 22:10
  • 727
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:算法导论示例-BinarySearchTree
举报原因:
原因补充:

(最多只允许输入30个字)