二叉树（查询和删除）

最新推荐文章于 2023-09-17 08:57:12 发布
最新推荐文章于 2023-09-17 08:57:12 发布
阅读量483 收藏
点赞数
分类专栏： 数据结构 文章标签： 二叉树
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/Poisx/article/details/78586022
版权

一，插入数据

这里写图片描述

二叉树的插入过程
这里写图片描述

数据结构

typedef struct TreeNode {
    int data;
    struct TreeNode *leftchild;
    struct TreeNode *rightChild;
    struct TreeNode *parent;
}TreeNode;

1， 第一步判断二叉树是否有根节点

//判断根节点是否为空
    if (root == NULL) {
        //创建根节点
        root = (TreeNode *)malloc(sizeof(TreeNode));
        //赋值
        root->data = data;
        root->leftchild = NULL;
        root->rightChild = NULL;

        return root;
    }

2， 如果有节点就记录当前的根节点，遍历比较节点的数据大小， 添加节点

//遍历比较
    TreeNode *parent = NULL;
    TreeNode *node = root;
    //遍历遍历比较大小 , 查询找到插入的位置
    for (; node != NULL; ) {
        parent = node;
        //比较值
        if (data < parent->data) 
            node = parent->leftchild;
        else if (data > parent->data)
            node = parent->rightChild;
        else 
            return node;
    }

    //创建节点
    TreeNode* newNode = (TreeNode *)malloc(sizeof(TreeNode));
    //赋值操作
    newNode->data = data;
    newNode->leftchild = NULL;
    newNode->rightChild = NULL;
    if (data < parent->data) {
        parent->leftchild = newNode;
    }
    else {
        parent->rightChild = newNode;
    }

    //child指针父节点parent

    newNode->parent = parent;

二，前序，中序， 后续遍历

提一下遍历的定义：

  1. 前序遍历： DLR ， 先根，在左， 再右
  2. 中序遍历：LDR，先左，在根， 再右
  3. 后序遍历：LRD， 先左， 在右，在根
前序遍历

LRD

void modleOrderTraverse(TreeNode *node) {
    if (node == NULL)
        return;
    printf("%d\t", node->data);
    modleOrderTraverse(node->leftchild);
    modleOrderTraverse(node->rightChild);

}
中序遍历

LDR

void midOrderTraverse(TreeNode* node) {
    if (node == NULL)
        return;
    midOrderTraverse(node->leftchild);
    printf("%d\t", node->data);
    midOrderTraverse(node->rightChild);
}
后序遍历

若二叉树为空则结束返回，
否则：
（1）后序遍历左子树
（2）后序遍历右子树
（3）访问根结点

LRD

void maxOrderTraverse(TreeNode* node) {

    if (node == NULL)
        return;
    midOrderTraverse(node->leftchild);
    midOrderTraverse(node->leftchild);
    printf("%d\t", node->data);

}

这里写图片描述

三，删除一个节点的操作

删除一个节点分为: 四种情况

1. 没有左右孩子节点的树的情况
2. 有左孩子的节点的树的情况
3. 有右孩子的节点的树的情况
4. 有左右孩子的节点的树的情况

1，第一种情况的分析没有左右节点的树情况

可以分为两种情况

  1. 是根（root）节点情况
  2. 不是节点的情况， 是叶子节点情况

①是根节点的情况图
这里写图片描述

//父节点为空时
if (parent == NULL) {
    root = NULL; //置空   
}

②，不是根节点的情况是叶子结点情况

这里写图片描述

if (parent->leftchild == node) {    
                    parent->leftchild = node->rightChild;
                }
                else if (parent->rightChild == node) {
                    parent->rightChild = node->leftchild;
                }
二，第二种情况和第三情况

只有左孩子或者右孩子的节点
大致也分为两类

1. 是根节点
2. 不是根节点，是只有左孩子或者右或者情况的节点

①，是根（root）节点的情况
这里写图片描述

//判r断父节点
if (parent == NULL) {
    root = parent->leftchild;

}

