C++模板实现链表与二叉树

1. 链表

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

// 双向链表节点模板类
template <typename T>
struct ListNode {
    T data;
    ListNode<T>* prev;
    ListNode<T>* next;

    ListNode() : prev(nullptr), next(nullptr) {}
    ListNode(T val) : data(val), prev(nullptr), next(nullptr) {}
    ListNode(T val, ListNode<T>* p_prev, ListNode<T>* p_next)
        : data(val), prev(p_prev), next(p_next) {}
};

// 模板函数：根据数组生成双向链表，返回头节点
template <typename T>
ListNode<T>* buildDoublyLinkedList(const vector<T>& arr) {
    // 边界条件：空数组返回空链表
    if (arr.empty()) {
        return nullptr;
    }

    // 创建头节点
    ListNode<T>* head = new ListNode<T>(arr[0]);
    // 用current指针跟踪当前链表的最后一个节点
    ListNode<T>* current = head;

    // 遍历数组剩余元素，逐个创建节点并链接
    for (size_t i = 1; i < arr.size(); ++i) {
        // 创建新节点，前驱指针指向current，后继指针默认nullptr
        ListNode<T>* newNode = new ListNode<T>(arr[i], current, nullptr);
        // 将当前节点的后继指针指向新节点
        current->next = newNode;
        // 移动current到新节点（链表末尾）
        current = newNode;
    }

    return head;
}

// 辅助模板函数：正向遍历打印双向链表（验证结果）
template <typename T>
void printListForward(ListNode<T>* head) {
    ListNode<T>* current = head;
    while (current != nullptr) {
        cout << current->data << " ";
        current = current->next;
    }
    cout << endl;
}

// 辅助模板函数：反向遍历打印双向链表（验证双向链接）
template <typename T>
void printListBackward(ListNode<T>* head) {
    if (head == nullptr) {
        cout << "空链表" << endl;
        return;
    }
    // 先找到链表的尾节点
    ListNode<T>* tail = head;
    while (tail->next != nullptr) {
        tail = tail->next;
    }
    // 从尾节点反向遍历
    while (tail != nullptr) {
        cout << tail->data << " ";
        tail = tail->prev;
    }
    cout << endl;
}

// 辅助模板函数：释放双向链表的内存（避免内存泄漏）
template <typename T>
void deleteList(ListNode<T>* head) {
    ListNode<T>* current = head;
    while (current != nullptr) {
        ListNode<T>* nextNode = current->next; // 先保存后继节点
        delete current; // 释放当前节点
        current = nextNode; // 移动到后继节点
    }
}

// 测试示例
int main() {
    // 测试1：int类型数组
    vector<int> arrInt = {1, 2, 3, 4, 5};
    ListNode<int>* headInt = buildDoublyLinkedList(arrInt);
    cout << "int类型链表正向遍历：";
    printListForward(headInt); // 输出：1 2 3 4 5
    cout << "int类型链表反向遍历：";
    printListBackward(headInt); // 输出：5 4 3 2 1
    deleteList(headInt); // 释放内存

    // 测试2：string类型数组
    vector<string> arrStr = {"A", "B", "C", "D"};
    ListNode<string>* headStr = buildDoublyLinkedList(arrStr);
    cout << "string类型链表正向遍历：";
    printListForward(headStr); // 输出：A B C D
    cout << "string类型链表反向遍历：";
    printListBackward(headStr); // 输出：D C B A
    deleteList(headStr); // 释放内存

    return 0;
}

2. 二叉树

#include <stdio.h>
#include <vector>
#include <stdlib.h>
#include <iostream> 
#include <deque>
#include <queue>
using namespace std;

template <typename T>
struct TreeNode {
    T val; // 将int改为模板类型T
    TreeNode *left;
    TreeNode *right;
    // 无参构造函数：对于非数值类型，默认构造可能更合理，这里给val默认构造
    TreeNode() : val(T()), left(nullptr), right(nullptr) {}
    // 单参数构造函数：接收T类型的val
    TreeNode(const T& x) : val(x), left(nullptr), right(nullptr) {}
    // 三参数构造函数：接收val、左子节点、右子节点
    TreeNode(const T& x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
};

template <typename T>
TreeNode<T>* buildTreeByLevelOrder(const vector<T*>& levelOrder) {
    if(levelOrder.empty() || levelOrder[0] == nullptr) {
        return nullptr;
    }

    TreeNode<T>* root = new TreeNode<T>(*levelOrder[0]);
    queue<TreeNode<T>*> nodeQueue;
    nodeQueue.push(root);

    int index = 1;
    int n = levelOrder.size();
    while(!nodeQueue.empty() && index < n) {
        TreeNode<T>* current = nodeQueue.front();
        nodeQueue.pop();

        if(index < n && levelOrder[index] != nullptr) {
            current->left = new TreeNode<T>(*levelOrder[index]);
            nodeQueue.push(current->left);
        }
        index++;

        if(index < n && levelOrder[index] != nullptr) {
            current->right = new TreeNode<T>(*levelOrder[index]);
            nodeQueue.push(current->right);
        }

        index++;

    }

    return root;
}

template <typename T>
void levelOrderTraversal(TreeNode<T>* root) {
    if (root == nullptr) {
        cout << "空树" << endl;
        return;
    }

    queue<TreeNode<T>*> q;
    q.push(root);
    while (!q.empty()) {
        TreeNode<T>* node = q.front();
        q.pop();
        cout << node->val << " ";
        if (node->left != nullptr) {
            q.push(node->left);
        }
        if (node->right != nullptr) {
            q.push(node->right);
        }
    }
    cout << endl;
}

int main() {
    int v1 = 3, v2 = 9, v3 = 20, v4 = 15, v5 = 7;
    vector<int*> levelOrderInt = {&v1, &v2, &v3, nullptr, nullptr, &v4, &v5};
    TreeNode<int>* rootInt = buildTreeByLevelOrder(levelOrderInt);
    cout << "int类型树的层序遍历：";
    levelOrderTraversal(rootInt);

    string s1 = "A", s2 = "B", s3 = "C", s4 = "D", s5 = "E";
    vector<string*> levelOrderStr = {&s1, &s2, &s3, nullptr, nullptr, &s4, &s5};
    TreeNode<string>* rootStr = buildTreeByLevelOrder(levelOrderStr);
    cout << "string类型树的层序遍历：";
    levelOrderTraversal(rootStr);

    return 0;
}