数据结构与算法十五：二叉排序树

分类：算法作者：编程之家用户

一、什么是二叉排序树

二叉排序树（Binary Sort Tree）又称二叉查找树、二叉搜索树。 它或者是一棵空树；或者是具有下列性质的二叉树：

（1）若左子树不空，则左子树上所有结点的值均小于它的根结点的值；

（2）若右子树不空，则右子树上所有结点的值均大于它的根结点的值；

（3）左、右子树也分别为二叉排序树；

image-20200720112917992

当我们使用需要对数列进行操作的时候，我们原本有以下选择：

  • 数组：不排序的数组插入快而查找慢，排序数组通过算法可以快速查找，但是插入效率又会受到影响
  • 链表：不管是否有序，插入都快，但是查找效率都不高
  • 哈希表：查找修改都简单，但当哈希冲突严重的时候传统哈希表效率也会下降

而二叉排序树的查找类似二分查找，而插入类似链表，相较以上三种结构可以较好的平衡查找和插入效率

二、代码实现

我们先实现一个节点类：

/**
 * @Author：CreateSequence
 * @Date：2020-07-20 11:27
 * @Description：二叉排序树节点
 */
public class BinarySortTreeNode {

    int val;
    BinarySortTreeNode left;
    BinarySortTreeNode right;

    public BinarySortTreeNode(int val) {
        this.val = val;
    }

    @Override
    public String toString() {
        return "{" +
                "val=" + val +
                '}';
    }
}

再实现一个二叉排序树类：

/**
 * @Author：CreateSequence
 * @Date：2020-07-20 12:18
 * @Description：二叉排序树
 */
public class BinarySortTree {

    BinarySortTreeNode root;

    public BinarySortTree(BinarySortTreeNode root) {
        if (root == null) {
            throw new RuntimeException("根节点不允许为空！");
        }
        this.root = root;
    }

}

1.添加

思路如下：

  • 获取要插入的节点与其父节点比较值，比父节点小向左树插，否则就向右插
  • 插入是判断父节点的左/右子节点是否存在，存在就继续递归遍历左/右树直到找到插入位置，否则直接插入

在节点类中添加方法：

/**
 * 添加节点
 * @param parent 父节点
 * @param node 要添加的节点
 */
public void add(BinarySortTreeNode parent,BinarySortTreeNode node){
    //判断子节点是否小于父节点
    if (parent.val > node.val) {
        //判断要添加的位置是否还有节点
        if (parent.left != null) {
            //有就继续遍历左树
            add(parent.left,node);
        }else {
            //否则直接添加
            parent.left = node;
        }
    }else {
        //如果子节点大于父节点
        if (parent.right != null) {
            add(parent.right,node);
        }else {
            parent.right = node;
        }
    }
}

2.查找

/**
 * 查找节点
 * @param node 当前节点
 * @param val 要查找的节点值
 * @return
 */
public BinarySortTreeNode search(BinarySortTreeNode node,int val) {
    //判断当前节点是否为要找到的值
    if (node.val != val) {
        return node;
    } else if (node.val > val) {
        //如果当前节点大于查找值，就向左递归
        if (node.left == null) {
            return null;
        }
        return search(node.left,val);
    }else {
        //否则就向右递归
        if (node.right == null) {
            return null;
        }
        return search(node.right,val);
    }
}

3.删除

删除节点时会出现三种情况：

  • 要删除的节点是叶子结点
  • 要删除的节点是一棵树的根节点
  • 要删除的节点是两棵树的根节点

不管对于哪种情况而言，我们都需要先找到要要删除节点的父节点的方法：

/**
  * 查找目标节点的父节点
  * @param node 当前节点
  * @param val 要查找的值
  * @return
  */
public BinarySortTreeNode searchParentOfTarget(BinarySortTreeNode node,int val) {
    //判断当前节点的子节点是否为目标节点
    boolean isTargetParent = (node.left != null && node.left.val == val) || (node.right != null && node.right.val == val);
    if (isTargetParent) {
        return node;
    } else {
        //如果查找值小于当前节点，向左递归
        if (val < node.val && node.left != null) {
            return searchParentOfTarget(node.left,val);
        } else if (val >= node.val && node.right != null) {
            //如果查找值大于当前节点,向右递归
            return searchParentOfTarget(node.right,val);
        } else {
            //否则目标节点不存在
            return null;
        }
    }
}

