• 数据结构--二叉查找树的java实现


    上代码:
    package com.itany.erchachazhaoshu;
    
    public class BinarySearchTree<T extends Comparable<? super T>>
    {
        //定义二叉查找树的根节点  每个查找二叉树都有一个自己的root  节点 root外界看不到
        private BinaryNode<T> root;
        public BinarySearchTree()
        {
            root=null;
        }
        //节点类
        private static class BinaryNode<T>
        {
            private T element;
            private BinaryNode<T> left;
            private BinaryNode<T> right;
            public BinaryNode(T element)
            {
                this(element, null, null);
            }
            public BinaryNode(T element,BinaryNode<T> left,BinaryNode<T> right)
            {
                this.element=element;
                this.left=left;
                this.right=right;
            }
        }
        public void makeEmpty()
        {
            root=null;
        }
        public boolean isEmpty()
        {
            return root==null;
        }
        public boolean contains(T t)
        {
            return contains(t,root);
        }
        //外界是不认识节点的  仅仅会返回T 布尔 或者根本无返回值
        public T findMax() throws Exception
        {
            if(isEmpty())
                throw new Exception();
            return findMax(root).element;
        }
        public T findMin() throws Exception
        {
            if(isEmpty())
                throw new Exception();
            return findMin(root).element;
        }
        public void insert(T t)
        {
            root=insert(t,root);
        }
        public void remove(T t)
        {
            root=remove(t,root);
        }
        public void printTree()
        {
            if(isEmpty())
                System.out.println("Empty Tree");
            else
                printTree(root);
        }
        //中序遍历
        private void printTree(BinaryNode<T> root)
        {
            //假设递归到了叶子节点 没有左右的部分就不运行遍历  并且if也完毕了对非空的推断
            if(null!=root)
            {
                printTree(root.left);
                System.out.println(root.element);
                printTree(root.right);
            }
        }
        //此处使用的是尾递归
        private boolean contains(T t,BinaryNode<T> root)
        {
            //必须在一開始就推断是否为null 否则在调用方法或元素时 会产生空指针异常  也是一个基准条件
            if(root==null)
                return false;
            int compareRes=t.compareTo(root.element);
            if(compareRes==0)
                return true;
            else if(compareRes<0)
                return contains(t,root.left);//不会使栈频繁进出 仅仅会覆盖当前栈
            else
                return contains(t,root.right);
        }
        // 方法二 使用循环取代尾递归找出最大 是返回相应的那个节点
        private BinaryNode<T> findMax(BinaryNode<T> root)
        {
            if(root==null)
                return null;
            else
            {
                while(root.right!=null)
                {
                    root=root.right  ;
                }
            }
            return root;
        }
        //方法一 使用递归查找 返回最小节点的引用
        private BinaryNode<T> findMin(BinaryNode<T> root)
        {
            //必须在一開始就推断是否为null 否则在调用方法或元素时 会产生空指针异常
            if(root==null)
                return null;
            //基准条件
            else if(root.left==null)
                return root;
            else
                return findMin(root.left);
        }
        //返回一个插入了之后的整个节点 逐级返回
        private BinaryNode<T> insert(T t,BinaryNode<T> root)
        {
            if(root==null)
                return new BinaryNode<T>(t,null,null);
            else
            {
                int com=t.compareTo(root.element);
                if(com==0)
                    ;
                else if(com<0)
                    //不断更新当前root的left值 并返回root
                    root.left=insert(t,root.left);
                else
                    root.right=insert(t,root.right);
                return root;
            }
        }
        //删除和添加一样 都要返回改动之后的节点
        private BinaryNode<T> remove(T t,BinaryNode<T> root)
        {
            //没有找到删除的  什么也不做  直接返回该root
            if(root==null)
                return root;
            int com=t.compareTo(root.element);
            if(com<0)
            {
                root.left=remove(t,root.left);
            }
            else if(com>0)
            {
                root.right=remove(t,root.right);
            }
            else
            {
                //有两个儿子的情况 
                if(root.left!=null && root.right!=null)
                {
                    root.element=findMin(root.right).element;
                    root.right=remove(root.element,root.right);//更新删除之后
                }
                else//包含一个儿子都没有的情况 有一个儿子的情况
                    return (root.left!=null)?

    root.left:root.right; } return root; } }

    package com.itany.erchachazhaoshu;
    
    public class Test
    {
        
        public static void main(String[] args)
        {
            BinarySearchTree bt=new BinarySearchTree();
            bt.insert(3);
            bt.insert(13);
            bt.insert(1);
            try
            {
                System.out.println("max:"+bt.findMax());
                System.out.println("max:"+bt.findMin());
                System.out.println(bt.contains(3)); 
                bt.remove(13);
                System.out.println(bt.contains(13));
            }
            catch (Exception e)
            {
                e.printStackTrace();
            }
        }
        
    }
    


  • 相关阅读:
    Hash基础相关知识点总结
    Java程序员简历模板
    nginx中C语言操作技巧学习
    C标准库中转换wchar_t和char类型的字符串
    golang中接口interface和struct结构类的分析
    oracle 使用occi方式 批量插入多条数据
    oracle 使用occi方式插入数据时中文乱码
    在linux下监控文件是否被删除或创建的命令
    QT 中设置按钮图片和文字的两种方法
    Windows操作系统下 使用c++ WIN32API禁用控制台最小化和关闭按钮
  • 原文地址:https://www.cnblogs.com/zsychanpin/p/7061336.html
Copyright © 2020-2023  润新知