第4章 树

 二叉查找树

public class BinarySearchTree<AnyType extends Comparable<? super AnyType>>
{
    private static class BinaryNode<AnyType> 
    {
        BinaryNode(AnyType theElement) 
        {
            this(theElement, null, null);
        }

        BinaryNode(AnyType theElement, BinaryNode<AnyType> lt, BinaryNode<AnyType> rt) 
        {
            element = theElement;
            left = lt;
            right = rt;
        }

        AnyType element;
        BinaryNode<AnyType> left;
        BinaryNode<AnyType> right;
    }

    private BinaryNode<AnyType> root;

    public BinarySearchTree() 
    {
        root = null;
    }

    public void makeEmpty() 
    {
        root = null;
    }

    public boolean isEmpty() 
    {
        return root == null;
    }

    public boolean contains(AnyType x)
    { return contains(x, root); }
    public AnyType findMin()
    {
        if (isEmpty()) throw new UnderflowException();
        return findMin(root).element;
    }
    public AnyType findMax()
    {
        if (isEmpty()) throw new UnderflowException();
        return findMax(root).element;
    }
    public void insert(AnyType x)
    {
        root = insert(x, root);
    }
    public void remove(AnyType x)
    {
        root = remove(x, root);
    }

    private boolean contains(AnyType x, BinaryNode<AnyType> t)
    {
        if (t == null)
            return false;

        int compareResult = x.compareTo(t.element);

        if (compareResult < 0)
            return contains(x, t.left);
        if (compareResult > 0)
            return contains(x, t.right);
        else
            return true;
    }

    private BinaryNode<AnyType> findMin(BinaryNode<AnyType> t)
    {
        if (t == null)
            return null;
        else if (t.left == null)
            return t;
        return findMin(t.left);
    }

    private BinaryNode<AnyType> findMax(BinaryNode<AnyType> t) 
    {
        if (t != null)
            while (t.right != null)
                t = t.right;

        return t;
    }

    private BinaryNode<AnyType> insert(AnyType x, BinaryNode<AnyType> t)
    {
        if (t == null)
            return new BinaryNode<>(x, null, null);

        int compareResult = x.compareTo(t.element);

        if (compareResult < 0)
            t.left = insert(x, t.left);
        if (compareResult > 0)
            t.right = insert(x, t.right);
        else
            ;
        return t;
    }

    private BinaryNode<AnyType> remove(AnyType x, BinaryNode<AnyType> t)
    {
        if (t == null)
            return t;

        int compareResult = x.compareTo(t.element);

        if (compareResult < 0)
            t.left = remove(x, t.left);
        else if (compareResult > 0)
            t.right = remove(x, t.right);
        else if (t.left != null && t.right != null)
        {
            t.element = findMin(t.right).element;
            t.right = remove(t.element, t.right);
        }
        else
            t = (t.left != null) ? t.left : t.right;
        return t;
    }

    public void printTree()
    {
        if (isEmpty())
            System.out.println("Empty tree");
        else
            printTree(root);
    }

    public void printTree(BinaryNode<AnyType> t)
    {
        if (t != null)
        {
            printTree(t.left);
            System.out.println(t.element);
            printTree(t.right);
        }
    }
}

public class UnderflowException extends RuntimeException {
}

懒惰删除：当一个元素要被删除时，它仍留在树中，而只是被标记为删除。

AVL树

public class AvlTree<AnyType extends Comparable<? super AnyType>>
{
    public AvlTree() { root = null; }
    
    public void insert(AnyType x){ root = insert(x, root); }
    public void remove(AnyType x){ root = remove(x, root); }
    
    private AvlNode<AnyType>remove(AnyType x, AvlNode<AnyType> t)
    {
        if (t == null)
            return t;
        
        int compareResult = x.compareTo(t.element);
        
        if (compareResult < 0)
            t.left = remove(x, t.left);
        else if (compareResult > 0)
            t.right = remove(x, t.right);
        else if (t.left != null && t.right != null)
        {
            t.element = findMin(t.right).element;
            t.right = remove(t.element, t.right);
        }
        else 
            t = (t.left != null) ? t.left : t.right;
        return balance(t);
    }
    
    public AnyType findMin()
    {
        if (isEmpty())
            throw new UnderflowException();
        return findMin(root).element;
    }
    
    public AnyType findMax()
    { 
        if (isEmpty())
            throw new UnderflowException();
        return findMin(root).element;
    }
    
    public boolean contains(AnyType x){ return contains(x, root); }
    
    public void makeEmpty(){ root = null; }
    
    public boolean isEmpty(){ return root == null; }
    
    public void printTree()
    {
        if (isEmpty())
            System.out.println("Empty tree");
        else 
            printTree(root);
    }
    
    private static final int ALLOWED_IMBALANCE = 1;
    