我们先区分三种情况，然后在此基础上分别实现三种情况下的删除：

/**
 * 删除指定叶子节点
 * @param node 要删除节点的父节点
 * @param val 要删除节点的值
 */
public void deleteNode(int val) {
    //判断要删除的是否为根节点
    if (root.val == val && root.left == null && root.right == null) {
        throw new RuntimeException("树中只有根节点，无法删除!");
    }

    //查找目标节点
    BinarySortTreeNode target = search(val);
    if (target == null) {
        return;
    }
    //查找目标节点的父节点
    BinarySortTreeNode parent = searchTargetParent(val);

    //判断要删除的节点的子节点情况
    if (target.left == null && target.right == null) {
        //删除叶子节点
        deleteLeafNode(val,parent);
    } else if (target.left != null && target.right != null) {
        //删除有两颗子树的节点的节点
        deleteTwoBranchNode(target);
    }else {
        //删除只有一颗子树的节点
        deleteOneBranchNode(val,target,parent);
    }
}

我们在以上代码的基础上继续分析思路。

3.1删除的节点是叶子结点

即方法deleteLeafNode()

  • 找到要删除的节点，并判断其左右子节点是否都为空
  • 若都为空，再找到其父节点，然后判断要删除的节点是父节点的左子节点还是右子节点
/**
 * 删除叶子节点
 * @param node 要删除节点的父节点
 * @param val 要删除节点的值
 */
private void deleteLeafNode(int val,BinarySortTreeNode parent) {
    //判断目标节点是父节点左节点还是右节点
    if (parent.right != null && parent.right.val == val) {
        parent.right = null;
    }else {
        parent.left = null;
    }
}

3.2删除的节点有一课子树

即方法deleteOneBranchNode()

  • 找到目标节点，判断目标节点有的那颗子树是左子树还是右子树
  • 判断目标节点是否为根节点，如果是就直接将根节点替换为目标节点的子节点
  • 如果不是根节点，再判断目标节点是其父节点的左子节点还是右子节点
  • 让父节点的子节点指向目标节点的子节点
/**
 * 删除只有一颗子树的节点
 * @param val 要删除的节点的值
 * @param target 要删除的节点
 * @param parent 要删除的节点的父节点
 */
private void deleteOneBranchNode(int val,BinarySortTreeNode target,BinarySortTreeNode parent) {
    //判断目标节点有左子树还是右子树
    if (target.left != null) {
        //判断是否为根节点
        if (parent == null) {
            //如果是根节点，就直接删除
            root = target.left;
        }else {
            //目标节点只有左子树
            if (parent.left.val == val) {
                parent.left = target.left;
            }else {
                parent.right = target.left;
            }
        }
    }else {
        if (parent == null) {
            root = target.right;
        }else {
            //目标节点只有右子树
            if (parent.left.val == val) {
                parent.left = target.right;
            } else {
                parent.right = target.right;
            }
        }
    }
}

3.3 删除的节点结点有两颗子树

即方法deleteLeafNode()

当有要删除的节点有两颗子树时情况比较特殊，我们不能通过直接改变指针指向的方式让子树直接“移接”到目标节点的父节点上，我们需要在目标节点的子树中找到一个能替换目标节点并且不会改变排序树顺序的节点。

我们举个例子，现有{5,3,2,7,6,4,1,8}，形成的树

image-20200720164054844

我们要删除节点3，那3的位置就必须换成一个比3的右子树节点小而比左子树所有节点大的数，也就是说，这个数：

  • 左树选最大：可以是目标节点的左子节点的左树最大值，也就是2；
  • 右树选最小：可以是目标节点的右子节点的右树最小值，也就是4；

这里我们选择用右子树的最小值作为替换值：

/**
 * 删除有两颗子树的节点
 * @param target 目标节点
 * @return
 */
private void deleteTwoBranchNode(BinarySortTreeNode target) {
    BinarySortTreeNode minNodeOfTargetRitht = target.right;
    //遍历找到目标节点右子树上的最小值
    //右子树上的最小值，也就是目标节点的右子节点的左树最大值
    while (minNodeOfTargetRitht.left != null) {
        minNodeOfTargetRitht = minNodeOfTargetRitht.left;
    }
    //删除最小值
    deleteNode(minNodeOfTargetRitht.val);
    //目标节点的值替换为该最小值
    target.val = minNodeOfTargetRitht.val;
}