②，不是根节点的情况，只有左孩子或者右或者情况的节点
这里写图片描述

实现：

if (parent->leftchild == node) {
                    parent->leftchild = node->leftchild;
                }
                else if (parent->rightChild == node) {
                    parent->rightChild = node->leftchild;
                }
三，第四情况

分为两个大的情况

  1. 节点right节点的left为空的情况（node->rightChild->left == NULL）
  2. 节点的right节点的left不为空的情况（node->rightCild->left ！= NULL）

这里写图片描述

①，第一种情况 （node->rightChild->left == NULL）
在这种情况下面也分为两种情况

1. 是根节点
2. 不是根节点，是只有左孩子或者右或者情况的节点 

if (parent->rightChild->leftchild == NULL) {
                node->rightChild->leftchild = node->rightChild;
                if (parent == NULL) {
                    root = node->rightChild;


                }
                else if (parent->leftchild == node) {
                    parent->leftchild = node->leftchild;
                    //parent->leftchild->rightChild = node->rightChild;

                }
                else if (parent->rightChild == node) {
                    parent->rightChild = node->leftchild;
                    //parent->rightChild->leftchild = node->rightChild; 
                }
            }

②第二种情况（node->rightChild->leftChild ！= NULL）
这里写图片描述

TreeNode *leftNode = MinTreeNode(node->rightChild);

                //第一步   
                leftNode->leftchild = node->leftchild;
                //第二步
                TreeNode* leftNodep = leftNode->parent;
                leftNodep->leftchild = leftNode->rightChild;

                //第三步
                leftNode->rightChild = node->rightChild;

                //第四步
                if (parent == NULL)  
                    root = leftNode; 
                else { 
                    if (parent->leftchild == node) 
                        parent->leftchild = leftNode; 
                    else if (parent->rightChild == node) 
                        parent->rightChild = leftNode; 
                    //leftNode->parent = parent;
                }
            }

C语言的代码实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>


typedef struct TreeNode {
    int data;
    struct TreeNode *leftchild;
    struct TreeNode *rightChild;
    struct TreeNode *parent;
}TreeNode;

//根节点
TreeNode *root = NULL;

//添加节点
TreeNode* put(int data) {
    //判断根节点是否为空
    if (root == NULL) {
        //创建根节点
        root = (TreeNode *)malloc(sizeof(TreeNode));
        //赋值
        root->data = data;
        root->leftchild = NULL;
        root->rightChild = NULL;

        return root;
    }

    //遍历比较
    TreeNode *parent = NULL;
    TreeNode *node = root;
    //遍历遍历比较大小   ,查询找到插入的位置
    for (; node != NULL; ) {
        parent = node;
        //比较值
        if (data < parent->data) 
            node = parent->leftchild;
        else if (data > parent->data)
            node = parent->rightChild;
        else 
            return node;
    }

    //创建节点
    TreeNode* newNode = (TreeNode *)malloc(sizeof(TreeNode));
    //赋值操作
    newNode->data = data;
    newNode->leftchild = NULL;
    newNode->rightChild = NULL;
    if (data < parent->data) {
        parent->leftchild = newNode;
    }
    else {
        parent->rightChild = newNode;
    }

    //child指针父节点parent

    newNode->parent = parent;
    return newNode;
}


/**
* 中序遍历
*/
void midOrderTraverse(TreeNode* node) {
    if (node == NULL)
        return;
    midOrderTraverse(node->leftchild);
    printf("%d\t", node->data);
    midOrderTraverse(node->rightChild);
}
/**
* 后序遍历
*/
void maxOrderTraverse(TreeNode* node) {

    if (node == NULL)
        return;
    midOrderTraverse(node->leftchild);
    midOrderTraverse(node->leftchild);
    printf("%d\t", node->data);

}


/*
前序遍历
*/

void modleOrderTraverse(TreeNode *node) {
    if (node == NULL)
        return;
    printf("%d\t", node->data);
    modleOrderTraverse(node->leftchild);
    modleOrderTraverse(node->rightChild);

}


