[C++]二叉树总结

最新推荐文章于 2024-05-26 18:52:42 发布
最新推荐文章于 2024-05-26 18:52:42 发布
阅读量2.3k 收藏 3
点赞数
分类专栏： C++编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stary_yan/article/details/51347423
版权

[C++]二叉树总结

简单封装二叉树

题目要求

（简单的说，就是把二叉树的功能封装起来）

binary tree is a tree data structure in which each node has at most two children, which are referred to as the left child and the right child.

Three Constructor:

creat a tree by copy.
creat a tree by a array.(using BFS)
creat a tree by preorder and inorder.
Methods:

clear: clear the tree.
copyTree: input old tree root and new tree root, copy get a new tree.
Static Methods:

three way to search tree.

测试文件：

#include <iostream>
#include "BinaryTree.hpp"

using namespace std;

void print(BinaryTree::Node * temp) {
    cout << temp->val << " ";
}

std::vector<char> pre;
std::vector<char> in;

void getPreOrder(BinaryTree::Node * temp) {
    pre.push_back(temp->val);
}

void getInOrder(BinaryTree::Node * temp) {
    in.push_back(temp->val);
}

void testTree() {
    cout << "test Tree" << endl;
    int n = 1;
    std::vector<char> tree;
    cin >> n;
    while (n--) {
        char temp = '\0';
        cin >> temp;
        tree.push_back(temp);
    }

    BinaryTree x = BinaryTree(tree);

    BinaryTree::preOrder(print, x.getRoot());
    cout << endl;
    BinaryTree::inOrder(print, x.getRoot());
    cout << endl;
    BinaryTree::postOrder(print, x.getRoot());
    cout << endl;

    BinaryTree::preOrder(getPreOrder, x.getRoot());
    BinaryTree::inOrder(getInOrder, x.getRoot());

    BinaryTree t = BinaryTree(pre, in);
    BinaryTree::postOrder(print, t.getRoot());
    cout << endl;

    BinaryTree y = BinaryTree(t);

    BinaryTree::preOrder(print, y.getRoot());
    cout << endl;
    BinaryTree::inOrder(print, y.getRoot());
    cout << endl;
    BinaryTree::postOrder(print, y.getRoot());

    BinaryTree::preOrder(getPreOrder, y.getRoot());
    BinaryTree::inOrder(getInOrder, y.getRoot());
}

int main() {
    testTree();
}

接口文件：

//
//  BinaryTree.hpp
//  C++
//
//  Created by 李天培 on 16/5/4.
//  Copyright © 2016年 lee. All rights reserved.
//

#ifndef BinaryTree_hpp
#define BinaryTree_hpp

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

#define EMPTY_ELE '#'

class BinaryTree {
public:
    struct Node {
        char val;
        Node* left;
        Node* right;
        Node(char v, Node* l = NULL, Node* r = NULL):
        val(v), left(l), right(r) {
        }
    };
    BinaryTree(const BinaryTree&);
    BinaryTree(std::vector<char>&);
    // created by preorder and inorder
    BinaryTree(const std::vector<char>& preOrder,
               const std::vector<char>& inOrder);
    ~BinaryTree();

    Node* getRoot() const;
    void clear();

    static void preOrder(void (*visite)(BinaryTree::Node*), Node*);
    static void inOrder(void (*visite)(BinaryTree::Node*), Node*);
    static void postOrder(void (*visite)(BinaryTree::Node*), Node*);


private:
    Node * copyNode(Node * oldNode, Node * newNode);

    Node * root;
};

#endif /* BinaryTree_hpp */

问题分析

先来讨论相对简单的访问二叉树问题。

遍历问题

前(先)序遍历

中序遍历

后序遍历

