Binary-Search-010-Tree

于 2019-04-19 10:24:31 发布
阅读量94 收藏
点赞数
分类专栏： 数据结构与算法

BST.h

#ifndef BINARY_SEARCH_TREE_BST_H
#define BINARY_SEARCH_TREE_BST_H

#include <iostream>
#include <queue>
#include <cassert>

using namespace std;


template<typename Key, typename Value>
class BST{

private:
    struct Node{
        Key key;
        Value value;
        Node *left;
        Node *right;

        Node(Key key, Value value){
            this->key = key;
            this->value = value;
            this->left = this->right = NULL;
        }

        Node(Node *node){
            this->key = node->key;
            this->value = node->value;
            this->left = node->left;
            this->right = node->right;
        }
    };

    Node *root;
    int count;

public:
    BST(){
        root = NULL;
        count = 0;
    }

    ~BST(){
        destroy(root);
        assert( count == 0 );
    }

    // 返回二叉树的元素个数
    int size(){
        return count;
    }

    // 返回二叉树是否为空
    int isEmpty(){
        return count == 0;
    }

    // 插入节点
    void insert(Key key, Value value){
        root = insert(root, key, value);
    }

    // 检查二叉树是否包含键值为key的元素
    bool contain(Key key){
        return contain(root, key);
    }

    // 在二叉树中寻找键值为key的value值
    Value* search(Key key){
        return search(root, key);
    }

    // 前序遍历
    void preOrder(){
        preOrder(root);
    }

    // 中序遍历
    void inOrder(){
        inOrder(root);
    }

    // 后序遍历
    void postOrder(){
        postOrder(root);
    }

    // 层序遍历
    void levelOrder(){
        queue<Node*> q;
        q.push(root);
        while( !q.empty() ){
            Node *node = q.front();
            q.pop();
            cout<<node->key<<" ";
            if( node->left )
                q.push(node->left);
            if( node->right )
                q.push(node->right);
        }
    }

    // 寻找最小的键值
    Key minimum(){
        assert( count != 0 );
        Node* minNode = minimum(root);
        return minNode->key;
    }

    // 寻找最大的键值
    Key maximum(){
        assert( count != 0 );
        Node* maxNode = maximum(root);
        return maxNode->key;
    }

    // 从二叉树中删除最小值所在节点
    void removeMin(){
        if( root )
            root = removeMin( root );
    }

    // 从二叉树中删除最大值所在节点
    void removeMax(){
        if( root )
            root = removeMax( root );
    }

    // 从二叉树中删除键值为key的节点
    void remove(Key key){
        root = remove(root, key);
    }

private:
    // 向以node为根的二叉搜索树中,插入节点(key, value)
    // 返回插入新节点后的二叉搜索树的根
    Node* insert(Node* node, Key key, Value value){
        if( node == NULL ){
            count += 1;
            return new Node(key, value);
        }

        if( key == node->key )
            node->value = value;
        else if( key < node->key )
            node->left = insert(node->left, key, value);
        else // key > node->key
            node->right = insert(node->right, key, value);

        return node;
    }

    // 查看以node为根的二叉搜索树中是否包含键值为key的节点
    bool contain(Node* node, Key key){
        if( node == NULL )
            return false;

        if( key == node->key )
            return true;
        else if( key < node->key )
            return contain(node->left, key);
        else
            return contain(node->right, key);
    }

    // 在以node为根的二叉搜索树中查找key所对应的value
    Value* search(Node* node, Key key){

        if( node == NULL )
            return NULL;

        if( key == node->key )
            return &(node->value);
        else if( key < node->key )
            return search(node->left, key);
        else
            return search(node->right, key);
    }

    // 对以node为根的二叉搜索树进行前序遍历
    void preOrder(Node* node){

        if( node != NULL){
            cout<<node->key<<" ";
            preOrder(node->left);
            preOrder(node->right);
        }
    }

    // 对以node为根的二叉搜索树进行中序遍历
    void inOrder(Node* node){

        if( node != NULL){
            inOrder(node->left);
            cout<<node->key<<" ";
            inOrder(node->right);
        }
    }