TreeNode * MinTreeNode(TreeNode *node) {
    if (node == NULL) {
        printf("方法名：%s\n", __FUNCTION__);
        return NULL;
    }
    else {
        while (node->leftchild != NULL) {
            node = node->leftchild;
        }
        return node;
    }
}


/*
   删除一个节点
*/
void delNode(TreeNode *node) {
    if (node == NULL) {
        printf("node == null\n");
    }
    else {
        TreeNode *parent = node->parent;
        //1， 没有孩子
        if ((node->rightChild == NULL) && (node->leftchild == NULL)) {
            //父节点为空时
            if (parent == NULL) {
                root = NULL;    
            }
            else {
                if (parent->leftchild == node) {    
                    parent->leftchild = node->rightChild;
                }
                else if (parent->rightChild == node) {
                    parent->rightChild = node->leftchild;
                }
            }
            //释放节点的内存
            free(node);
            //节点数据置空
            node->data = NULL;
            //父指针
            node->parent = NULL;
            node = NULL;

        }
        else if ((node->rightChild == NULL) && (node->leftchild != NULL)) {
            //2， 有左孩子
            //判r断父节点
            if (parent == NULL) {
                root = parent->leftchild;

            }
            else {
                if (parent->leftchild == node) {
                    parent->leftchild = node->leftchild;
                }
                else if (parent->rightChild == node) {
                    parent->rightChild = node->leftchild;
                } 
            }
            //释放节点的内存
            free(node);
            //节点数据置空
            node->data = NULL;
                //父指针
            node->parent = NULL;
            node = NULL;

        }
        else if ((node->rightChild != NULL) && (node->leftchild == NULL)) {
            //3,  有右孩子
            //判断父节点
            if (parent == NULL) {
                root = parent->rightChild;
                //parent->rightChild->parent = NULL;
            }
            else {
                if (parent->leftchild == node) {
                    parent->leftchild = node->rightChild;
                }
                else if (parent->rightChild == node) {
                    parent->rightChild = node->rightChild;
                }
            }
            //释放节点的内存
            free(node);
            //节点数据置空
            node->data = NULL;
            //父指针
            node->parent = NULL;
            node = NULL;

        }
        else if ((node->rightChild != NULL) && (node->leftchild != NULL)) {
            //4， 有左右孩子
            if (parent->rightChild->leftchild == NULL) {
                node->rightChild->leftchild = node->rightChild;
                if (parent == NULL) {
                    root = node->rightChild;


                }
                else if (parent->leftchild == node) {
                    parent->leftchild = node->leftchild;
                    //parent->leftchild->rightChild = node->rightChild;

                }
                else if (parent->rightChild == node) {
                    parent->rightChild = node->leftchild;
                    //parent->rightChild->leftchild = node->rightChild; 
                }
            }
            else {
                TreeNode *leftNode = MinTreeNode(node->rightChild);

                //第一步   
                leftNode->leftchild = node->leftchild;
                //第二步
                TreeNode* leftNodep = leftNode->parent;
                leftNodep->leftchild = leftNode->rightChild;

                //第三步
                leftNode->rightChild = node->rightChild;

                //第四步
                if (parent == NULL)  
                    root = leftNode; 
                else { 
                    if (parent->leftchild == node) 
                        parent->leftchild = leftNode; 
                    else if (parent->rightChild == node) 
                        parent->rightChild = leftNode; 
                    //leftNode->parent = parent;
                }
            }
            //释放节点的内存
            free(node);
            //节点数据置空
            node->data = NULL;
            //父指针 
            node->parent = NULL;
            node = NULL;
        }



    }

}


TreeNode* searchNode(int data) {
    if (root == NULL) {
        return NULL;
    }
    TreeNode* node = root;
    while (node != NULL) {
        if (node->data == data) {
            return node;
        }
        else if (node->data < data) {
            node = node->rightChild;
        }
        else if (node->data > data) {
            node = node->leftchild;
        }
    }

    return NULL;
}