代码实现：
void BinaryTree::preOrder(void (*visite)(BinaryTree::Node *),
                          BinaryTree::Node * treeNode) {
    if (treeNode != NULL) {
        visite(treeNode);
        preOrder(visite, treeNode->left);
        preOrder(visite, treeNode->right);
    }
}
void BinaryTree::inOrder(void (*visite)(BinaryTree::Node *),
                         BinaryTree::Node * treeNode) {
    if (treeNode != NULL) {
        inOrder(visite, treeNode->left);
        visite(treeNode);
        inOrder(visite, treeNode->right);
    }
}
void BinaryTree::postOrder(void (*visite)(BinaryTree::Node *),
                           BinaryTree::Node * treeNode) {
    if (treeNode != NULL) {
        postOrder(visite, treeNode->left);
        postOrder(visite, treeNode->right);
        visite(treeNode);
    }
}
根据前序后序求中序

已知前序遍历为GDAFEMHZ，中序遍历为ADEFGHMZ，请画出这棵二叉树。

①根据前序遍历特征，我们知道根结点必在首位置，所以为G；

②根据中序遍历特征。其中根节点G左侧的ADEF必然是根节点的左子树，G右侧的HMZ必然是根节点的右子树；

③根据前序中序特征，重复以上步骤。递归找到子树根节点；

那么，我们可以画出这个二叉树：

由图可知，后序遍历顺序为：AEFDHZMG

代码实现
BinaryTree::Node* recursionBuild(const std::vector<char>& preorder,
                                 unsigned long preLeft,
                                 unsigned long preRight,
                                 const std::vector<char>& inorder,
                                 unsigned long inLeft,
                                 unsigned long inRight) {
    if (preLeft > preRight || preRight == preorder.size() ||
        inLeft > inRight || inRight == inorder.size())
        return NULL;

    unsigned long i = 0;

    BinaryTree::Node* node = new BinaryTree::Node(preorder[preLeft]);

    for (i = inLeft; i <= inRight; i++) {
        if (inorder[i] == node->val) {
            break;
        }
    }

    node->left =  recursionBuild(preorder,
                                 preLeft + 1, preLeft + i -inLeft,
                                 inorder,
                                 inLeft, i - 1);
    node->right = recursionBuild(preorder,
                                 preLeft + i - inLeft + 1, preRight,
                                 inorder,
                                 i + 1, inRight);

    return node;
}
BinaryTree::BinaryTree(const std::vector<char> & preorder,
                       const std::vector<char> & inorder) {
    root = NULL;
    unsigned long preSize = preorder.size();
    unsigned long inSize = inorder.size();
    if (preSize == 0 || preSize != inSize) {
        return;
    }

    root = recursionBuild(preorder, 0, preSize - 1,
                          inorder, 0, inSize - 1);
}
根据后序中序求前序

已知一棵二叉树的中序序列和后序序列分别是BDCEAFHG 和 DECBHGFA，请画出这棵二叉树。
分析：

  • ①由后序遍历特征，根结点必在后序序列尾部（即A）；
  • ②由中序遍历特征，根结点必在其中间，而且其左部必全部是左子树的子孙（即BDCE），其右部必全部是右子树的子孙（即FHG）；
  • ③递归找出子树根节点。

那么，我们可以画出这个二叉树：

注意事项：

左子树中序为BDCE，后序为DECB，说明B为A的左子树根节点，C为B的右子树（从BDCE看出）根节点（从DCE及DEC看出）；

右子树中序为FHG，后序为HGF，说明F为A的右子树的根节点，H为G的左子树根节点。

构造过程

接下来讨论在构造过程中出现的难点。

用队列让vector构造二叉树

用队列可以实现FIFO，从而让每一个节点都依次赋值。但必须注意在queue中要存储_Node**，就是存储一个指向指针的指针。（因为在其内部应该实现了深复制。所以如果只用_Node*会就会复制指针所指向的对象（都为NULL）,这与我们的算法就想违背了。）

BinaryTree::BinaryTree(std::vector<char>& orig) {
    std::queue<_Node**> queue_Node;
    if (!orig.empty() && orig[0] != EMPTY_ELE) {
        root = new _Node(orig[0]);
        queue_Node.push(&root->left);
        queue_Node.push(&root->right);
        int i = 1;
        while (!queue_Node.empty()) {
            _Node** temp = queue_Node.front();
            queue_Node.pop();
            if (i >= orig.size()) {
                temp = NULL;
                i++;
            } else if (orig[i] == EMPTY_ELE) {
                temp = NULL;
                i++;
            } else {
                *temp = new _Node(orig[i++]);
                queue_Node.push(&((*temp)->left));
                queue_Node.push(&((*temp)->right));
            }
        }
    } else {
        root = NULL;
    }
}