    // 对以node为根的二叉搜索树进行后序遍历
    void postOrder(Node* node){

        if( node != NULL){
            postOrder(node->left);
            postOrder(node->right);
            cout<<node->key<<" ";
        }
    }

    void destroy(Node* node){
        if( node != NULL){
            destroy(node->left);
            destroy(node->right);
            delete node;
            count--;
        }
    }

    // 在以node为根的二叉搜索树中,返回最小键值的节点
    Node* minimum(Node* node){
        if( node->left == NULL )
            return node;
        return minimum( node->left );
    }

    // 在以node为根的二叉搜索树中,返回最大键值的节点
    Node* maximum(Node* node){
        if( node->right == NULL )
            return node;
        return maximum( node->right );
    }

    // 删除掉以node为根的二分搜索树中的最小节点
    // 返回删除节点后新的二分搜索树的根
    Node* removeMin(Node* node){

        if( node->left == NULL ){
            Node* rightNode = node->right;
            delete node;
            count --;
            return rightNode;
        }

        node->left = removeMin( node->left );
        return node;
    }

    // 删除掉以node为根的二分搜索树中的最大节点
    // 返回删除节点后新的二分搜索树的根
    Node* removeMax(Node* node){

        if( node->right == NULL ){
            Node* leftNode = node->left;
            delete node;
            count --;
            return leftNode;
        }

        node->right = removeMax( node->right );
        return node;
    }

    // 删除掉以node为根的二分搜索树中键值为key的节点
    // 返回删除节点后新的二分搜索树的根
    Node* remove(Node* node, Key key){

        if( node == NULL )
            return NULL;

        if( key < node->key ){
            node->left = remove( node->left , key );
            return node;
        }
        else if( key > node->key ){
            node->right = remove( node->right, key );
            return node;
        }
        else{ // key == node->key

            if( node->left == NULL){
                Node *rightNode = node->right;
                delete node;
                count--;
                return rightNode;
            }

            if( node->right == NULL ){
                Node *leftNode = node->left;
                delete node;
                count--;
                return leftNode;
            }

            assert( node->left != NULL && node->right != NULL );

            Node *successor = new Node(minimum(node->right));
            count ++;

            successor->right = removeMin(node->right);
            successor->left = node->left;

            delete node;
            count --;

            return successor;
        }
    }

};
#endif

FileOps.h

#ifndef BINARY_SEARCH_TREE_FILEOPS_H
#define BINARY_SEARCH_TREE_FILEOPS_H

#include <string>
#include <iostream>
#include <fstream>
#include <vector>

using namespace std;


namespace FileOps{

    int firstCharacterIndex(const string& s, int start){
        for( int i = start ; i < s.length() ; i ++ )
            if( isalpha(s[i]) )
                return i;
        return s.length();
    }

    string lowerS( const string& s){

        string ret = "";
        for( int i = 0 ; i < s.length() ; i ++ )
            ret += tolower(s[i]);
        return ret;
    }

    bool readFile(const string& filename, vector<string> &words){

        string line;
        string contents = "";
        ifstream file(filename);
        if( file.is_open() ){
            while( getline(file, line))
                contents += ( line + "\n" );
            file.close();
        }
        else{
            cout<<"Can not open "<<filename<<" !!!"<<endl;
            return false;
        }

        int start = firstCharacterIndex(contents, 0);
        for( int i = start + 1 ; i <= contents.length() ; ){

            if( i == contents.length() || !isalpha(contents[i]) ){
                words.push_back( lowerS( contents.substr(start,i-start) ) );
                start = firstCharacterIndex(contents, i);
                i = start + 1;
            }
            else{
                i ++;
            }
        }

        return true;
    }
}
#endif

SequenceST.h

#ifndef BINARY_SEARCH_TREE_SEQUENCESEARCHLIST_H
#define BINARY_SEARCH_TREE_SEQUENCESEARCHLIST_H

#include <iostream>
#include <cassert>

using namespace std;


