算法导论示例-RedBlackTree

原创 2006年06月10日 19:08:00
/**
 * Introduction to Algorithms, Second Edition 
 * 13 Red-Black Trees
 * 
 * 红黑树的条件:
 * 1.每个节点标记为“红”或“黑”。
 * 2.根标记为“黑”。
 * 3.所有叶节点(nil)标记为“黑”。
 * 4.如果一个节点为“红”,则它的两个节点都为“黑”。
 * 5.对每个的节点,从该节点至后继叶节点包含相同数量的“黑”节点。
 * @author 土豆爸爸
 * 
 */
import java.util.ArrayList;
import java.util.List;

public class RedBlackTree {
    /**
     * 数据节点
     */
    public static class Node {
        int key;
        Node parent; //父节点
        Node left; //左子节点
        Node right; //右子节点
        Color color; //节点颜色
        public Node(int key) {
            this.key = key;
        }
        
        public boolean isLeft() {
            return parent != null && parent.left == this;
        }
        
        public boolean isRight() {
            return parent != null && parent.right == this;
        }
        
        public String toString() {
            return String.valueOf(key);
        }
    }
    
    /**
     * 颜色
     */
    private enum Color { RED, BLACK};
    
    Node root; //根节点
    
    Node nil; //空节点
    
    
    /**
     * 构造函数
     */
    public RedBlackTree() {
        nil = new Node(-1);
        nil.color = Color.BLACK;
        root = nil;       
    }
    
    /**
     * 左旋转。
     * @param x 支点
     */
    private void leftRotate(Node x) {
        Node y = x.right; // y是x的右子节点
        x.right = y.left; // y的左子树转换成x的右子树
        if (y.left != nil)
            y.left.parent = x;
        y.parent = x.parent; // 用y替换x的位置
        if (x.parent == nil) {
            root = y;
        } else if (x == x.parent.left) {
            x.parent.left = y;
        } else {
            x.parent.right = y;
        }

        y.left = x; // 将x设置为y的左子节点
        x.parent = y;
    }
    
    /**
     * 右旋转。
     * @param x 支点
     */
    private void rightRotate(Node y) {
        Node x = y.left; // x是y的右子节点
        y.left = x.right; // x的右子树转换成y的左子树
        if (x.right != nil)
            x.right.parent = y;
        x.parent = y.parent; // 用x替换y的位置
        if (y.parent == nil) {
            root = x;
        } else if (y == y.parent.left) {
            y.parent.left = x;
        } else {
            y.parent.right = x;
        }

        x.right = y; // 将y设置为x的右子节点
        y.parent = x;
    }
  
    /**
     * 采用递归法查找键值为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 == nil || 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 != nil && 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 != nil) {
            x = x.left;
        }
        return x;
    }
    
    /**
     * 返回树的最大键值的节点。
     * @return 最大键值的节点
     */
    public Node maximum() {
        return maximum(root);
    }
    
    /**
     * 返回树的最大键值的节点。
     * @param x 当前节点
     * @return 最大键值的节点
     */
    private Node maximum(Node x) {
        while(x.right != nil) {
            x = x.right;
        }
        return x;
    }
    
    /**
     * 返回指定节点x的后继节点。
     * @param x 当前节点
     * @return x的后继节点;如果x具有最大键值,返回null
     */
    public Node successor(Node x) {
        if(x.right != nil) {
            return minimum(x.right);
        }
        Node y = x.parent;
        while(y != nil && 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 != nil) {
            return maximum(x.left);
        }
        Node y = x.parent;
        while(y != nil && x == y.left) {
            x = y;
            y = y.parent;
        }
        return y;
    }
    
    /**
     * 插入节点。
     * @param z 待插入节点
     */
    public void insert(Node z) {
        Node y = nil; //当前节点的父节点
        Node x = root; //当前节点
        while(x != nil) { //迭代查寻z应该所在的位置
            y = x;
            if(z.key < x.key) {
                x = x.left;
            } else {
                x = x.right;
            }
        }
        z.parent = y;
        if(y == nil) { 
            root = z; //如果没有父节点,则插入的节点是根节点。
        } else if(z.key < y.key) {
            y.left = z;
        } else {
            y.right = z;
        }
        z.left = nil;
        z.right = nil;
        z.color = Color.RED;
        insertFixup(z);
    }
    