第二种方法：（更细致的实现方法。）

BinaryTree::BinaryTree(std::vector<char> & elements) {
    unsigned long size = elements.size();
    int index = 0;
    std::queue<Node*> queue;
    if (elements.empty() || elements[index] == EMPTY_ELE) {
        root = NULL;
    } else {
        root = new Node(elements[index]);
        queue.push(root);
        index += 1;
        while (index < size) {
            Node* temp = queue.front();
            queue.pop();
            if (elements[index] != EMPTY_ELE) {
                temp->left = new Node(elements[index]);
                queue.push(temp->left);
            }
            index += 1;
            if (index >= size) {
                break;
            }
            if (elements[index] != EMPTY_ELE) {
                temp->right = new Node(elements[index]);
                queue.push(temp->right);
            }
            index += 1;
        }
    }
}
copy构造函数（递归实现）
BinaryTree::Node* BinaryTree::copyNode(BinaryTree::Node *oldNode,
                                       BinaryTree::Node *newNode) {
    if (oldNode == NULL) {
        newNode = NULL;
        return newNode;
    }

    newNode = new Node(oldNode->val);
    newNode->left = copyNode(oldNode->left, newNode->left);
    newNode->right = copyNode(oldNode->right, oldNode->right);
    return newNode;
}
BinaryTree::BinaryTree(const BinaryTree &old) {
    root = NULL;
    root = copyNode(old.getRoot(), root);
}

问题解决

#include "BinaryTree.hpp"
BinaryTree::Node* recursionBuild(const std::vector<char>& preorder,
                                 unsigned long preLeft,
                                 unsigned long preRight,
                                 const std::vector<char>& inorder,
                                 unsigned long inLeft,
                                 unsigned long inRight) {
    if (preLeft > preRight || preRight == preorder.size() ||
        inLeft > inRight || inRight == inorder.size())
        return NULL;

    unsigned long i = 0;

    BinaryTree::Node* node = new BinaryTree::Node(preorder[preLeft]);

    for (i = inLeft; i <= inRight; i++) {
        if (inorder[i] == node->val) {
            break;
        }
    }

    node->left =  recursionBuild(preorder,
                                 preLeft + 1, preLeft + i -inLeft,
                                 inorder,
                                 inLeft, i - 1);
    node->right = recursionBuild(preorder,
                                 preLeft + i - inLeft + 1, preRight,
                                 inorder,
                                 i + 1, inRight);

    return node;
}


BinaryTree::BinaryTree(const BinaryTree &old) {
    root = NULL;
    root = copyNode(old.getRoot(), root);
}

BinaryTree::BinaryTree(const std::vector<char> & preorder,
                       const std::vector<char> & inorder) {
    root = NULL;
    unsigned long preSize = preorder.size();
    unsigned long inSize = inorder.size();
    if (preSize == 0 || preSize != inSize) {
        return;
    }

    root = recursionBuild(preorder, 0, preSize - 1,
                          inorder, 0, inSize - 1);
}
BinaryTree::BinaryTree(std::vector<char> & elements) {
    unsigned long size = elements.size();
    int index = 0;
    std::queue<Node*> queue;
    if (elements.empty() || elements[index] == EMPTY_ELE) {
        root = NULL;
    } else {
        root = new Node(elements[index]);
        queue.push(root);
        index += 1;
        while (index < size) {
            Node* temp = queue.front();
            queue.pop();
            if (elements[index] != EMPTY_ELE) {
                temp->left = new Node(elements[index]);
                queue.push(temp->left);
            }
            index += 1;
            if (index >= size) {
                break;
            }
            if (elements[index] != EMPTY_ELE) {
                temp->right = new Node(elements[index]);
                queue.push(temp->right);
            }
            index += 1;
        }
    }
}