    private AvlNode<AnyType>balance(AvlNode<AnyType>t)
    {
        if (t == null)
            return t;
     
        if (height(t.left) - height(t.right) > ALLOWED_IMBALANCE)
            if (height(t.left.left) - height(t.left.right) > ALLOWED_IMBALANCE)
                t = rotateWithLeftChild(t);
            else 
                t = doubleWithLeftChild(t);
        
        if (height(t.right) - height(t.left) > ALLOWED_IMBALANCE)
            if (height(t.right.right) - height(t.right.left) > ALLOWED_IMBALANCE)
                t = rotateWithRightChild(t);
            else 
                t = doubleWithRightChild(t);
            
        t.height = Math.max(height(t.left), height(t.right)) + 1;
        return t;
    }
    
    public void checkBalance(){ checkBalance(root); }
    
    private int checkBalance(AvlNode<AnyType> t)
    { 
        if (t == null)
            return -1;
        
        if (t != null)
        {
            int hl = checkBalance(t.left);
            int hr = checkBalance(t.right);
            if (Math.abs(height(t.left) - height(t.right)) > 1 || height(t.left) != hl || height(t.right) != hr)
                System.out.println("OOPS");
        }
        
        return height(t);
    }
    
    private AvlNode<AnyType> insert(AnyType x, AvlNode<AnyType>t)
    {
        if (t == null)
            return new AvlNode<>(x, null, null);
        
        int compareResult = x.compareTo(t.element);
        
        if (compareResult < 0)
            t.left = insert(x, t.left);
        else if (compareResult > 0)
            t.right = insert(x, t.right);
        else 
            ;
        return balance(t);
    }
    private AvlNode<AnyType> findMin(AvlNode<AnyType> t)
    {
        if (t == null)
            return t;
        while (t.left != null)
            t = t.left;

        return t;
    }

    private AvlNode<AnyType>findMax(AvlNode<AnyType> t)
    {
        if (t == null)
            return t;
        while (t.right != null)
            t = t.right;

        return t;
    }
    private boolean contains(AnyType x, AvlNode<AnyType> t)
    {
        while (t != null)
        {
            int compareResult = x.compareTo(t.element);
            if (compareResult < 0)
                t = t.left;
            else if (compareResult > 0)
                t = t.right;
            else
                return true;
        }
        return false;
    }

    private void printTree(AvlNode<AnyType> t)
    {
        if (t != null)
        {
            printTree(t.left);
            System.out.println(t.element);
            printTree(t.right);
        }
    }

    private int height(AvlNode<AnyType> t){ return t == null ? -1 : t.height; }
    
    private AvlNode<AnyType> rotateWithLeftChild(AvlNode<AnyType> k2)
    {
        AvlNode<AnyType>k1 = k2.left;
        k2.left = k1.right;
        k1.right = k2;
        k2.height = Math.max(height(k2.left), height(k2.right)) + 1;
        k1.height = Math.max(height(k1.left), k2.height) + 1;
        return k1;
    }
    
    private AvlNode<AnyType> rotateWithRightChild(AvlNode<AnyType>k1)
    {
        AvlNode<AnyType>k2 = k1.right;
        k1.right = k2.left;
        k2.left = k1;
        k1.height = Math.max(height(k1.left), height(k1.right)) + 1;
        k2.height = Math.max(height(k2.right), k1.height) + 1;
        return k2;
    }
    
    private AvlNode<AnyType>doubleWithLeftChild(AvlNode<AnyType> k3)
    {
        k3.left = rotateWithRightChild(k3.left);
        return rotateWithLeftChild(k3);
    }
    
    private AvlNode<AnyType>doubleWithRightChild(AvlNode<AnyType>k1)
    {
        k1.right = rotateWithLeftChild(k1.right);
        return rotateWithRightChild(k1);
    }

    private static class AvlNode<AnyType>
    {
        AvlNode(AnyType theElement)
        { this(theElement, null, null); }
        AvlNode(AnyType theElement, AvlNode<AnyType>lt, AvlNode<AnyType>rt)
        { element = theElement; left = lt; right = rt; height = 0; }

        AnyType element;
        AvlNode<AnyType> left;
        AvlNode<AnyType> right;
        int height;
    }

    private AvlNode<AnyType> root;
}

4.10 编写一个程序，该程序列出一个目录中所有的文件和大小

import java.io.File;

public class FileList
{
    public void list(File f)
    {
        list(f, 0);
    }

    public void list(File f, int depth)
    {
        printName(f, depth);
        if (f.isDirectory())
        {
            File[] files = f.listFiles();
            for (File i : files)
                list(i, depth + 1);
        }
    }

    void printName(File f, int depth)
    {
        String name = f.getName();
        for (int i = 0; i < depth; i++)
            System.out.print("      ");
        if (f.isDirectory())
            System.out.println("Dir: " + name);
        else
            System.out.println(f.getName() + " " + f.length());
    }
}