template<typename Key, typename Value>
class SequenceST{
private:
    struct Node{
        Key key;
        Value value;
        Node *next;

        Node(Key key, Value value){
            this->key = key;
            this->value = value;
            this->next = NULL;
        }
    };

    Node* head;
    int count;

public:
    SequenceST(){
        head = NULL;
        count = 0;
    }
    ~SequenceST(){
        while( head != NULL){
            Node *node = head;
            head = head->next;
            delete node;
            count --;
        }

        assert( head == NULL && count == 0 );
    }

    int size(){
        return count;
    }

    bool isEmpty(){
        return count == 0;
    };

    void insert(Key key, Value value){
        Node *node = head;
        while( node != NULL ){
            if( key == node->key ){
                node->value = value;
                return;
            }
            node = node->next;
        }

        Node *newNode = new Node(key, value);
        newNode->next = head;
        head = newNode;
        count ++;
    }

    bool contain(Key key){

        Node *node = head;
        while( node != NULL ){
            if( key == node->key ){
                return true;
            }
            node = node->next;
        }

        return false;
    }

    Value* search(Key key){

        Node *node = head;
        while( node != NULL ){
            if( key == node->key ){
                return &(node->value);
            }
            node = node->next;
        }

        return NULL;
    }

    void remove(Key key){

        if( key == head->key ){
            Node* delNode = head;
            head = head->next;
            delete delNode;
            count--;
            return;
        }

        Node *node = head;
        while( node->next != NULL && node->next->key != key )
            node = node->next;

        if( node->next != NULL ){
            Node* delNode = node->next;
            node->next = delNode->next;
            delete delNode;
            count --;
            return;
        }
    }
};
#endif

main_bst_basics.cpp

#include <iostream>
#include <ctime>
#include "BST.h"

using namespace std;


int main() {

    srand(time(NULL));
    BST<int,int> bst = BST<int,int>();

    int n = 10;
    for( int i = 0 ; i < n ; i ++ ){
        int key = rand()%n;
        // 为了后续测试方便,这里value值取和key值一样
        int value = key;
        cout<<key<<" ";
        bst.insert(key,value);
    }
    cout<<endl;

    // test size
    cout<<"size: "<<bst.size()<<endl<<endl;

    // test preOrder
    cout<<"preOrder: ";
    bst.preOrder();
    cout<<endl<<endl;

    // test inOrder
    cout<<"inOrder: ";
    bst.inOrder();
    cout<<endl<<endl;

    // test postOrder
    cout<<"postOrder: ";
    bst.postOrder();
    cout<<endl<<endl;

    // test levelOrder
    cout<<"levelOrder: ";
    bst.levelOrder();
    cout<<endl<<endl;

    // test contain and search
    for( int i = 0 ; i < n ; i ++ ){
        //cout<<"TRY "<<i<<" -- ";
        if( bst.contain(i) ){
            int* res = bst.search(i);
            //cout<<"contain "<<i<<", value: "<<*res<<endl;
            assert( res != NULL && *res == i );
        }
        //else{
        //    cout<<"not conatin "<<i<<endl;
        //}
    }

    return 0;
}

main_bst_remove.cpp

#include <iostream>
#include <ctime>
#include <ctime>
#include <algorithm>
#include "BST.h"

using namespace std;


void shuffle( int arr[], int n ){

    srand( time(NULL) );
    for( int i = n-1 ; i >= 0 ; i -- ){
        int x = rand()%(i+1);
        swap( arr[i] , arr[x] );
    }
}