int main(int argc, char* argv[])
{

    int arrays[] = {12, 3, 23, 5, 8, 1, 19, 2, 4, 56, 45, 34, 23, 33};


    for (int i = 0; i < 14; i++)
        put(arrays[i]);


    printf("中序遍历\n");
    midOrderTraverse(root);

    printf("\n");
    printf("前序遍历\n");
    printf("\n");
    modleOrderTraverse(root);
    printf("\n");
    printf("后序遍历\n");
    printf("\n");
    maxOrderTraverse(root);
    TreeNode * del = searchNode(33);

    delNode(del);
    printf("\n");
    midOrderTraverse(root);

    //modleOrderTraverse(root);
    printf("\n");
    system("pause");
    return EXIT_SUCCESS;
}

Java代码的实现

package com.songli.BinarayTree;

import java.util.NoSuchElementException;

import com.sun.jmx.snmp.BerException;

/**
    > Author: songli
    > QQ: 2734030745
    > Mail: 15850774503@163.com
    > CSDN: http://my.csdn.net/Poisx
    > github: https://github.com/chensongpoixs
 */
public class SearchBinaryTree {
    //根节点
    public TreeNode root;

    public class TreeNode {

        int data;
        TreeNode leftChild;
        TreeNode rightChild;
        TreeNode parent;

        /**
         * @return the data
         */
        public int getData() {
            return data;
        }
        /**
         * @param data the data to set
         */
        public void setData(int data) {
            this.data = data;
        }
        /**
         * @return the leftChild
         */
        public TreeNode getLeftChild() {
            return leftChild;
        }
        /**
         * @param leftChild the leftChild to set
         */
        public void setLeftChild(TreeNode leftChild) {
            this.leftChild = leftChild;
        }
        /**
         * @return the rightChild
         */
        public TreeNode getRightChild() {
            return rightChild;
        }
        /**
         * @param rightChild the rightChild to set
         */
        public void setRightChild(TreeNode rightChild) {
            this.rightChild = rightChild;
        }
        /**
         * @return the parent
         */
        public TreeNode getParent() {
            return parent;
        }
        /**
         * @param parent the parent to set
         */
        public void setParent(TreeNode parent) {
            this.parent = parent;
        }
        /**
         * 构造器
         * @param data
         * @param leftChild
         * @param rightChild
         * @param parent
         */
        public TreeNode(int data) {
            super();
            this.data = data;
            this.leftChild = null;
            this.rightChild = null;
            this.parent = null;
        } 




    }

    public TreeNode getRoot() {
        return root;
    }
    /**
     * 添加节点
     * @param data
     * @return
     */
    public TreeNode put(int data) {
        //判断根节点是否为空
        if (root == null){
            //创建节点
            TreeNode node = new TreeNode(data);
            //赋值给根节点
            root = node;
            return node; //返回节点
        }

        //遍历比较
        TreeNode parent = null;
        //得到根节点
        TreeNode node = root;
        //遍历比较节点的大小
        for (; node != null; ) {
            parent = node;
            //比较当前节点的值
            if (data < node.data) {
                node = node.leftChild;
            } else if(data > node.data) {
                node = node.rightChild;
            } else {
                //相等情况返回
                return node;
            }
        }

        //添加节点
        TreeNode newNode = new TreeNode(data);
        if (data < parent.data) {
            parent.leftChild = newNode;
        } else {
            parent.rightChild = newNode;
        }

        //child指针父节点parent
        newNode.parent = parent;

        return newNode;
    }

    /**
     * 前序遍历
     * @param root
     */
    public void preOrderTraverse(TreeNode root) {
        if (root == null) 
            return;

        System.out.println("pro Order : " + root.data);
        preOrderTraverse(root.leftChild);
        preOrderTraverse(root.rightChild);
    }
    /**
     * 中序遍历                            时间复杂度 ：O(n)
     * @param root
     */
    public void midOrderTraverse(TreeNode root) {
        if (root == null) 
            return;
        midOrderTraverse(root.leftChild);
        System.out.print(root.data + " ");
        midOrderTraverse(root.rightChild);
    }


