链表二叉树debug工具

链表debug

struct ListNode {
    int val;
    ListNode *next;

    ListNode(int x) : val(x), next(nullptr) {}
};
class List {
private:
    ListNode *dummy;
public:
    List(std::vector<int>num){
        dummy=get_head(num);
    }
    ~List(){
        Del(dummy);
    }
private:
    ListNode *get_head(std::vector<int> num) {
        dummy = new ListNode(-1);
        ListNode *store = dummy;
        for (auto x : num) {
            dummy->next = new ListNode(x);
            dummy = dummy->next;
        }
        return store->next;
    }

    void Del(ListNode *head) {
        ListNode *middle = head;
        head = head->next;
        while (head) {
            delete head;
            head = head->next;
        }
        delete middle;
    }
public:
        ListNode* head() const{
        return dummy;
    }
};

二叉树debug工具

//
// Created by sensetime on 2020/11/20.
//

#pragma once

#include <iostream>
#include <queue>
#include <stack>


struct TreeNode {
    int key;
    int val;
    TreeNode *left;
    TreeNode *right;

    TreeNode() = default;

    TreeNode(int k, int v) : key(k), val(v), left(nullptr), right(nullptr) {}

    TreeNode(int k, int v, TreeNode *left, TreeNode *right) : key(k), val(v), left(left), right(right) {}
};


class BinaryTree {
private:
    TreeNode *_root;

public:
    BinaryTree(std::vector<int> vec) {
        if (vec.empty()) {
            _root = nullptr;
        } else if (vec.size() == 1) {
            _root = new TreeNode(1, vec[0]);
        } else {
            _root = get_head(vec);
        }
    }

    ~BinaryTree() {
        destory(_root);
    }

private:
    TreeNode *get_head(std::vector<int> &vec) {
        TreeNode *head = new TreeNode(1, vec[0]);
        TreeNode *story = head;
        std::queue<TreeNode *> q;
        q.push(head);
        int i = 1;
        while (!q.empty()) {
            TreeNode *root = q.front();
            q.pop();
            if ((2 * i + 1) <= vec.size()) {
                TreeNode *left = new TreeNode(2 * i, vec[2 * i - 1]);
                root->left = left;
                q.push(left);
                TreeNode *right = new TreeNode(2 * i + 1, vec[2 * i]);
                root->right = right;
                q.push(right);
            } else if (2 * i == vec.size()) {
                TreeNode *left = new TreeNode(2 * i, vec[2 * i - 1]);
                root->left = left;
                q.push(left);
            }
            i++;
        }
        return story;
    }

    void destory(TreeNode *head) {
        std::stack<TreeNode *> stk;
        stk.emplace(head);
        while (!stk.empty()) {
            TreeNode *root = stk.top();
            stk.pop();
            delete root;
            stk.emplace(root->right);
            stk.emplace(root->left);
        }
    }

public:
    TreeNode *head() {
        return _root;
    }

};