Homework New

Exercise/Homework4/ab间路径.cpp

@@ -0,0 +1,198 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <sstream>
+using namespace std;
+vector<vector<int>> result; 
+vector<int> leftt, rightt;
+
+template <class T>
+struct Node {
+    T element;
+    Node<T>* left;
+    Node<T>* right;
+    Node<T>* parent;
+    
+    Node(const T& e, Node<T>* p) : element(e), parent(p), left(nullptr), right(nullptr) {}
+};
+
+template <class T>
+class BinTree {
+public:
+    Node<T>* root;
+    int height;
+    vector<T> arr;
+        
+    BinTree() : root(nullptr), height(0) {}
+    BinTree(const vector<T>& arrs) : arr(arrs), height(0) {}
+    void test() {
+        for (auto x : arr) {
+            cout << x << " ";
+        }
+    }
+    Node<T>* returnroot() {
+        return this->root;
+    }
+        
+    Node<T>* build(int& index, Node<T>* parent) {
+        if (index >= arr.size() || arr[index] == 0) {
+            index++;
+            return nullptr;
+        }
+        
+        Node<T>* node = new Node<T>(arr[index], parent);
+        index++;
+        node->left = build(index, node);
+        node->right = build(index, node);
+        
+        return node;
+    }
+        
+    void buildTree() {
+        int index = 0;
+        this->root = build(index, nullptr);
+    }
+        
+    //输出
+    void preorder(Node<T>* node) {
+        if (node == nullptr) return;
+        
+        cout << node->element << " ";
+        preorder(node->left);
+        preorder(node->right);
+    }
+    void inorder(Node<T>* node) {
+        if (node == nullptr) return;
+
+        inorder(node->left);
+        cout << node->element << " ";
+        //cout << ( node->parent == nullptr ? 0 : node->parent->element) << endl;
+        inorder(node->right);
+    }
+    void postorder(Node<T>* node) {
+        if (node == nullptr) return;
+        
+        postorder(node->left);
+        postorder(node->right);
+        cout << node->element << " ";
+    }
+    Node<T>* inorder2(Node<T>* node, const T& x) {
+        if (node == nullptr) return nullptr;
+        
+        if (node->element == x) {
+            return node;
+        }
+        
+        Node<T>* leftResult = inorder2(node->left, x);
+        if (leftResult != nullptr) {
+            return leftResult;
+        }
+        
+        Node<T>* rightResult = inorder2(node->right, x);
+        return rightResult;
+    }
+    void findparent(const T& e) {
+        auto x = inorder2(this->root, e);
+        if (x == nullptr || x->parent == nullptr) cout << 0 << endl;
+        else         cout << x->parent->element << endl;
+    }
+    void deletesub(Node<T>* node) {
+        if (node == nullptr) return;
+        deletesub(node->left);
+        deletesub(node->right);
+        delete node;
+    }
+
+    bool deletenode(const T& e) {
+        auto x = inorder2(this->root, e);
+        if (x == nullptr) return false;
+        
+        if (x == this->root) {
+            deletesub(x);
+            this->root = nullptr;
+            return true;
+        }
+        
+        if (x->parent->left == x) {
+            x->parent->left = nullptr;
+        } else {
+            x->parent->right = nullptr;
+        }
+        deletesub(x);
+        return true;
+    }
+    
+    void searchpath(T a, T b) {
+        Node<T>* na = inorder2(root, a);
+        Node<T>* nb = inorder2(root, b);
+        if (!na || !nb) { cout << 0 << endl << endl; return; }
+        
+        vector<Node<T>*> patha;
+        Node<T>* cur = na;
+        while (cur) {
+            patha.push_back(cur);
+            cur = cur->parent;
+        }
+        reverse(patha.begin(), patha.end());
+        
+        vector<Node<T>*> pathb;
+        cur = nb;
+        while (cur) {
+            pathb.push_back(cur);
+            cur = cur->parent;
+        }
+        reverse(pathb.begin(), pathb.end());
+
+        int lena = patha.size(), lenb = pathb.size();
+        int minlen = min(lena, lenb);
+        
+        int idx = 0;
+        for (int i = 0; i < minlen; ++i) {
+            if (patha[i] == pathb[i]) idx = i;
+            else break;
+        }
+        
+        vector<T> allpath;
+        for (int j = lena - 1; j > idx; j--) {
+            allpath.push_back(patha[j]->element);
+        }
+        allpath.push_back(patha[idx]->element);
+        for (int j = idx + 1; j < lenb; j++) {
+            allpath.push_back(pathb[j]->element);
+        }
+        
+        int length = allpath.size() - 1;
+        cout << length << endl;
+        
+        for (int i = 0; i < allpath.size(); ++i) {
+            cout << allpath[i] << " ";
+        }
+        cout << endl;
+    }
+};
+
+int main() {
+    int x = 0;
+    vector<int> arr;
+    string line;
+    getline(cin, line);
+    stringstream ss(line);
+    int num;
+
+    while (ss >> num) {
+        arr.push_back(num);
+    }
+    BinTree<int> tree(arr);
+    tree.buildTree();
+
+    int m;
+    cin >> m;
+    for(int i = 0; i < m; i++){
+        int a, b;
+        cin >> a >> b;
+        tree.searchpath(a, b);
+    }
+    
+    
+    return 0;
+}