BinaryTree::Node* BinaryTree::copyNode(BinaryTree::Node *oldNode,
                                       BinaryTree::Node *newNode) {
    if (oldNode == NULL) {
        newNode = NULL;
        return newNode;
    }

    newNode = new Node(oldNode->val);
    newNode->left = copyNode(oldNode->left, newNode->left);
    newNode->right = copyNode(oldNode->right, oldNode->right);
    return newNode;
}


BinaryTree::Node* BinaryTree::getRoot() const {
    return root;
}

BinaryTree::~BinaryTree() {
    clear();
}
void BinaryTree::clear() {
    std::queue<Node*> queue;
    if (root != NULL) {
        queue.push(root);
    }
    while (!queue.empty()) {
        Node * temp = queue.front();
        queue.pop();
        if (temp->left != NULL)
            queue.push(temp->left);
        if (temp->right != NULL)
            queue.push(temp->right);
        delete temp;
    }
}

void BinaryTree::preOrder(void (*visite)(BinaryTree::Node*), Node* r = NULL) {
    Node *temp = r;
    if (temp == NULL) {
        return;
    } else {
        visite(temp);
        preOrder(visite, temp->left);
        preOrder(visite, temp->right);
    }
}

void BinaryTree::inOrder(void (*visite)(BinaryTree::Node*), Node* r = NULL) {
    Node *temp = r;
    if (temp == NULL) {
        return;
    } else {
        inOrder(visite, temp->left);
        visite(temp);
        inOrder(visite, temp->right);
    }
}

void BinaryTree::postOrder(void (*visite)(BinaryTree::Node*), Node* r = NULL) {
    Node *temp = r;
    if (temp == NULL) {
        return;
    } else {
        postOrder(visite, temp->left);
        postOrder(visite, temp->right);
        visite(temp);
    }
}

搜索二叉树

关于搜索二叉树的具体知识点分析见：

搜索二叉树

#ifndef BinarySearchTree_hpp
#define BinarySearchTree_hpp

#include <queue>
#include <vector>

class BinarySearchTree {
 public:
  struct Node {
    int val;
    Node* left;
    Node* right;
    Node(int v, Node* l = NULL, Node* r = NULL) : val(v), left(l), right(r) {}
  };

  BinarySearchTree();
  BinarySearchTree(const std::vector<int>&);
  ~BinarySearchTree();

  bool insertNode(int);
  bool searchNode(int);
  bool deleteNode(int);
  void clear();

  Node* getRoot() const;

 private:
  Node* root;
};

#endif /* BinarySearchTree_hpp */
#include "BinarySearchTree.hpp"
BinarySearchTree::BinarySearchTree() { root = NULL; }
void delete_node(BinarySearchTree::Node* root) {
  if (root != NULL) {
    delete_node(root->left);
    delete_node(root->right);
    delete root;
  }
}
BinarySearchTree::~BinarySearchTree() { clear(); }
void BinarySearchTree::clear() { delete_node(root); }
BinarySearchTree::BinarySearchTree(const std::vector<int>& orig) {
  root = new Node(orig[0]);
  for (int i = 1; i < orig.size(); i++) {
    insertNode(orig[i]);
  }
}
void insert(BinarySearchTree::Node** root, int value) {
  if (*root == NULL) {
    *root = new BinarySearchTree::Node(value);
    return;
  }
  if (value < (*root)->val) {
    insert(&(*root)->left, value);
  }
  if (value > (*root)->val) {
    insert(&(*root)->right, value);
  }
}

bool BinarySearchTree::insertNode(int value) {
  if (searchNode(value)) {
    return false;
  }
  insert(&root, value);
  return true;
}
bool BinarySearchTree::searchNode(int value) {
  Node* temp = root;
  while (temp != NULL) {
    if (temp->val == value) {
      return true;
    } else if (temp->val > value) {
      temp = temp->left;
    } else if (temp->val < value) {
      temp = temp->right;
    }
  }
  return false;
}
BinarySearchTree::Node* BinarySearchTree::getRoot() const { return root; }
/**
 *  find the max value in the left tree
 *
 *  @param t Node (which will be deleted later)
 *
 *  @return Max Node
 */
