Java 二叉搜索树的生成

当我有一个包含100个元素的数组列表，比如

{3,2,6,7，…，99}

？

首先对这个数组排序，而不是使用BST

编辑

1-BST在排序数组上工作

int[] someInts = {3,2,6,7, /*...,*/ 99};

// use a TreeSet
TreeSet<Integer> ints = new TreeSet<Integer>();
for (int i : someInts)
    ints.add(i);

System.out.println(ints.contains(2)); // true      
System.out.println(ints.contains(5)); // false

// or sort the array and use Arrays.binarySearch
Arrays.sort(someInts);
System.out.println(Arrays.binarySearch(someInts, 2) >= 0); // true
System.out.println(Arrays.binarySearch(someInts, 5) >= 0); // false

---

2-使用此psudo代码

我相信

树集

是二进制搜索树的实现。由于整数具有自然顺序，您可以简单地循环遍历整数数组，并将它们全部添加到

树集

还要注意，有一个方法可以在排序数组中进行二进制搜索

int[] someInts = {3,2,6,7, /*...,*/ 99};

// use a TreeSet
TreeSet<Integer> ints = new TreeSet<Integer>();
for (int i : someInts)
    ints.add(i);

System.out.println(ints.contains(2)); // true      
System.out.println(ints.contains(5)); // false

// or sort the array and use Arrays.binarySearch
Arrays.sort(someInts);
System.out.println(Arrays.binarySearch(someInts, 2) >= 0); // true
System.out.println(Arrays.binarySearch(someInts, 5) >= 0); // false

int[]someInts={3,2,6,7，/*…，*/99}；
//使用树集
TreeSet ints=新的TreeSet（）；
for（int i:someint）
内加（i）；
System.out.println（ints.contains（2））；//真的
System.out.println（ints.contains（5））；//假的
//或者对数组进行排序并使用Arrays.binarySearch
数组。排序（someInts）；
System.out.println（Arrays.binarySearch（someInts，2）>=0）；//真的
System.out.println（Arrays.binarySearch（someInts，5）>=0）；//假的
除非您想自己实现所有功能（在这种情况下，您可能需要检查），否则您应该查看[Collections.binarySearch][2]

[2] ：，java.lang.Object）
我最近完成了一个项目，我们基本上必须这样做

你可以看看这门课

编辑：这是C++，我看到你在用java编码，我道歉！p>
/**************************************
 *  Tree.cpp - Created by DT
 **************************************
 *
 *  Functions:
 *
 *  public:
 *      Tree();
 *      void addNode(int);
 *      bool findID(int);
 *      Node* findNode(int);
 *      Node* findParent(int);
 *      bool deleteID(int);
 *      Node* findMaximum(Node*);
 *      Node* findMinimum(Node*);
 *      void printInOrder();
 *      void printPreOrder();
 *      void printPostOrder();
 *      int recurseHeight(Node*);
 *      int getHeight();
 *      void inOrder(Node*);
 *      void preOrder(Node*);
 *      void postOrder(Node*);
 *
 ***************************************/
#include <iostream>
#include "Node.h"
#include "Tree.h"

using namespace std;