    /**
     * 
     * @param data
     * @return
     */
    public TreeNode searchNode(int data) {
        if (root == null) 
            return null;

        //比较right和left节点的大小   
        TreeNode node = root;
        //在java中不要使用   递归
        while (node != null) {
            //比较当前节点
            if (node.data == data)
                return node;
            else if (node.data < data) 
                node = node.rightChild;
            else if (node.data > data) 
                node = node.leftChild;
        }

        //不存节点在返回null
        return null;
    }



    /**
     * 删除一个节点
     * @param node
     */
    private void delNode(TreeNode node) {
        if (node == null) {
            //异常报错历   没有成
            throw new NoSuchElementException();
        } else {
            TreeNode parent = node.parent;
            //1,没有right 和left 子树
            if ((node.leftChild == null) && (node.rightChild == null)) {
                //判断父节点是否为空
                if (parent == null) {
                    root = null;
                } else if (parent.leftChild == node) {
                    parent.leftChild = null;
                } else if (parent.rightChild == node) {
                    parent.rightChild = null;
                }
                node.parent = null;
            } else if ((node.leftChild != null) && (node.rightChild == null)) {
                //2,有left子树
                if (parent == null) {
                    node.parent = null;
                    parent.leftChild.parent = null;  //改变孩子的指针 
                    root = node.leftChild;
                } else {
                    if (parent.leftChild == node) {
                        parent.leftChild = node.leftChild;              
                    } else if (parent.rightChild == node) {
                        parent.rightChild = node.rightChild;
                    }
                    node.parent = null;
                }
            } else if ((node.leftChild == null) && (node.rightChild != null)) {
                //3,有ringht子树
                if (parent == null) {
                    node.parent = null;
                    parent.rightChild.parent = null;  //改变孩子的指针 
                    root = node.rightChild;
                } else {
                    if (parent.leftChild == node) {
                        parent.leftChild = node.leftChild;
                    } else if (parent.rightChild == node) {
                        parent.rightChild = node.rightChild;
                    }

                    node.parent = null;
                }

            } else if ((node.leftChild != null) && (node.rightChild != null)) {
                //4,有letf， ringht树
                if (node.rightChild.leftChild == null) {
                    if (parent == null) {
                        root = node.rightChild;
                    } else {
                        if (parent.leftChild == node) {
                            parent.leftChild = node.rightChild;
                        } else if (parent.rightChild == node) {
                            parent.rightChild = node.rightChild;
                        }
                    }
                    node.parent = null;
                } else {
                    TreeNode newleftNode = MinleftNode(node.rightChild);

                    //第一步
                    newleftNode.leftChild = node.leftChild;

                    //第二步
                    TreeNode newleftNodeP = newleftNode.parent;
                    newleftNodeP.leftChild = newleftNode.rightChild;

                    //第三步
                    newleftNode.rightChild = node.rightChild;

                    //第四步
                    if (parent == null) {
                        root = newleftNode;
                    } else {
                        if (parent.leftChild == node) {
                            parent.leftChild = newleftNode;
                        } else if (parent.rightChild == node) {
                            parent.rightChild = newleftNode;
                        }
                    }   
                }
                //node.parent = null;
                //node = null;      
            }   
        }
    }

    /**
     * @param rightChild
     * @return
     */
    private TreeNode MinleftNode(TreeNode node) {
        // TODO Auto-generated method stub
        if (node == null) {
            return null;
        } else {
            while (node.leftChild != null) {
                node = node.leftChild;
            }
            return node;
        }
    }
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int arrays[] = {12, 3, 23, 5, 8, 1, 19, 2, 4, 56, 45, 34, 23, 33};

        SearchBinaryTree tree = new SearchBinaryTree();

        for (int i: arrays) 
            tree.put(i);


        //打印
        tree.midOrderTraverse(tree.root);

        //查找树
        TreeNode node = tree.searchNode(23);
        //System.out.println(node != null ? node.data: null);

        System.out.println();

