BinaryTree

LinearList/BinaryTree/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.31)
+project(BTree)
+
+set(CMAKE_CXX_STANDARD 20)
+
+add_executable(BTree main.cpp
+        binaryTreeNode.h
+        binaryTree.h
+        linkedBinaryTree.h)

LinearList/BinaryTree/binaryTree.h

@@ -0,0 +1,22 @@
+//
+// Created by PC on 25-8-6.
+//
+
+#ifndef BINARYTREE_H
+#define BINARYTREE_H
+#include "binaryTreeNode.h"
+
+template <class T>
+class binaryTree {
+public:
+    virtual ~binaryTree() = default;
+    virtual bool empty() const = 0;
+    virtual int size() const = 0;
+    virtual void preOrder(void(*) (binaryTreeNode<T>*) ) const = 0;
+    virtual void inOrder(void(*) (binaryTreeNode<T>*) ) const = 0;
+    virtual void postOrder(void(*) (binaryTreeNode<T>*) ) const = 0;
+    virtual void levelOrder(void(*) (binaryTreeNode<T>*) ) const = 0;
+};
+
+
+#endif //BINARYTREE_H

LinearList/BinaryTree/binaryTreeNode.h

@@ -0,0 +1,22 @@
+//
+// Created by PC on 25-8-6.
+//
+
+#ifndef BINARYTREENODE_H
+#define BINARYTREENODE_H
+
+template<class T>
+class binaryTreeNode {
+public:
+    T element;
+    binaryTreeNode<T>* left;
+    binaryTreeNode<T>* right;
+public:
+    binaryTreeNode() {left = right = nullptr;}
+    explicit binaryTreeNode(const T& e)  : element(e), left(nullptr), right(nullptr) {}
+    binaryTreeNode(const T& e, binaryTreeNode<T>* l, binaryTreeNode<T>* r) : element(e), left(l), right(r) {}
+    ~binaryTreeNode() = default;
+
+};
+
+#endif //BINARYTREENODE_H

LinearList/BinaryTree/linkedBinaryTree.h