int main() {

    srand(time(NULL));
    BST<int,int> bst = BST<int,int>();

    int n = 10000;
    for( int i = 0 ; i < n ; i ++ ){
        int key = rand()%n;
        // 为了后续测试方便,这里value值取和key值一样
        int value = key;
        //cout<<key<<" ";
        bst.insert(key,value);
    }
    //cout<<endl;


//    // test removeMin
//    while( !bst.isEmpty() ){
//        cout<<"min: "<<bst.minimum()<<endl;
//        bst.removeMin();
//        cout<<"After removeMin, size = "<<bst.size()<<endl;
//    }

    // test removeMax
    while( !bst.isEmpty() ){
        cout<<"max: "<<bst.maximum()<<endl;
        bst.removeMax();
        cout<<"After removeMax, size = "<<bst.size()<<endl;
    }

    // test remove
    // remove elements in random order
    int order[n];
    for( int i = 0 ; i < n ; i ++ )
        order[i] = i;
    shuffle( order , n );

    for( int i = 0 ; i < n ; i ++ )
        if( bst.contain( order[i] )){
            bst.remove( order[i] );
            cout<<"After remove "<<order[i]<<" size = "<<bst.size()<<endl;
        }

    return 0;
}

main_bst_sst_cmp.cpp

#include <iostream>
#include <string>
#include <vector>
#include "BST.h"
#include "SequenceST.h"
#include "FileOps.h"

using namespace std;


int main() {

    string filename = "bible.txt";
    vector<string> words;
    if( FileOps::readFile(filename, words) ) {

        cout << "There are totally " << words.size() << " words in " << filename << endl;

        cout << endl;


        // test BST
        time_t startTime = clock();
        BST<string, int> bst = BST<string, int>();
        for (vector<string>::iterator iter = words.begin(); iter != words.end(); iter++) {
            int *res = bst.search(*iter);
            if (res == NULL)
                bst.insert(*iter, 1);
            else
                (*res)++;
        }

        cout << "'god' : " << *bst.search("god") << endl;
        time_t endTime = clock();
        cout << "BST , time: " << double(endTime - startTime) / CLOCKS_PER_SEC << " s." << endl;

        cout << endl;


        // test SST
        startTime = clock();
        SequenceST<string, int> sst = SequenceST<string, int>();
        for (vector<string>::iterator iter = words.begin(); iter != words.end(); iter++) {
            int *res = sst.search(*iter);
            if (res == NULL)
                sst.insert(*iter, 1);
            else
                (*res)++;
        }

        cout << "'god' : " << *sst.search("god") << endl;

        endTime = clock();
        cout << "SST , time: " << double(endTime - startTime) / CLOCKS_PER_SEC << " s." << endl;

    }

    return 0;
}

main_sst.cpp

#include <iostream>
#include <ctime>
#include "SequenceST.h"

using namespace std;