    /**
     * 按红黑树规则进行调整。
     * @param z 待插入节点
     */
    public void insertFixup(Node z) {
        while(z.parent.color == Color.RED) { //违反条件4,并且保证z有爷爷
            if(z.parent == z.parent.parent.left) { //z的父节点是左子节点
                Node y = z.parent.parent.right;
                if(y.color == Color.RED) { //如果z的叔叔是红
                    z.parent.color = Color.BLACK; //将z的父亲和叔叔设为黑
                    y.color = Color.BLACK;
                    z.parent.parent.color = Color.RED; //z的爷爷设为红
                    z = z.parent.parent; //迭代
                } else { //如果z的叔叔是黑
                    if (z == z.parent.right) { //如果z是右子节点,左旋
                        z = z.parent;
                        leftRotate(z);
                    }
                    z.parent.color = Color.BLACK; //z的父亲为黑(叔叔为黑)
                    z.parent.parent.color = Color.RED; //z的爷爷为红
                    rightRotate(z.parent.parent); // 右旋
                }
            } else { //z的父节点是右子节点,反向对称
                Node y = z.parent.parent.left;
                if(y.color == Color.RED) {
                    z.parent.color = Color.BLACK;
                    y.color = Color.BLACK;
                    z.parent.parent.color = Color.RED;
                    z = z.parent.parent;
                } else {
                    if (z == z.parent.left) {
                        z = z.parent;
                        rightRotate(z);
                    }
                    z.parent.color = Color.BLACK;
                    z.parent.parent.color = Color.RED;
                    leftRotate(z.parent.parent);
                }
            }
        }
        root.color = Color.BLACK; //满足条件2
    }
    
    /**
     * 删除节点。
     * @param z 待删除节点
     */
    public Node delete(Node z) {
        Node y = null;
        Node x = null;
        if (z.left == nil || z.right == nil) {
            y = z;
        } else {
            y = successor(z);
        }

        if (y.left != nil) {
            x = y.left;
        } else {
            x = y.right;
        }
        
        x.parent = y.parent;
        
        if (y.parent == nil) {
            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.parent != nil) {
                if (z.isLeft()) {
                    z.parent.left = y;
                } else {
                    z.parent.right = y;
                }
            } else {
                root = y;
            }
            z.left.parent = y;
            y.left = z.left;
            z.right.parent = y;
            y.right = z.right;
        }
        
        if(y.color == Color.BLACK) {
            deleteFixup(x);
        }
        return y;
    }
    
    /**
     * 按红黑树规则进行调整。
     * @param z 待删除节点
     */
    private void deleteFixup(Node x) {
        while(x != nil && x != root && x.color == Color.BLACK) {
            if(x == x.parent.left) {
                Node w = x.parent.right;
                if(w==nil) return;
                if(w.color == Color.RED) {
                    w.color = Color.BLACK;
                    x.parent.color = Color.RED;
                    leftRotate(x.parent);
                    w = x.parent.right;
                } 
                if(w==nil) return;
                if(w.left.color == Color.BLACK && w.right.color == Color.BLACK) {
                    w.color = Color.RED;
                    x = x.parent; 
                } else {
                    if(w.right.color == Color.BLACK) {
                        w.left.color = Color.BLACK;
                        w.color = Color.RED;
                        rightRotate(w);
                        w = x.parent.right;
                    }
                    
                    w.color = x.parent.color;
                    x.parent.color = Color.BLACK;
                    w.right.color = Color.BLACK;
                    leftRotate(x.parent);
                    x = root;
                }
            } else {
                Node w = x.parent.left;
                if(w==nil) return;
                if(w.color == Color.RED) {
                    w.color = Color.BLACK;
                    x.parent.color = Color.RED;
                    rightRotate(x.parent);
                    w = x.parent.left;
                }
                if(w==nil) return;
                if(w.right.color == Color.BLACK && w.left.color == Color.BLACK) {
                    w.color = Color.RED;
                    x = x.parent;
                } else {
                    if(w.left.color == Color.BLACK) {
                        w.right.color = Color.BLACK;
                        w.color = Color.RED;
                        leftRotate(w);
                        w = x.parent.left;
                    }
                    w.color = x.parent.color;
                    x.parent.color = Color.BLACK;
                    w.left.color = Color.BLACK;
                    rightRotate(x.parent);
                    x = root;
                    
                }
            }
        }
        x.color = Color.BLACK;
    }
    
    /**
     * 中序遍历。即从小到大排序。
     * @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 != nil) {
            inorderWalk(x.left, list);
            list.add(x);
            inorderWalk(x.right, list);
        }
    }
    
    /**
     * 前序遍历打印。即从小到大排序。
     * @return 返回已排序的节点列表
     */
    public void preorderWalk() {
        preorderWalk(root);
    }
    
    /**
     * 中序遍历打印。
     * @param x 当前节点
     * @param list 遍历结果存储在list中
     */
    private void preorderWalk(Node x) {
        if(x != nil) {
            System.out.print("(");
            System.out.print(x);
            preorderWalk(x.left);
            preorderWalk(x.right);
            System.out.print(")");
        } else {
            System.out.print("N");
        }
    }
}