按以上方法，等于删除4，然后让3的值变为4：

image-20200720165202316

三、完整代码

具体代码和测试用例可以去GitHub上看，这里就放实现类：

/**
 * @Author：CreateSequence
 * @Date：2020-07-20 12:18
 * @Description：二叉排序树
 */
public class BinarySortTree {

    BinarySortTreeNode root;

    public BinarySortTree(BinarySortTreeNode root) {
        if (root == null) {
            throw new RuntimeException("根节点不允许为空！");
        }
        this.root = root;
    }

    /**
     * 遍历树
     */
    private void show(BinarySortTreeNode node) {
        if (node.left != null) {
            show(node.left);
        }
        System.out.println(node.toString());
        if (node.right != null) {
            show(node.right);
        }
    }

    public void show() {
        show(root);
    }

    /**
     * 添加节点
     * @param parent 父节点
     * @param node 要添加的节点
     */
    private void add(BinarySortTreeNode parent,BinarySortTreeNode node){
        //判断子节点是否小于父节点
        if (parent.val > node.val) {
            //判断要添加的位置是否还有节点
            if (parent.left != null) {
                //有就继续遍历左树
                add(parent.left,node);
            }else {
                //否则直接添加
                parent.left = node;
            }
        }else {
            //如果子节点大于父节点
            if (parent.right != null) {
                add(parent.right,node);
            }else {
                parent.right = node;
            }
        }
    }

    public void add(BinarySortTreeNode node){
        add(root,node);
    }

    /**
     * 查找节点
     * @param node 当前节点
     * @param val 要查找的节点值
     * @return
     */
    public BinarySortTreeNode search(BinarySortTreeNode node,int val) {
        //判断当前节点是否为要找到的值
        if (node.val == val) {
            return node;
        } else if (node.val > val) {
            //如果当前节点大于查找值，就向左递归
            if (node.left == null) {
                return null;
            }
            return search(node.left,val);
        }else {
            //否则就向右递归
            if (node.right == null) {
                return null;
            }
            return search(node.right,val);
        }
    }

    public BinarySortTreeNode search(int val) {
        return search(root,val);
    }

    /**
     * 查找目标节点的父节点
     * @param node 当前节点
     * @param val 要查找的值
     * @return
     */
    private BinarySortTreeNode searchTargetParent(BinarySortTreeNode node,int val) {
        //判断当前节点的子节点是否为目标节点
        boolean isTargetParent = (node.left != null && node.left.val == val) || (node.right != null && node.right.val == val);
        if (isTargetParent) {
            return node;
        } else {
            //如果查找值小于当前节点，向左递归
            if (val < node.val && node.left != null) {
                return searchTargetParent(node.left,val);
            } else if (val >= node.val && node.right != null) {
                //如果查找值大于当前节点,向右递归
                return searchTargetParent(node.right,val);
            } else {
                //否则目标节点不存在
                return null;
            }
        }
    }

    public BinarySortTreeNode searchTargetParent(int val) {
        return searchTargetParent(root,val);
    }

    /**
     * 删除指定节点
     * @param val 要删除节点的值
     */
    public void deleteNode(int val) {
        //判断要删除的是否为根节点
        if (root.val == val && root.left == null && root.right == null) {
            throw new RuntimeException("树中只有根节点，无法删除!");
        }

        //查找目标节点
        BinarySortTreeNode target = search(val);
        if (target == null) {
            return;
        }
        //查找目标节点的父节点
        BinarySortTreeNode parent = searchTargetParent(val);

        //判断要删除的节点的子节点情况
        if (target.left == null && target.right == null) {
            //删除叶子节点
            deleteLeafNode(val,parent);
        } else if (target.left != null && target.right != null) {
            //删除有两颗子树的节点的节点
            deleteTwoBranchNode(target);
        }else {
            //删除只有一颗子树的节点
            deleteOneBranchNode(val,parent);
        }
    }