Tree::Tree() {
    root = NULL;
}
///////////////////////////////
// AddNode Function:
///////////////////////////////
void Tree::addNode(int id) {
    if(findNode(id)) {
        cout << "This ID already exists in the tree" << endl;
        return;
    }
    //if(id == 2147483647) {
    //  cout << "Overflow Detected: Did you enter a really big number?\n";
    //  cout << "This ID is being stored as 2147483647\n";
    //}
    Node *newNode = new Node();
    newNode->id = id;
    if(root == NULL) {
        root = newNode;
        return;
    }
    Node *nextNode = root;
    Node *lastNode = nextNode;
    while(nextNode != NULL) {
        if(id <= nextNode->id) {
            lastNode = nextNode;
            nextNode = nextNode->leftChild;
        }
        else {
            lastNode = nextNode;
            nextNode = nextNode->rightChild;
        }
    }
    if(id <= lastNode->id)
        lastNode->leftChild = newNode;
    else
        lastNode->rightChild = newNode;
}
///////////////////////////////
// FindID Function:
///////////////////////////////
bool Tree::findID(int id) {
    Node *finder = root;
    while(finder != NULL) {
        if(id == finder->id)
            return true;
        if(id <= finder->id)
            finder = finder->leftChild;
        else
            finder = finder->rightChild;
    }
    return false;
}
///////////////////////////////
// FindNode Helper Function:
///////////////////////////////
Node* Tree::findNode(int id) {
    Node *finder = root;
    while(finder != NULL) {
        if(id == finder->id)
            return finder;
        if(id <= finder->id)
            finder = finder->leftChild;
        else
            finder = finder->rightChild;
    }
    return NULL;
}
///////////////////////////////
// FindParent Helper Function:
///////////////////////////////
Node* Tree::findParent(int id) {
    Node *parent = NULL;
    Node *finder = root;
    while(finder != NULL) {
        if(id == finder->id)
            return parent;
        parent = finder;
        if(id <= finder->id)
            finder = finder->leftChild;
        else
            finder = finder->rightChild;
    }
    return NULL;
}
///////////////////////////////
// DeleteID Function:
///////////////////////////////
bool Tree::deleteID(int id) {
    if(root == NULL)
        return false;
    Node *toDelete = findNode(id);      //Find the node to delete
    if(toDelete == NULL)                //If we can't find it, return false
        return false;
    Node *parent = findParent(id);      //Find the parent of the node to delete
    Node *justInCase;                   //In case we are deleting the root node
    bool deletingRoot = false;          //This is a special case so handle it differently
    if(root->id == id) {                //If we're deleting the root node
        justInCase = new Node();        //Let's create a fake parent for the root
        justInCase->leftChild = root;   //Just to make sure that we can run checks on parents
        justInCase->rightChild = NULL;
        justInCase->id = 0;             //Later on in the code
        parent = justInCase;            //Set the parent of the root to our new fake node
        deletingRoot = true;            //Let the end of our function know we're deleting the root
    }
    bool deletingLeftChild = (parent->leftChild == toDelete);
    if(toDelete->leftChild == NULL && toDelete->rightChild == NULL) {
        if(toDelete == root)
            root = NULL;
        if(deletingLeftChild)
            parent->leftChild = NULL;
        else
            parent->rightChild = NULL;
        delete toDelete;
        return true;
    }
    if((toDelete->leftChild == NULL || toDelete->rightChild == NULL) && (parent != NULL && !deletingRoot)) {
        if(deletingLeftChild)
            parent->leftChild = (toDelete->leftChild == NULL) ? toDelete->rightChild : toDelete->leftChild;
        else
            parent->rightChild = (toDelete->leftChild == NULL) ? toDelete->rightChild : toDelete->leftChild;
        delete toDelete;
        return true;
    }
    Node *replacer = findMaximum(toDelete->leftChild);          //Replace the node we're deleting with the hightest LEFT Child
    if(replacer == NULL || replacer == toDelete)                //If we can't find a left child (in case of deleting root)
        replacer = findMinimum(toDelete->rightChild);           //Find the smallest RIGHT child
    Node *replacerParent = findParent(replacer->id);            //Find the parent of this child
    if(replacerParent != NULL) {                                //If this child has a parent
        if(replacerParent->leftChild == replacer) {             //If the child is to the left of the parent
            if(replacer->leftChild != NULL)                     //And the left child has a child of its own (in case of findMinimum/maximum)
                replacerParent->leftChild = replacer->leftChild;//set the parent's child to this child's node
            else
                replacerParent->leftChild = NULL;               //Otherwise, set the parent's child to NULL
        }
        else {                                                  //In the case of Right Child
            if(replacer->rightChild != NULL)                    //Do the same thing
                replacerParent->rightChild = replacer->rightChild;
            else
                replacerParent->rightChild = NULL;
        }
    }
    toDelete->id = replacer->id;                                //Swap the IDs of the nodes we're deleting
    delete replacer;                                            //And delete the minimum or maximum that we found
    return true;
}
///////////////////////////////
// FindMaximum Helper Function:
///////////////////////////////
Node* Tree::findMaximum(Node *theNode) {
    if(theNode == NULL)
        return NULL;
    Node *finder = theNode;
    Node *last = finder;
    while(finder != NULL) {
        last = finder;
        finder = finder->rightChild;
    }
    return last;
}
///////////////////////////////
// FindMinimum Helper Function:
///////////////////////////////
Node* Tree::findMinimum(Node *theNode) {
    if(theNode == NULL)
        return NULL;
    Node *finder = theNode;
    Node *last = finder;
    while(finder != NULL) {
        last = finder;
        finder = finder->leftChild;
    }
    return last;
}
///////////////////////////////
// PrintInOrder Function:
///////////////////////////////
void Tree::printInOrder() {
    inOrder(root);                                      //Recurse through our root
    cout << "\b " << endl;
}
///////////////////////////////
// PrintPostOrder Function:
///////////////////////////////
void Tree::printPostOrder() {
    postOrder(root);                                    //Recurse through our root
    cout << "\b " << endl;
}
///////////////////////////////
// PrintPreOrder Function:
///////////////////////////////
void Tree::printPreOrder() {
    preOrder(root);                                 //Recurse through our root
    cout << "\b " << endl;
}
///////////////////////////////
// RecurseHeight Function:
///////////////////////////////
int Tree::recurseHeight(Node *node) {
    if(node == NULL) return -1;
    return 1 + max(recurseHeight(node->leftChild),recurseHeight(node->rightChild));
}
///////////////////////////////
// GetHeight Function:
///////////////////////////////
int Tree::getHeight() { return recurseHeight(root); }   //Recurse through our root
///////////////////////////////
// InOrder Function:
///////////////////////////////
void Tree::inOrder(Node *cNode) {
    if(cNode == NULL)
        return;
    inOrder(cNode->leftChild);
    cout << cNode->id << "-";
    inOrder(cNode->rightChild);
}
///////////////////////////////
// PostOrder Function:
///////////////////////////////
void Tree::postOrder(Node *cNode) {
    if(cNode == NULL)
        return;
    postOrder(cNode->leftChild);
    postOrder(cNode->rightChild);
    cout << cNode->id << "-";
}
///////////////////////////////
// PreOrder Function:
///////////////////////////////
void Tree::preOrder(Node *cNode) {
    if(cNode == NULL)
        return;
    cout << cNode->id << "-";
    preOrder(cNode->leftChild);
    preOrder(cNode->rightChild);
}