BinarySearchTree::Node* findMax(BinarySearchTree::Node* t) {
  if (t == NULL) {
    return NULL;
  } else {
    while (t->right != NULL) t = t->right;
    return t;
  }
}
BinarySearchTree::Node* findMin(BinarySearchTree::Node* t) {
  if (t == NULL) {
    return NULL;
  } else {
    while (t->left != NULL) {
      t = t->left;
    }
    return t;
  }
}
//  there is two kinds of way to delete Node
void remove_Left(const int& x, BinarySearchTree::Node*& t) {
  if (t == NULL) return;
  if (x < t->val)
    remove_Left(x, t->left);
  else if (x > t->val)
    remove_Left(x, t->right);
  else if (t->left != NULL && t->right != NULL) {
    t->val = findMax(t->left)->val;
    remove_Left(t->val, t->left);
  } else {
    BinarySearchTree::Node* oldNode = t;
    t = (t->right != NULL) ? t->right : t->left;
    delete oldNode;
  }
}
void remove_Right(const int& x, BinarySearchTree::Node*& t) {
  if (t == NULL) return;
  if (x < t->val)
    remove_Right(x, t->left);
  else if (x > t->val)
    remove_Right(x, t->right);
  else if (t->left != NULL && t->right != NULL) {
    t->val = findMin(t->right)->val;
    remove_Right(t->val, t->right);
  } else {
    BinarySearchTree::Node* oldNode = t;
    t = (t->left != NULL) ? t->left : t->right;
    delete oldNode;
  }
}
bool BinarySearchTree::deleteNode(int value) {
  if (searchNode(value)) {
    remove_Left(value, root);
    return true;
  }
  return false;
}

测试文件

#include <iostream>
#include <vector>
#include "BinarySearchTree.hpp"

using std::cout;
using std::cin;
using std::endl;

void preorder(BinarySearchTree::Node* node) {
  if (node == NULL) {
    return;
  } else {
    cout << node->val << " ";
    preorder(node->left);
    preorder(node->right);
  }
}

void inorder(BinarySearchTree::Node* node) {
  if (node == NULL) {
    return;
  } else {
    inorder(node->left);
    cout << node->val << " ";
    inorder(node->right);
  }
}

void displayTree(const BinarySearchTree& tree) {
  cout << "pre: ";
  preorder(tree.getRoot());
  cout << endl;

  cout << "in: ";
  inorder(tree.getRoot());
  cout << endl;
}

void testMinimalSpanningTrees() {
  cout << "testMinimalSpanningTrees" << endl;

  std::vector<int> elements;

  int n = 0;
  cin >> n;
  while (n--) {
    int temp = 0;
    cin >> temp;
    elements.push_back(temp);
  }

  BinarySearchTree tree(elements);
  displayTree(tree);

  cin >> n;
  cout << "insert : " << n << " -> " << tree.insertNode(n) << endl;
  displayTree(tree);

  cout << "search : " << n << " -> " << tree.searchNode(n) << endl;
  cout << "delete : " << n << " -> " << tree.deleteNode(n) << endl;

  cin >> n;
  cout << "delete : " << n << " -> " << tree.deleteNode(n) << endl;
  displayTree(tree);

  cin >> n;
  cout << "search : " << n << " -> " << tree.searchNode(n) << endl;

  cout << "insert : " << elements[0] << " -> " << tree.insertNode(elements[0])
       << endl;
  displayTree(tree);
}