        tree.delNode(node);
        //打印
        tree.midOrderTraverse(tree.root);

    }

}
chen_song_
关注
专栏目录
二叉树的查询
csdn_edition的博客
11-26 591
我们以下面这颗二叉树举例，来实现二叉树查询的递归代码和非递归代码。 比如说要查找B这个节点，我们就返回B这个节点的地址，用非递归实现我们可以借助非递归的先序、中序或者后序遍历来解决，这里借助的是先序遍历。给出代码： BtNode* Findvalue(BtNode* ptr, ElemType val) { if (ptr == NULL) { return NULL; } stack<BtNode*> st; st.push(ptr); while (!st.empty())
二叉查询树
齐光的博客
10-02 671
Java二叉查询树（Binary Search Tree）， 二叉树的遍历（前序遍历、中序遍历、后续遍历、层序遍历）
二叉树查找
Stone 不会喝水的博客
04-05 90
C实现与学习 二叉查找树学习 C++STL中的查找方法
二叉树的查找
12-11
创建二叉排序树 的第一种方法（通过insertBST创建） 二叉排序树的查找 （递归实现） * * 查找可以有两种实现方法，一种是递归，一种是while 循环。 * 在插入和删除操作中也首先需要查询操作，这时使用while 循环比较好，可以知道要查询结点的双亲结点
二叉树查找树
weixin_41837346的博客
01-02 175
二叉查找树（Binary Search Tree） 二叉搜索树 快速查找，插入，删除 定义：每个节点，都不大于它的右子节点，且不小于它的左子节点 查找：递归：大找右边，小找左边，找到或没了返回 插入：递归：大找右空，不空往右；小找左空，不空往左 删除 先找，并记录父节点 无子节点，父节点指向null 一个子节点，父节点指向它 2个子节点，替换和删除（右侧最小节点） 排序：中序遍历，复杂度O...
创建二叉树 二叉树如何删除节点操作教程
09-05
二叉树的操作主要包括创建、插入节点和删除节点。接下来，我们将深入探讨这些操作。 首先，创建二叉树通常涉及从用户输入的数据构造树结构。在提供的代码中，`createBiTree` 函数用于创建二叉树。用户被要求输入一...
二叉树的查找和删除.zip
12-06
二叉树删除操作相对复杂，因为要考虑以下几种情况： 1. 要删除的节点没有子节点：直接删除即可。 2. 要删除的节点有一个子节点：用其子节点替换该节点并删除原节点。 3. 要删除的节点有两个子节点：需要找到其右子...
二叉树面试题 树和二叉树总结.doc
02-24
树和二叉树的操作包括遍历、插入、删除、搜索等。这些操作对树和二叉树的结构和性质产生了影响。 四、树和二叉树的应用 树和二叉树有广泛的应用，例如在数据库索引、文件系统、编译器、算法设计等领域。 五、选择...
二叉树插入和删除
09-02
在二叉树数据结构中，插入和删除操作是基本的操作之一。本文将深入探讨这些概念，并提供C语言实现的示例。 首先，二叉树是一种特殊的树形数据结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树...
西南科技大学SWUST OJ 数据结构 树和二叉树答案 树和二叉树.zip
01-01
- **插入与删除**：在二叉树中，需要考虑平衡问题，如AVL树和红黑树。 - **高度**：树的最大层数，影响查找、插入和删除的效率。 - **平衡因子**：用于衡量二叉搜索树的平衡程度。 4. **特殊类型的树**： - **...
二叉树-二叉树的查找
qq_30657195的博客
06-03 824
三种查找方式： 前序查找、中序查找、后序查找。 前序查找 比较当前节点，如果是，返回查找结果。如果不是就向左递归查找，如果左边没有就向右边递归查找。设置no=5，针对该题，前序遍历共4次。 中序遍历 先向左递归查找，如果左子树没有，再比较当前节点，如果仍然不是则向右遍历查找。 后序遍历 先向左递归查找，如果左子树没有，就向右边子树递归查找，如果还没有，再比较当前节点。 代码实现 package chapter18.binarytree object BinaryTreeDemo { def mai
[SinGuLaRiTy] 平衡树
weixin_34290631的博客
03-22 253
【SinGuLaRiTy-1009】 Copyright (c) SinGuLaRiTy 2017. All Rights Reserved. 二叉查找树 二叉查找树是指具有下列性质的非空二叉树： ⑴若根结点的左子树不空，则左子树的所有结点值均小于根结点值； ⑵若根结点的右子树不空，则右子树的所有结点值均不小于根结点值； ⑶根结的左右树也分别为二叉排序树； 显然，对二叉排序树进行中序遍...
二叉树搜索树
一条二哈
10-04 442
简单的二叉树搜索树 二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。 原理：二叉排序树的查找过程和次优二叉树类似，通常采取二叉链表作为二叉排序树的存储结构...
【 二叉树查询Binary Search Tree】
qq_43479628的博客
04-21 267
二叉树查询Binary Search Tree1.定义2.方法2.1 基础类2.2 操作类2.3 添加操作2.4 查找操作2.5 遍历操作：2.6 删除操作3. 完整代码 1.定义 二叉树，Binary Search Tree，简称BST 特性： 若任意节点的左子树不为空，则左子树上所有节点的值均小于它的根节点的值； 若任意节点的右子树不为空，则右子树上所有节点的值均大于它的根节点的值； 任意节点的左右树也分别为二叉查找树 2.方法 2.1 基础类 节点Node 数据元素 左子树 右子树 代码： c
数据结构之二叉树的查找
GiantCrocodile的博客
03-23 343
二叉树的查找方式有三种，分别是先序中序和后序。 先序思路： 判断当前的节点中的No和传过来要查找的是否一致 相等返回 不相等判断当前节点左子节点是否为空 如果不为空 继续比较 查找返回 如果 为空 或者没有找到 查看右子节点 查到返回否则返回null 中序思路： 判断当前的左子节点是否为空，不为空递归查询左子节点 查到返回 左子节点为空或者左边没有查到，查询当前节点 查到返回 根节...
数据结构之二叉树查找树
风吟
09-30 649
树由节点和边组成。整棵树有一个最上端的节点，称为根节点（root）。每个节点可以拥有具方向性的边，用来和其他节点相连。相连节点之中，在上者称为父节点，在下者称为子节点。无子节点者称为叶节点。根节点至任何节点之间有唯一的路径，路径所经过的边数我们称作路径长度。根节点至任一节点的路径长度我们称作该节点的深度。根节点的深度永远是0。某节点至其最深的子节点的路径长度，我们称为该节点的高度。 子节点如果...
数据结构：二叉查找树
最新发布
梁辰兴的博客
09-17 1043
二叉查找树（Binary Search Tree，简称BST）是一种特殊的二叉树，其中每个节点都有一个可比较的键和一个关联的值，且对于每个节点，其左子树的所有键都小于节点的键，而右子树的所有键都大于节点的键。简介二叉查找树是一种自我平衡的二叉树，它的中序遍历会得到一个升序的序列。二叉查找树的每个节点都包含一个键和一个值，其中键用于保持树的排序，而值则可以是任何类型的数据。二叉查找树的主要操作包括插入、查找和删除。图示50/ \30 70/ \ / \
查询二叉树的实现
AC_MI的专栏
03-18 1842
首先是Node 类的定义package SearchTree; public class Node { private Node left; private Node right; private Node Parrent; int data; public Node(Node left, Node right, Node parrent, int data) { supe
二叉搜索树（查找、插入、删除的讲解实现+图文并茂）
bang___bang_的博客
05-25 8199
本文讲解并模拟实现二叉搜索树，详解它的查找、插入、删除及实现，并对二叉搜索树的应用场景进行描述，最后进行了性能分析！
树和二叉树的概念与基本术语解析
"第六章树和二叉树的讲解，由西南大学计算机与信息科学学院熊海灵提供，涵盖了树的定义、基本术语、二叉树的概念和相关属性。" 在计算机科学中，树是一种非常重要的数据结构，它模拟了现实世界中许多层次关系和分枝...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值