c++手写一个简单的栈以及二叉树

1. 数组实现一个栈

#include <iostream>
#include <string>
using namespace std;

template <class T>
class myStack{
private:
    T* data;
    size_t capacity;
    size_t size;
public:
    myStack(): data(nullptr), capacity(0), size(0){}
    ~myStack(){
        delete[] data;
    }
    void push(const T& item){
        if(size == capacity){
            resize(capacity * 2 + 1);
        }
        data[size++] = item;
    }
    void pop(){
        if(!empty()){
            --size;
        }
    }
    T& top(){
        if(!empty()){
            return data[size-1];
        }
        throw runtime_error("Stack is empty.");
    }
    const T& top() const{
        if(!empty()){
            return data[size-1];
        }
        throw runtime_error("stack is empty.");
    }
    bool empty() const{
        return size == 0;
    }
    size_t stackSize() const{
        return size;
    }
private:
    void resize(size_t newCapacity);
};

template<class T>
void myStack<T>::resize(size_t newCapacity){
    T* newData = new T[newCapacity];
    for(size_t i = 0; i < size; ++i){
        newData[i] = data[i];
    }
    delete[] data;
    data = newData;
    capacity = newCapacity;
}

int main(){
    myStack<int> stk1;
    stk1.push(1);
    stk1.push(2);
    stk1.push(3);

    cout << "Stack size: " << stk1.stackSize() << endl;
    cout << "Top element: " << stk1.top() << endl;

    stk1.pop();
    cout << "Stack size after pop: " << stk1.stackSize() << endl;
    cout << "Top element after pop: " << stk1.top() << endl;
    return 0;
}

2. 实现一个二叉搜索树

#include <iostream>
#include <vector>
#include <memory>
using namespace std;

struct TreeNode{
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode():
            val(0), left(nullptr), right(nullptr){}
    TreeNode(int x):
            val(x), left(nullptr), right(nullptr){}
    TreeNode(int x, TreeNode* p1, TreeNode* p2):
            val(x), left(p1), right(p2){}
};

template <class T>
class BST{
private:
        T root;
        T insertNode(T node, int value);
        void inorderTraversal(T node);
public:
        BST(): root(nullptr){}
        BST(T ptr): root(ptr){}
        void insert(int val);
        void inorder();
        ~BST(){cout << "using destruct fuction BST" << endl;}
};

template<class T>
T BST<T>::insertNode(T node, int value){
    if(node == nullptr){
        return new TreeNode(value);
    }
    if(value < node->val){
        node->left = insertNode(node->left, value);
    }else if(value > node->val){
        node->right = insertNode(node->right, value);
    }
        return node;
}

template<class T>
void BST<T>::inorderTraversal(T node){
    if(node == nullptr){
        return;
    }
    inorderTraversal(node->left);
    cout << node->val << " ";
    inorderTraversal(node->right);
}

template<class T>
void BST<T>::insert(int val){
    root = insertNode(root, val);
}

template<class T>
void BST<T>::inorder(){
    inorderTraversal(root);
    cout << endl;
}

typedef shared_ptr<BST<TreeNode*>> myshared_ptr;

int main(){
    //BST<TreeNode*> *bst = new BST<TreeNode*>();
    myshared_ptr bst = make_shared<BST<TreeNode*>>();
    //shared_ptr<BST<TreeNode*>> bst (new BST<TreeNode*>());
    bst->insert(5);
    bst->insert(6);
    bst->insert(7);
    bst->insert(4);
    bst->insert(8);
    cout << "RES: " << endl;
    bst->inorder();
    return 0;
}