/**************************************
*Tree.cpp-由DT创建
**************************************
*
*职能：
*
*公众：
*树（）；
*void addNode（int）；
*布尔·芬迪德（国际）；
*节点*findNode（int）；
*节点*findParent（int）；
*布尔删除ID（int）；
*节点*查找最大值（节点*）；
*节点*findminium（节点*）；
*void printInOrder（）；
*void printproorder（）；
*作废打印PostOrder（）；
*int递归八（Node*）；
*int getHeight（）；
*按顺序无效（节点*）；
*无效前序（节点*）；
*无效邮购（节点*）；
*
***************************************/
#包括
#包括“Node.h”
#包括“Tree.h”
使用名称空间std；
Tree:：Tree（）{
root=NULL；
}
///////////////////////////////
//AddNode函数：
///////////////////////////////
void树：：addNode（int-id）{
if（findNode（id））{
cout leftChild=newNode；
其他的
lastNode->rightChild=newNode；
}
///////////////////////////////
//FindID功能：
///////////////////////////////
布尔树：：findID（int-id）{
Node*finder=root；
while（finder！=NULL）{
if（id==finder->id）
返回true；
如果（id）
finder=finder->leftChild；
其他的
finder=finder->rightChild；
}
返回false；
}
///////////////////////////////
//FindNode辅助函数：
///////////////////////////////
节点*树：：findNode（int-id）{
Node*finder=root；
while（finder！=NULL）{
if（id==finder->id）
返回查找器；
如果（id）
finder=finder->leftChild；
其他的
finder=finder->rightChild；
}
返回NULL；
}
///////////////////////////////
//FindParent辅助函数：
///////////////////////////////
节点*树：：findParent（int id）{
Node*parent=NULL；
Node*finder=root；
while（finder！=NULL）{
if（id==finder->id）
返回父母；
父=查找者；
如果（id）
finder=finder->leftChild；
其他的
finder=finder->rightChild；
}
返回NULL；
}
///////////////////////////////
//DeleteID函数：
///////////////////////////////
布尔树：：deleteID（int-id）{
if（root==NULL）
返回false；
Node*toDelete=findNode（id）；//查找要删除的节点
if（toDelete==NULL）//如果找不到它，则返回false
返回false；
Node*parent=findParent（id）；//查找要删除的节点的父节点
Node*justInCase；//如果要删除根节点
bool deletingRoot=false；//这是一种特殊情况，因此处理方式不同
如果（root->id==id）{//如果我们正在删除根节点
justInCase=new Node（）；//让我们为根目录创建一个假父目录
justInCase->leftChild=root；//只是为了确保我们可以对父母进行检查
justInCase->rightChild=NULL；
justInCase->id=0；//稍后在代码中
parent=justInCase；//将根的父节点设置为新的伪节点
deletingRoot=true；//让函数末尾知道我们正在删除根
}
bool deletingLeftChild=（父->leftChild==toDelete）；
if（toDelete->leftChild==NULL&&toDelete->rightChild==NULL）{
if（toDelete==根）
root=NULL；
if（删除leftchild）
parent->leftChild=NULL；
其他的
parent->rightChild=NULL；
删除toDelete；
返回true；
}
if（（toDelete->leftChild==NULL | | toDelete->rightChild==NULL）&&（parent！=NULL&&！deletingRoot））{
if（删除leftchild）
父项->左子项=（toDelete->leftChild==NULL）？toDelete->rightChild:toDelete->leftChild；
其他的
父->右孩子=（toDelete->leftChild==NULL）？toDelete->rightChild:toDelete->leftChild；
删除toDelete；
返回true；
}
Node*replacer=findMaximum（toDelete->leftChild）；//将要删除的节点替换为最左高的子节点
if（replacer==NULL | | replacer==toDelete）//如果我们找不到左子级（在删除根的情况下）
replacer=findminium（todelite->rightChild）；//查找最小的右子级
Node*replacerParent=findParent（replacer->id）；//查找此子级的父级
if（replacerParent！=NULL）{//如果此子级有父级
如果（替换父对象->左子对象）