@@ -0,0 +1,117 @@
+//
+// Created by PC on 25-8-6.
+//
+
+#ifndef LINKEDBINARYTREE_H
+#define LINKEDBINARYTREE_H
+#include <iostream>
+#include <deque>
+#include <queue>
+
+#include "binaryTree.h"
+#include "binaryTreeNode.h"
+template <class T>
+class linkedBinaryTree : public binaryTree<T> {
+private:
+    static std::deque<binaryTreeNode<T> *> nodes;
+    binaryTreeNode<T>* root;
+    int tsize;
+    static void (*visit)(binaryTreeNode<T>* node);//存储visit
+    static void preOrder(binaryTreeNode<T>* node) {
+        if (node == nullptr) return;
+
+        bool isLeaf = (node->left == nullptr && node->right == nullptr);
+        if (!isLeaf) std::cout << "(";
+
+        visit(node);
+        preOrder(node->left);
+        preOrder(node->right);
+
+        if (!isLeaf) std::cout << ")";
+    }
+
+    static void inOrder(binaryTreeNode<T>* node) {
+        if (node == nullptr) return;
+
+        // 对非叶子节点加括号
+        bool isLeaf = (node->left == nullptr && node->right == nullptr);
+        if (!isLeaf) std::cout << "(";
+
+        inOrder(node->left);
+        visit(node);
+        inOrder(node->right);
+
+        if (!isLeaf) std::cout << ")";
+    }
+
+    static void postOrder(binaryTreeNode<T>* node) {
+    if (node == nullptr) return;
+
+    bool isLeaf = (node->left == nullptr && node->right == nullptr);
+    if (!isLeaf) std::cout << "(";
+
+    postOrder(node->left);
+    postOrder(node->right);
+    visit(node);
+
+    if (!isLeaf) std::cout << ")";
+}
+
+    //层序遍历levelOrder，使用deque，这人好聪明！
+    static void levelOrder(binaryTreeNode<T>* node) {
+        std::deque<binaryTreeNode<T>*> tmp;
+        tmp.push_back(node);
+        nodes.push_back(node);
+        //开始
+        while (!tmp.empty()) {
+            binaryTreeNode<T>* current = tmp.front();
+            tmp.pop_front();
+
+            if (current->left != nullptr) {
+                nodes.push_back(current->left);
+                tmp.push_back(current->left);
+            }
+            if (current->right != nullptr) {
+                nodes.push_back(current->right);
+                tmp.push_back(current->right);
+            }
+        }
+        for (binaryTreeNode<T>* x : nodes) {
+            std::cout << x->element;
+        }
+    }
+
+    static void dispose(binaryTreeNode<T>* node) {
+        if (node == nullptr) return;
+        dispose(node->left);
+        dispose(node->right);
+        std::cout << "disposing " << node->element << std::endl;
+        delete node;
+    }
+public:
+    linkedBinaryTree() {root = nullptr;tsize = 0;}
+    explicit linkedBinaryTree(binaryTreeNode<T>* x ) {root = x;tsize = 1;}
+    ~linkedBinaryTree() override {erase();}
+    bool empty() const override {return tsize == 0;}
+    void preOrder(void(*Ivisit) (binaryTreeNode<T>*)) const override {visit = Ivisit; preOrder(root);}
+    //传入的是一个函数，在private里有void (*visit)来储存函数入口，从而在遍历的时候进行操作（输出，计算等）
+    //操作的函数是visit，即访问到该node之后进行什么操作
+    void inOrder(void(*Ivisit) (binaryTreeNode<T>*)) const override{visit = Ivisit; inOrder(root);}
+    void postOrder(void(*Ivisit) (binaryTreeNode<T>*)) const override {visit = Ivisit; postOrder(root);}
+    void levelOrder(void(*Ivisit) (binaryTreeNode<T>*)) const override {visit = Ivisit; levelOrder(root);}
+    int size() const override {return tsize;}
+    void erase() {
+        //postOrder(dispose);
+        dispose(root);
+        root = nullptr;
+        tsize = 0;
+    }
+};
+
+template<typename T>
+void (*linkedBinaryTree<T>::visit)(binaryTreeNode<T>*) = nullptr;
+
+template<typename T>
+std::deque<binaryTreeNode<T> *> linkedBinaryTree<T>::nodes;
+
+#endif //LINKEDBINARYTREE_H

LinearList/BinaryTree/main.cpp

@@ -0,0 +1,55 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include "linkedBinaryTree.h"
+using namespace std;
+vector<string> m;
+void func(binaryTreeNode<string>* node) {
+    cout << node->element;
+}
+
+int main() {
+    /*
+     *          x
+     *      +       -
+     *   a     b c     d
+    */
+    //构建要从下往上构建，注意如果是 new了一个[]，必须delete []而不能直接delete t[i]
+    auto t0 = new binaryTreeNode<string>("a");
+    auto t1 = new binaryTreeNode<string>("b");
+    auto t2  = new binaryTreeNode<string>("c");
+    auto t3  = new binaryTreeNode<string>("d");
+    auto t4  = new binaryTreeNode<string>("+", t0, t1);
+    auto t5  = new binaryTreeNode<string>("-", t2, t3);
+    auto t6  = new binaryTreeNode<string>("x", t4, t5);
+    linkedBinaryTree<string> tree(t6);
+
+    cout << endl;
+    tree.inOrder(func);
+    cout << endl;
+
+    tree.preOrder(func);
+    cout << endl;
+
+    tree.postOrder(func);
+    cout << endl;
+
+    tree.levelOrder(func);
+    cout << endl;
+    return 0;
+}
+
+/*
+Output:
+((a+b)x(c-d))
+(x(+ab)(-cd))
+((ab+)(cd-)x)
+x+-abcd
+disposing a
+disposing b
+disposing +
+disposing c
+disposing d
+disposing -
+disposing x
+ */