import java.util.List;

import junit.framework.TestCase;

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

        //测试最大值,最小值
        List<RedBlackTree.Node> list = tree.inorderWalk();
        verifyOrdered(list);
        assertEquals(count, list.size());
        assertEquals(list.get(0), tree.minimum());
        assertEquals(list.get(list.size() - 1), tree.maximum());

        //测试后继
        RedBlackTree.Node min = tree.minimum(), succ = null;
        while((succ=tree.successor(min)) != tree.nil) {
            assertTrue(succ.key > min.key);
            min = succ;
        }
        
        //测试前驱
        RedBlackTree.Node max = tree.maximum(), pre = null;
        while((pre=tree.predecessor(max)) != tree.nil) {
            assertTrue(succ.key < max.key);
            max = pre;
        }
        
        //测试删除
        int[] keys = new int[list.size()];
        for(int i = 0; i < keys.length; i++) {
            keys[i] = list.get(i).key;
        }
        
        PermuteBySorting.permute(keys);
        for (int i = 0; i < count; i++) {            
            RedBlackTree.Node node = tree.search(keys[i]);    
            assertNotNull(node);
            tree.delete(node);
            assertEquals(tree.nil, tree.search(keys[i]));
            verifyOrdered(tree.inorderWalk());
        }
    }

    private boolean verifyOrdered(List<RedBlackTree.Node> list) {
        for (int i = 1; i < list.size(); i++) {
            if (list.get(i - 1).key > list.get(i).key) {
                return false;
            }
        }
        return true;
    }
}


版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

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

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

算法导论复习(2) 归并排序

归并排序时间复杂度 平均: θ(nlgn) 最好: O (nlgn) 最坏:O(nlgn) 空间复杂度:O(1) 课本在讲归并排序之前...

算法导论二:快速排序

快速排序采用的是分治策略,其方法是将一个数组a[p,r]划分为两个子数组a[p,q-1],a[q+1,r],使其左子数组元素中的元素均小于等于a[q],右子数组元素均大于a[q],并递归划分两个子数组...

钢条切割--动态规划--算法导论

在网上看到很多钢条切割的代码,很多都是C++,用到结构体,内联函数,const变量,复杂......直接写了一段java简单的代码 import java.util.Scanner; public...

算法导论 红黑树 热身 二叉树学习(一)

学习算法 还是建议看看算法导论 算法导论第三版 如果不看数学推导 仅看伪代码 难度还是适中 本系列只是记录我的学习心得 和伪代码转化代码的过程 深入学习 还是建议大家看看算法书籍 教程更加系统。...

《算法导论》学习心得(六)—— 计数排序(Java)

计数排序是一个非基于比较的排序算法,该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时,它的复杂度为Ο(n+k)(其中k是整数的范围),快于任何比...

算法导论-红黑树C++实现

红黑树的定义: 一棵二叉查找树如果满足下面的红黑性质,则为一棵红黑树: 1)每个节点或是红的,或是黑的。 2)根节点是黑的。 3)每个叶节点(NIL)是黑节点。 4)如果一个节点是红的,则它...

算法导论 Algorithms 01 - 线性回归 Simple linear regression

/* 假设工资是6000、那麽经过迴歸分析计算、预期花红是2386.055908。 */ #import @interface cLmCalculator : NSObject { NS...

【算法导论】求最大子数组

要求:找到数组中连续和最大的子数组 来源:算法导论,第四章 方法:分治法 思路:一个串中和最大的子数组,可能出现的位置1、前一半(不包含中间元素)             ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

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