int main() { testMinimalSpanningTrees(); }
stary_yan
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树总结
zhangchengcheng1997的博客
04-21 201
关于二叉树问题，由于其本身固有的递归属性，通常我们可以用递归算法来解决。遍历是二叉树各种操作的基础，可以在遍历过程中对结点进行各种操作。 一、二叉树的遍历   由二叉树的定义可知，一颗二叉树由根节点及左、右子树三个基本部分组成，因此，只要依次遍历这三部分，就可以遍历整个二叉树。 　　1.先序遍历： 　　先序遍历的递归过程为：若二叉树为空，遍历结束。否则， 　　(1)访
已知一棵二叉树的中序序列和后序序列分别是BDCEAFHG 和 DECBHGFA，请画出这棵二叉树。
热门推荐
qq_50574424的博客
12-19 1万+
c++的二叉树
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
【C++】树(Tree)
2301_80418172的博客
05-26 834
树
C++实现树 - 01 树的三种表示法
Newin2020的博客
05-01 3324
写在前面： 今天我们开始进入树的学习啦，在学习高级搜索树之前，我们先看看一些简单树的实现，先理解好概念，入门就很快了。 树的定义 之前我们学习的是线性表，也就是线性的存储结构。今天我们开始学习非线性的存储结构，树就是非线性的存储结构，它可以拥有一对多的元素。 ......
【数据结构/C++】 树详解
mhyasadj的博客
02-04 4079
树（Tree）是n（n≥0）个结点的有限集。n=0时称为空树。在任意一颗非空树中：①有且仅有一个特定的称为根（Root）的结点；
非常适合小白理解的C++二叉树代码
05-20
### 非常适合小白理解的C++二叉树代码详解 #### 一、引言 在计算机科学中，二叉树是一种常见的数据结构，它广泛应用于算法设计、数据库索引构建等领域。对于初学者来说，理解二叉树的基本概念及其在C++中的实现非常...
C++ 二叉树的镜像实例详解
08-30
"C++ 二叉树的镜像实例详解" 本文主要介绍了 C++ 二叉树的镜像实例详解的相关知识点，包括二叉树镜像的定义、递归实现和非递归实现。 一、 二叉树镜像的定义 二叉树镜像是将一个二叉树的左右子树调换位置，从根...
[C++]二叉树的建立和遍历
06-08
总结来说，理解和应用二叉树是提升编程能力的关键步骤，尤其是对数据结构和算法的理解。熟练掌握二叉树的构建、遍历和操作，能够为解决复杂问题打下坚实的基础，这对任何IT专业人员的事业都至关重要。
C++ 二叉树
11-26
总结来说，这个"C++ 二叉树"项目提供了一个在MFC框架下操作二叉搜索树的实例，涵盖了基本的数据结构和算法知识，对于理解和实践C++中的数据结构具有很好的学习价值。通过这个程序，开发者可以更深入地理解二叉树的...
讲解非常详细的C++二叉树的创建与遍历
05-27
### C++中二叉树的创建与遍历详解 #### 一、引言 二叉树是计算机科学中一种重要的数据结构，在很多算法问题中都有着广泛的应用，例如搜索、排序等。本文将深入探讨如何在C++中创建二叉树，并实现四种基本的遍历方式...
【数据结构】第5章 树和二叉树 二叉树
wwr's study notes
08-18 315
【二叉树的啦啦啦啦】
C++ Tree
a130737的专栏
07-18 3782
树是一种十分重要， 应用
数据结构之二叉树（c++）
qq_57541265的博客
03-19 9273
本文章主要介绍二叉树的概念，二叉树的存储结构，二叉树的插入，删除，查找，遍历，等操作
C++之---树/数据结构
qq_41920323的博客
06-03 1235
C++的树结构
数据结构浅浅析之（三）——树（Tree）（上篇——基础知识 附C++代码）
尘海折柳的博客
01-18 620
目录 一.引言 二.基础知识  树（tree）的定义 在任意一棵非空树中存在以下特性： 注意几点： 结点的分类 结点间的关系 其他相关概念 线性结构和树结构的比较 三.最简单的树——二叉树（Binary Tree） 满二叉树 完全二叉树 二叉树的遍历          1.前序遍          2.中序遍历 3.后序遍历 4.层次遍历 一.引言      ...
1111111111111111111111
最新发布
08-13
1111111111111111
C++二叉树基础与应用详解
总结来说，这份PPT涵盖了二叉树的基础概念，如定义、术语、度和层次，以及关键的应用场景，例如二叉树的遍历方法和Huffman树的构建。对于C++程序员来说，理解和掌握这些内容有助于他们在算法设计和数据结构处理中更...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值