int main() {

    srand(time(NULL));
    SequenceST<int,int> sst = SequenceST<int,int>();

    int n = 100;
    for( int i = 0 ; i < n ; i ++ ){
        int key = rand()%n;
        // 为了后续测试方便,这里value值取和key值一样
        int value = key;
        sst.insert(key,value);
    }

    cout<<"size: "<<sst.size()<<endl<<endl;

    for( int i = 0 ; i < n ; i ++ ){
        if( sst.contain(i) ){
            int* res = sst.search(i);
            assert( res != NULL && *res == i );
        }
    }

    return 0;
}
With__Sunshine
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Binary-Search-Tree
03-21
在"Binary-Search-Tree-main"这个文件中，可能包含了二叉搜索树的主要功能实现，如插入、查找、删除等操作的函数，以及可能的测试代码来验证这些操作的正确性。通过阅读和理解这个文件，你可以深入学习二叉搜索树的...
DoubleLinkedList-Binary-Search-Tree
05-02
DoubleLinkedList二进制搜索树•创建了自己的自定义双LinkedList类。 •创建了Node类继承的抽象类。... •在双重LinkedList和BinarySearch树类中，可以使用以下操作：1.添加-2.删除-3.遍历任何对象（字符串，整数等）
LeetCode-recover-binary-search-tree
六月二十七的博客
04-03 147
Two elements of a binary search tree (BST) are swapped by mistake. Recover the tree without changing its structure. Note: A solution using O(n) space is pretty straight forward. Could you devise a...
【recover-binary-search-tree】
lplp90908的博客
09-09 364
Two elements of a binary search tree (BST) are swapped by mistake. Recover the tree without changing its structure. Note:  A solution using O(n ) space is pretty straight forward. Could you devis
leetcode---recover-binary-search-tree---树
新博客：https://aping-dev.com/
10-10 279
Two elements of a binary search tree (BST) are swapped by mistake. Recover the tree without changing its structure. Note: A solution using O(n ) space is pretty straight forward. Could you devise a
convert-sorted-array-to-binary-search-tree
llwjason5555的博客
09-26 222
题目：Given an array where elements are sorted in ascending order, convert it to a height balanced BST.程序：class Solution { public:     TreeNode *sortedArrayToBST(vector<int> &num)     {         return Arr
recover-binary-search-tree
fistraiser的博客
08-21 142
Two elements of a binary search tree (BST) are swapped by mistake. Recover the tree without changing its structure. Note:  A solution using O(n ) space is pretty straight forward. Could you devise a...
LeetCode-validate-binary-search-tree
六月二十七的博客
04-03 167
Given a binary tree, determine if it is a valid binary search tree (BST). Assume a BST is defined as follows: The left subtree of a node contains only nodes with keysless thanthe node's key. The ...
validate-binary-search-tree
fistraiser的博客
08-21 197
Given a binary tree, determine if it is a valid binary search tree (BST). Assume a BST is defined as follows: The left subtree of a node contains only nodes with keys less than the node's key. The ...
convert-sorted-list-to-binary-search-tree
stloztoeplitz的博客
12-27 314
/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */ /** * Definition for binary tree * struc
binary-search-tree-iterator
专栏
02-29 411
https://leetcode.com/problems/binary-search-tree-iterator/ 利用非递归 中序遍历的思想class BSTIterator { private: stack<TreeNode*> s; public: BSTIterator(TreeNode *root) { while (!s.empty())
【validate-binary-search-tree】
lplp90908的博客
09-09 388
Given a binary tree, determine if it is a valid binary search tree (BST). Assume a BST is defined as follows: The left subtree of a node contains only nodes with keys less than the node's key.Th
binary-search-tree-experiment
05-18
导航到终端中的该存储库，然后运行node binary-search-tree-demo.js来执行程序（您将需要安装Node.js）。 打开文件并运行程序，交替使用Array.prototype.indexOf（）方法和随附的binarySearchIndexOf（）方法来观察...
binary-search-tree-exercises
05-11
breadthFirstSearch ：遍历树并使用“广度优先搜索”（从左到右）返回所有值的数组-您可以了解更多信息 DFSPreOrder ：遍历树并使用深度优先搜索预购返回所有值的数组-您可以阅读更多内容 DFSInOrder ：遍历树并使用...
信息技术教师技能大赛基础知识与专业技能试卷.doc
08-16
信息技术教师技能大赛基础知识与专业技能试卷.doc
基于ssm的新生报到系统(有报告) Javaee项目，ssm项目
最新发布
08-16
资源详情：https://blog.csdn.net/2302_78191516/article/details/141269772
奥柯玛DC16A电磁炉原理图.rar
08-16
奥柯玛DC16A电磁炉原理图
麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包
08-16
麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包 麒麟 V10 SP1 升级 python 3.7.9 所需 rpm 包
java-学生比赛指导管理系统（源码+数据库+论文）.rar
08-16
针对当前高校各类竞赛的报名现状，本文利用JSP技术以及Mysql数据库开发设计一款针对高校比赛指导及报名的线上平台，学生用户可以通过线上平台及时了解到高校内的各类赛事信息及规则，通过页面信息的了解可以实现在线的报名，对于报名审核通过的学生用户可以获得对应的比赛指导资料，利用线上平台帮助更好的提升比赛信息的传播范围以及比赛报名的效率，通过流程化和线上化的平台帮助建立在线的比赛报名及信息传递的平台。 关键词：JSP技术；Mysql数据库；比赛管理；在线报名；
7-1 complete binary search tree
04-11
b'7-1 完全二叉搜索树'。 完全二叉树的定义是：若设二叉树的深度为h，除第 h 层外，其它各层 (1~h-1) 的结点数都达到了最大个数，并且第 h 层所有的结点都连续集中在最左边的若干位置。这就是完全二叉树。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值