    /**
     * 删除有两颗子树的节点
     * @param target 目标节点
     * @return
     */
    public void deleteTwoBranchNode(BinarySortTreeNode target) {
        BinarySortTreeNode minNodeOfTargetRitht = target.right;
        //遍历找到目标节点右子树上的最小值
        //右子树上的最小值，也就是目标节点的右子节点的左树最大值
        while (minNodeOfTargetRitht.left != null) {
            minNodeOfTargetRitht = minNodeOfTargetRitht.left;
        }
        //删除最小值
        deleteNode(minNodeOfTargetRitht.val);
        //目标节点的值替换为该最小值
        target.val = minNodeOfTargetRitht.val;
    }

    /**
     * 删除只有一颗子树的节点
     * @param val 要删除的节点的值
     * @param target 要删除的节点
     * @param parent 要删除的节点的父节点
     */
    private void deleteOneBranchNode(int val,BinarySortTreeNode parent) {
        //判断要目标节点有左子树还是右子树
        if (target.left != null) {
            //判断是否为根节点
            if (parent == null) {
                //如果是根节点，就直接删除
                root = target.left;
            }else {
                //目标节点只有左子树
                if (parent.left.val == val) {
                    parent.left = target.left;
                }else {
                    parent.right = target.left;
                }
            }
        }else {
            if (parent == null) {
                root = target.right;
            }else {
                //目标节点只有右子树
                if (parent.left.val == val) {
                    parent.left = target.right;
                } else {
                    parent.right = target.right;
                }
            }
        }
    }

    /**
     * 删除叶子节点
     * @param val 要删除的节点的值
     * @param parent 要删除的节点的父节点
     */
    private void deleteLeafNode(int val,BinarySortTreeNode parent) {
        //判断目标节点是父节点左节点还是右节点
        if (parent.right != null && parent.right.val == val) {
            parent.right = null;
        }else {
            parent.left = null;
        }
    }
}

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。

相关推荐

负数原码与补码之间相互转换
背景：计算机内部用补码表示二进制数。符号位1表示负数，0表示正数。正数：无区别，正数 的原码= 反码 = 补码重点讨论负数若已知 负数 -8，则其原码为：1000 1000，（1为符号位，为1代表负数，为0代表正数）反码为：1111 0111，（符号位保持不变，其他位置按位取反）补码为：1111 1000，（反码 + 1）即在计算机中 用 1111 1000表示 -8若已知补码为 1111 1000，如何求其原码呢？（1）方法1：求负数 原码---&gt;补...
MD5 加密算法介绍
大家好,我们现在来讲解关于加密方面的知识,说到加密我认为不得不提MD5,因为这是一种特殊的加密方式,它到底特殊在哪,现在我们就开始学习它全称:message-digest algorithm 5翻译过来就是:信息 摘要 算法 5加密和摘要，是不一样的加密后的消息是完整的；具有解密算法，得到原始数据；摘要得到的消息是不完整的；通过摘要的数据，不能得到原始数据；所以，当看到很多人说，md5，加密，解密的时候，呵呵一笑就好了。MD5长度有人说md5,128位，32位，16位，到
新的快速排序算法: 《Dual-Pivot QuickSort》阅读笔记
相信大家在大学的《算法与数据结构》里面都学过快速排序(QuickSort), 知道这种排序的性能很好，JDK里面直到JDK6用的都是这种经典快排的算法。但是到了JDK7的时候JDK内置的排序算法已经由经典快排变成了Dual-Pivot排序算法。那么Dual-Pivot到底是何方圣神，能比我们学过的经典快排还要快呢？我们一起来看看。经典快排在学习新的快排之前，我们首先来复习一下经典快排，它的核心思想是:接受一个数组，挑一个数(pivot)，然后把比它小的那一摊数放在它的左边，把比它大的那一摊数放
对称加密与非对称加密
加密在编程中的应用的是非常广泛的，尤其是在各种网络协议之中，对称/非对称加密则是经常被提及的两种加密方式。对称加密我们平时碰到的绝大多数加密就是对称加密，比如：指纹解锁，PIN 码锁，保险箱密码锁，账号密码等都是使用了对称加密。对称加密：加密和解密用的是同一个密码或者同一套逻辑的加密方式。这个密码也叫对称秘钥，其实这个对称和不对称指的就是加密和解密用的秘钥是不是同一个。我在上大学的时候做过一个命令行版的图书馆管理系统作为 C 语言课设。登入系统时需要输入账号密码，当然，校验用户输入的密码
详解vue的diff算法
前言我的目标是写一个非常详细的关于diff的干货，所以本文有点长。也会用到大量的图片以及代码举例，目的让看这篇文章的朋友一定弄明白diff的边边角角。先来了解几个点...1. 当数据发生变化时，vue是怎么更新节点的？要知道渲染真实DOM的开销是很大的，比如有时候我们修改了某个数据，如果直接渲染到真实dom上会引起整个dom树的重绘和重排，有没有可能我们只更新我们修改的那一小块dom而不要更新整个dom呢？diff算法能够帮助我们。我们先根据真实DOM生成一颗virtual DOM，当v
对称加密算法
对称加密算法 所有的对称加密都有一个共同的特点：加密和解密所用的密钥是相同的。现代对称密码可以分为序列密码和分组密码两类：序列密码将明文中的每个字符单独加密后再组合成密文；而分组密码将原文分为若干个组，每个组进行整体加密，其最终加密结果依赖于同组的各位字符的具体内容。也就是说，分组加密的结果不仅受密钥影响，也会受到同组其他字符的影响。序列密码分组密码序列密码的安全性看上去要更弱一些，但是由于序列密码只需要对单个位进行操作，因此运行速度比分组加密要快...
RSA密钥长度、明文长度和密文长度
本文介绍RSA加解密中必须考虑到的密钥长度、明文长度和密文长度问题，对第一次接触RSA的开发人员来讲，RSA算是比较复杂的算法，RSA算法自己其实也很简单，RSA的复杂度是由于数学家把效率和安全也考虑进去的缘故。html本文先只谈密钥长度、明文长度和密文长度的概念知识，RSA的理论及示例等之后再谈。提到密钥，咱们不得不提到RSA的三个重要大数：公钥指数e、私钥指数d和模值n。这三个大数是咱们使用RSA时须要直接接触的，理解了本文的基础概念，即便未接触过RSA的开发人员也能应对自如的使用RSA相关函数库，
布隆过滤器(Bloom Filter)详解
直观的说，bloom算法类似一个hash set，用来判断某个元素（key）是否在某个集合中。和一般的hash set不同的是，这个算法无需存储key的值，对于每个key，只需要k个比特位，每个存储一个标志，用来判断key是否在集合中。算法：1. 首先需要k个hash函数，每个函数可以把key散列成为1个整数2. 初始化时，需要一个长度为n比特的数组，每个比特位初始化为03. 某个key加入集合时，用k个hash函数计算出k个散列值，并把数组中对应的比特位置为14. 判断某个key是否在集合时
如何防范密码被破解
你会用什么样的算法来为你的用户保存密码？如果你还在用明码的话，那么一旦你的网站被hack了，那么你所有的用户口令都会被泄露了，这意味着，你的系统或是网站就此完蛋了。所以，我们需要通过一些不可逆的算法来保存用户的密码。比如：MD5, SHA1, SHA256, SHA512, SHA-3,等Hash算法。这些算法都是不可逆的。系统在验证用户的口令时，需要把Hash加密过后的口令与后面存放口令的数据库中的口令做比较，如果一致才算验证通过。但你觉得这些算法好吗？我说的是：MD5, SHA1, SHA256,
Excel表格如何筛选重复内容筛选重复数据的方法
在日常工作中经常会使用excel，有时在表格中需要筛选出重复的数据，该怎么操作呢？1、以下图中的表格数据为例，筛选出列中重复的内容；2、打开文件，选中需要筛选的数据列，依次点击菜单项【开始】-【条件格式】-【突出显示单元格规则】-【重复值】；3、将重复的值突出颜色显示；4、选中数据列，点击【数据】-【筛选】；5、点击列标题的的下拉小三角，点击【按颜色筛选】，即可看到重复的数据；...
第三方接口联调加解密与签名验签
工作中经常有和第三方机构联调接口的事情，顾将用到过的做以记录。 在和第三方联调时，主要步骤为：网络、加解密/签名验签、接口数据等，其中接口数据没啥好说的。 在联调前就需要先将两边的网络连通，一般公司的生产环境都加了防火墙，测试环境有的是有防火墙，有的则没有防火墙，这个需要和第三方人员沟通，如果有防火墙的就需要将我们的出口ip或域名发送给第三方做配置，配置了之后网络一般都是通的。加解密与签名验签： 一般第三方公司都会有加解密或签名验签的，毕竟为了数据安全。一般就是三...
Spring Security安全框架中BCrypt强哈希加密算法使用
此文章不包含认证机制。任何应用考虑到安全，绝不能明文的方式保存密码。密码应该通过某种方式进行加密。如今已有很多标准的算法比如SHA或者MD5再结合salt(盐)使用是一个不错的选择。废话不多说！直接开始SpringBoot 中提供了Spring Security：BCryptPasswordEncoder类,实现Spring的PasswordEncoder接口使用BCrypt强哈希方法来加密密码。第一步：pom导入依赖：&lt;dependency&gt; &lt;groupId...
哈希加密详解和md5、sha1、sha256、Java 工具类
前言在所有的加密算法中使用最多的就是哈希加密了，很多人第一次接触的加密算法如MD5、SHA1都是典型的哈希加密算法，而哈希加密除了用在密码加密上，它还有很多的用途，如提取内容摘要、生成签名、文件对比、区块链等等。这篇文章就是想详细的讲解一下哈希加密，并分享一个哈希加密的工具类。概述哈希函数（Hash Function），也称为散列函数或杂凑函数。哈希函数是一个公开函数，可以将任意长度的消息M映射成为一个长度较短且长度固定的值H（M），称H（M）为哈希值、散列值（Hash Value）、杂凑值或者消息
[排序算法] 快速排序 (C++) (含三种写法)
#快速排序解释 快速排序 Quick Sort 与归并排序一样，也是典型的分治法的应用。 (如果有对 归并排序还不了解的童鞋，可以看看这里哟~ 归并排序)❤❤❤ ###快速排序的分治模式 1、选取基准
[排序算法] 堆排序 (C++)
#堆排序解释 ##什么是堆 堆 heap 是一种近似完全二叉树的数据结构，其满足一下两个性质 1. 堆中某个结点的值总是不大于(或不小于)其父结点的值； 2. 堆总是一棵完全二叉树 将根结点最大的堆叫
[排序算法] 希尔排序 (C++)
#前言 本文章是建立在插入排序的基础上写的喔，如果有对插入排序还有不懂的童鞋，可以看看这里。 ❤❤❤ 直接/折半插入排序 2路插入排序 ❤❤❤ #希尔排序解释 希尔排序 Shell Sort 又名&q
[排序算法] 归并排序 (C++)
#归并排序解释 归并排序 Merge Sort 是典型的分治法的应用，其算法步骤完全遵循分治模式。 ##分治法思想 分治法 思想: 将原问题分解为几个规模较小但又保持原问题性质的子问题，递归求解这些子
[排序算法] 双向冒泡排序 (C++)
#前言 本文章是建立在冒泡排序的基础上写的，如还有对 冒泡排序 不了解的童鞋，可以看看这里哦~ 冒泡排序 C++ #双向冒泡排序原理 双向冒泡排序 的基本思想与 冒泡排序还是一样的。冒泡排序 每次将相
[排序算法] 直接/折半插入排序 (C++)
#插入排序解释 插入排序很好理解，其步骤是 ：先将第一个数据元素看作是一个有序序列，后面的 n-1 个数据元素看作是未排序序列。对后面未排序序列中的第一个数据元素在这个有序序列中进行从后往前扫描，找到
[排序算法] 桶排序 (C++)
#桶排序解释 ##桶排序思想 桶排序 是一种空间换取时间的排序方式，是非基于比较的。 桶排序 顾名思义，就是构建多个映射数据的桶，将数据放入桶内，对每个桶内元素进行单独排序。假设我们有 n 个待排序的
pythonJavaScriptjavaHTMLPHPreactjsC#AndroidCSSNode.jssqlrpython-3.xMysqLjQueryc++pandasFlutterangularIOSdjangolinuxswifttypescript路由器JSON路由器设置无线路由器h3c华三华三路由器设置华三路由器电脑软件教程arraysdocker软件图文教程Cvue.jslaravelspring-boot