devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构与算法学习笔记七--二叉树(C++)

作者：我家小花儿 | 2024-04-26 05:05:03

赞

踩

数据结构与算法学习笔记七--二叉树(C++)

目录

前言

1.树的定义和基本术语

2.二叉树

1.二叉树的定义

2.二叉树的性质

3.二叉树的存储结构

1.二叉树链表存储表示

2.二叉树链表常用操作

1.定义

2.先序遍历二叉树

3.中序遍历二叉树

4.后序遍历二叉树

5.判断二叉树是否为空

6.创建二叉树

7.求二叉树深度

8.返回二叉树根节点

9.求二叉树的节点个数

10.完整代码

3.遍历二叉树和线索二叉树

1.遍历二叉树

1.先序遍历二叉树

2.中序遍历二叉树

3.后序遍历二叉树

2.线索二叉树

1.定义

2.中序线索化函数

3.中序遍历线索二叉树

4.创建线索二叉树

5.完整代码

前言

   这篇文章介绍数据结构中的树和二叉树。

1.树的定义和基本术语

        在计算机科学中，树（Tree）是一种抽象数据类型，用于模拟具有树状结构特征的数据集合。树是由一组节点（Nodes）和连接这些节点的边（Edges）组成的，其中一个节点被指定为根节点（Root），其余节点分层组织成子树（Subtrees）。树的每个节点除了根节点外，都恰好连接到一条来自另一个节点的边，这个节点被称为其父节点（Parent Node）。每个节点可以连接到零个或多个子节点，子节点的节点被称为父节点的孩子节点（Child Node）。        

        树的定义如下：

  1. 根节点（Root）：树中的唯一顶层节点，没有父节点。
  2. 边（Edge）：连接两个节点的线段，表示节点之间的关联关系。
  3. 节点(Node):树中的基本元素，每个节点可以包含一个或多个数据项，以及指向其子节点的指针。
  4. 父节点（Parent Node）：拥有一个或多个子节点的节点。
  5. 孩子节点（Child Node）： 一个节点的直接后继节点。
  6. 叶子节点（Leaf Node）：没有子节点的节点称为叶子节点，又称为终端节点。
  7. 深度（Depth）:从根节点到该节点的唯一路径上的边的数量。
  8. 高度（Height）：从一个节点到其深度最大的叶子节点的路径上的边的数量。
  9. 子树（Subtree）： 树中的任意一个节点以及它的后代节点构成的子集，形成一个新的树。

        树的定义为我们提供了一种非常有用的数据结构，可用于表示层次化数据，例如文件系统、组织结构、家谱等等。树也是许多重要算法和数据结构的基础，例如二叉搜索树、堆、图等。

2.二叉树

1.二叉树的定义

        二叉树是一种树型结构，它的特点是每个节点至多只有两颗子树，并且二叉树的子树有左右之分，其次序不能任意颠倒。

2.二叉树的性质

1.在二叉树的第i层上，最多可以有2^(i-1)个节点

2.深度为k的二叉树至多有2^k-1个节点

3.对任何一二叉树T,如果其终端节点数为n0,度为2的节点数为n2,则n0 = n2+1

3.二叉树的存储结构

1.二叉树链表存储表示

        二叉树一般使用二叉链表表示。

2.二叉树链表常用操作

1.定义

        我们使用data表示二叉树数据域，leftChild和rightChild表示二叉树的左右节点。

        因此二叉树定义如下：

  1. // 二叉树节点的数据类型
  2. typedef char TElementType;
  3.  
  4. // 二叉树结点的定义
  5. typedef struct BiTNode {
  6.     TElementType data;
  7.     struct BiTNode * leftChild, * rightChild;
  8. } BiTNode, * BiTree;
2.先序遍历二叉树
  1. // 先序遍历二叉树
  2. void preOrderTraverse(BiTree tree) {
  3.     if (tree != nullptr) {
  4.         cout << tree->data << " "; // 访问根节点
  5.         preOrderTraverse(tree->leftChild); // 先序遍历左子树
  6.         preOrderTraverse(tree->rightChild); // 先序遍历右子树
  7.     }
  8. }
3.中序遍历二叉树
  1. // 中序遍历二叉树
  2. void inOrderTraverse(BiTree tree) {
  3.     if (tree != nullptr) {
  4.         inOrderTraverse(tree->leftChild); // 中序遍历左子树
  5.         cout << tree->data << " "; // 访问根节点
  6.         inOrderTraverse(tree->rightChild); // 中序遍历右子树
  7.     }
  8. }
4.后序遍历二叉树
  1. // 后序遍历二叉树
  2. void postOrderTraverse(BiTree tree) {
  3.     if (tree != nullptr) {
  4.         postOrderTraverse(tree->leftChild); // 后序遍历左子树
  5.         postOrderTraverse(tree->rightChild); // 后序遍历右子树
  6.         cout << tree->data << " "; // 访问根节点
  7.     }
  8. }
5.判断二叉树是否为空
  1. // 判断二叉树是否为空
  2. bool biTreeEmpty(BiTree tree) {
  3.     return tree == nullptr;
  4. }
6.创建二叉树
  1. // 创建二叉树T
  2. void createBiTree(BiTree &tree) {
  3.     TElementType data;
  4.     cin >> data;
  5.     if (data == '#') { // '#'表示空节点
  6.         tree = nullptr;
  7.     } else {
  8.         tree = new BiTNode{data, nullptr, nullptr};
  9.         createBiTree(tree->leftChild); // 创建左子树
  10.         createBiTree(tree->rightChild); // 创建右子树
  11.     }
  12. }
7.求二叉树深度
  1. // 返回二叉树的深度
  2. int biTreeDepth(BiTree tree) {
  3.     if (tree == nullptr) {
  4.         return 0;
  5.     } else {
  6.         int leftDepth = biTreeDepth(tree->leftChild); // 左子树的深度
  7.         int rightDepth = biTreeDepth(tree->rightChild); // 右子树的深度
  8.         return max(leftDepth, rightDepth) + 1; // 返回左右子树深度的最大值加1
  9.     }
  10. }
8.返回二叉树根节点
  1. // 返回二叉树的根节点
  2. BiTNode* Root(BiTree tree) {
  3.     return tree;
  4. }
9.求二叉树的节点个数
  1. // 返回二叉树的节点个数
  2. int biTreeSize(BiTree tree) {
  3.     if (tree == nullptr) {
  4.         return 0;
  5.     } else {
  6.         return biTreeSize(tree->leftChild) + biTreeSize(tree->rightChild) + 1;
  7.     }
  8. }
10.完整代码
  1. #include <iostream>
  2. #include <queue>
  3. using namespace std;
  4.  
  5. typedef char TElementType;
  6.  
  7. // 二叉树节点的定义
  8. typedef struct BiTNode {
  9.     TElementType data;
  10.     struct BiTNode * leftChild, * rightChild;
  11. } BiTNode, * BiTree;
  12.  
  13. // 先序遍历二叉树
  14. void preOrderTraverse(BiTree tree) {
  15.     if (tree != nullptr) {
  16.         cout << tree->data << " "; // 访问根节点
  17.         preOrderTraverse(tree->leftChild); // 先序遍历左子树
  18.         preOrderTraverse(tree->rightChild); // 先序遍历右子树
  19.     }
  20. }
  21.  
  22. // 中序遍历二叉树
  23. void inOrderTraverse(BiTree tree) {
  24.     if (tree != nullptr) {
  25.         inOrderTraverse(tree->leftChild); // 中序遍历左子树
  26.         cout << tree->data << " "; // 访问根节点
  27.         inOrderTraverse(tree->rightChild); // 中序遍历右子树
  28.     }
  29. }
  30.  
  31. // 后序遍历二叉树
  32. void postOrderTraverse(BiTree tree) {
  33.     if (tree != nullptr) {
  34.         postOrderTraverse(tree->leftChild); // 后序遍历左子树
  35.         postOrderTraverse(tree->rightChild); // 后序遍历右子树
  36.         cout << tree->data << " "; // 访问根节点
  37.     }
  38. }
  39.  
  40. // 判断二叉树是否为空
  41. bool biTreeEmpty(BiTree tree) {
  42.     return tree == nullptr;
  43. }
  44.  
  45. // 创建二叉树T
  46. void createBiTree(BiTree &tree) {
  47.     TElementType data;
  48.     cin >> data;
  49.     if (data == '#') { // '#'表示空节点
  50.         tree = nullptr;
  51.     } else {
  52.         tree = new BiTNode{data, nullptr, nullptr};
  53.         createBiTree(tree->leftChild); // 创建左子树
  54.         createBiTree(tree->rightChild); // 创建右子树
  55.     }
  56. }
  57.  
  58. // 返回二叉树的深度
  59. int biTreeDepth(BiTree tree) {
  60.     if (tree == nullptr) {
  61.         return 0;
  62.     } else {
  63.         int leftDepth = biTreeDepth(tree->leftChild); // 左子树的深度
  64.         int rightDepth = biTreeDepth(tree->rightChild); // 右子树的深度
  65.         return max(leftDepth, rightDepth) + 1; // 返回左右子树深度的最大值加1
  66.     }
  67. }
  68.  
  69. // 返回二叉树的根节点
  70. BiTNode* Root(BiTree tree) {
  71.     return tree;
  72. }
  73.  
  74. // 返回二叉树的节点个数
  75. int biTreeSize(BiTree tree) {
  76.     if (tree == nullptr) {
  77.         return 0;
  78.     } else {
  79.         return biTreeSize(tree->leftChild) + biTreeSize(tree->rightChild) + 1;
  80.     }
  81. }
  82.  
  83. // 查找以某个节点为根的子树中的最小节点
  84. BiTree findMin(BiTree tree) {
  85.     while (tree->leftChild != nullptr) {
  86.         tree = tree->leftChild;
  87.     }
  88.     return tree;
  89. }
  90.  
  91. // 删除某个节点
  92. BiTree deleteNode(BiTree tree, TElementType key) {
  93.     if (tree == nullptr) {
  94.         return nullptr;
  95.     }
  96.  
  97.     if (key < tree->data) { // 要删除的节点在左子树中
  98.         tree->leftChild = deleteNode(tree->leftChild, key);
  99.     } else if (key > tree->data) { // 要删除的节点在右子树中
  100.         tree->rightChild = deleteNode(tree->rightChild, key);
  101.     } else { // 找到要删除的节点
  102.         // 如果节点是叶子节点或者只有一个子节点
  103.         if (tree->leftChild == nullptr) {
  104.             BiTree temp = tree->rightChild;
  105.             delete tree;
  106.             return temp;
  107.         } else if (tree->rightChild == nullptr) {
  108.             BiTree temp = tree->leftChild;
  109.             delete tree;
  110.             return temp;
  111.         }
  112.  
  113.         // 如果节点有两个子节点，用右子树的最小节点替换当前节点
  114.         BiTree temp = findMin(tree->rightChild);
  115.         tree->data = temp->data;
  116.         tree->rightChild = deleteNode(tree->rightChild, temp->data);
  117.     }
  118.  
  119.     return tree;
  120. }
  121.  
  122. // 查找二叉树中的节点
  123. void value(BiTree tree, TElementType & element) {
  124.     if (tree != nullptr && tree->data == element) {
  125.         element = tree->data;
  126.     }
  127. }
  128.  
  129. // 给节点赋值
  130. void assign(BiTree tree, TElementType & element, TElementType value) {
  131.     if (tree != nullptr && tree->data == element) {
  132.         tree->data = value;
  133.     }
  134. }
  135.  
  136. // 返回非根节点
  137. void parent(BiTree tree, TElementType & element) {
  138.     if (tree == nullptr) {
  139.         return;
  140.     }
  141.     queue<BiTree> q;
  142.     q.push(tree);
  143.     while (!q.empty()) {
  144.         BiTree front = q.front();
  145.         q.pop();
  146.         if (front->leftChild != nullptr && front->leftChild->data == element) {
  147.             element = front->data;
  148.             return;
  149.         }
  150.         if (front->rightChild != nullptr && front->rightChild->data == element) {
  151.             element = front->data;
  152.             return;
  153.         }
  154.         if (front->leftChild != nullptr) {
  155.             q.push(front->leftChild);
  156.         }
  157.         if (front->rightChild != nullptr) {
  158.             q.push(front->rightChild);
  159.         }
  160.     }
  161. }
  162.  
  163. // 返回左节点
  164. void leftChild(BiTree tree, TElementType & leftElement) {
  165.     if (tree != nullptr && tree->leftChild != nullptr) {
  166.         leftElement = tree->leftChild->data;
  167.     }
  168. }
  169.  
  170. // 返回右节点节点
  171. void rightChild(BiTree tree, TElementType & rightElement) {
  172.     if (tree != nullptr && tree->rightChild != nullptr) {
  173.         rightElement = tree->rightChild->data;
  174.     }
  175. }
  176.  
  177. // 返回做左兄弟节点
  178. void leftSibling(BiTree tree, TElementType & leftSiblingElement) {
  179.     parent(tree, tree->data);
  180.     if (tree->leftChild != nullptr) {
  181.         leftChild(tree->leftChild, leftSiblingElement);
  182.     }
  183. }
  184.  
  185. // 返回做右兄弟节点
  186. void rightSibling(BiTree tree, TElementType & rightSiblingElement) {
  187.     parent(tree, tree->data);
  188.     if (tree->rightChild != nullptr) {
  189.         rightChild(tree->rightChild, rightSiblingElement);
  190.     }
  191. }
  192.  
  193. //插入节点
  194. void insertChild(BiTree tree, TElementType p, TElementType LR, BiTree c) {
  195.     queue<BiTree> q;
  196.     q.push(tree);
  197.     while (!q.empty()) {
  198.         BiTree front = q.front();
  199.         q.pop();
  200.         if (front->data == p) {
  201.             if (LR == 'L') {
  202.                 front->leftChild = c;
  203.             } else {
  204.                 front->rightChild = c;
  205.             }
  206.             return;
  207.         }
  208.         if (front->leftChild != nullptr) {
  209.             q.push(front->leftChild);
  210.         }
  211.         if (front->rightChild != nullptr) {
  212.             q.push(front->rightChild);
  213.         }
  214.     }
  215. }
  216.  
  217. // 层序遍历二叉树,对每个节点调用函数visit一次且仅一次
  218. void leveOrderTraverse(BiTree T) {
  219.     if (T == nullptr) {
  220.         return;
  221.     }
  222.     queue<BiTree> q;
  223.     q.push(T);
  224.     while (!q.empty()) {
  225.         BiTree front = q.front();
  226.         cout << front->data << " ";
  227.         q.pop();
  228.         if (front->leftChild != nullptr) {
  229.             q.push(front->leftChild);
  230.         }
  231.         if (front->rightChild != nullptr) {
  232.             q.push(front->rightChild);
  233.         }
  234.     }
  235. }
  236. // 层序遍历二叉树
  237. void levelOrderTraverse(BiTree tree) {
  238.     if (tree == nullptr) {
  239.         return;
  240.     }
  241.     queue<BiTree> q;
  242.     q.push(tree);
  243.     while (!q.empty()) {
  244.         BiTree front = q.front();
  245.         cout << front->data << " ";
  246.         q.pop();
  247.         if (front->leftChild != nullptr) {
  248.             q.push(front->leftChild);
  249.         }
  250.         if (front->rightChild != nullptr) {
  251.             q.push(front->rightChild);
  252.         }
  253.     }
  254. }
  255. // 测试二叉树操作
  256. void testBitTree() {
  257.     // 创建二叉树
  258.     BiTree root = nullptr;
  259.     cout << "请输入二叉树的先序遍历序列，空节点用#表示：" << endl;
  260.     createBiTree(root);
  261.  
  262.     // 先序遍历
  263.     cout << "先序遍历结果：";
  264.     preOrderTraverse(root);
  265.     cout << endl;
  266.  
  267.     // 中序遍历
  268.     cout << "中序遍历结果：";
  269.     inOrderTraverse(root);
  270.     cout << endl;
  271.  
  272.     // 后序遍历
  273.     cout << "后序遍历结果：";
  274.     postOrderTraverse(root);
  275.     cout << endl;
  276.  
  277.     // 释放内存
  278.     delete root;
  279. }
  280.  
  281. int main() {
  282.  
  283.     // 创建二叉树
  284.     BiTree root = nullptr;
  285.     
  286.     cout << "请输入二叉树的先序遍历序列，空节点用#表示：" << endl;
  287.     createBiTree(root);
  288.  
  289.     // 先序遍历
  290.     cout << "先序遍历结果：";
  291.     preOrderTraverse(root);
  292.     cout << endl;
  293.  
  294.     // 中序遍历
  295.     cout << "中序遍历结果：";
  296.     inOrderTraverse(root);
  297.     cout << endl;
  298.  
  299.     // 后序遍历
  300.     cout << "后序遍历结果：";
  301.     postOrderTraverse(root);
  302.     cout << endl;
  303.  
  304.     // 层序遍历
  305.     cout << "层序遍历结果：";
  306.     levelOrderTraverse(root);
  307.     cout << endl;
  308.  
  309.     // 二叉树深度
  310.     cout << "二叉树深度：" << biTreeDepth(root) << endl;
  311.  
  312.     // 二叉树节点个数
  313.     cout << "二叉树节点个数：" << biTreeSize(root) << endl;
  314.  
  315.     // 删除节点
  316.     TElementType key;
  317.     cout << "请输入要删除的节点值：" << endl;
  318.     cin >> key;
  319.     root = deleteNode(root, key);
  320.  
  321.     // 层序遍历
  322.     cout << "删除节点后的层序遍历结果：";
  323.     levelOrderTraverse(root);
  324.     cout << endl;
  325.  
  326.     // 释放内存
  327.     delete root;
  328.  
  329.     return 0;
  330. }

       控制台输入信息：ABD##E##CF##G##

        控制台打印信息如下：

3.遍历二叉树和线索二叉树

1.遍历二叉树

        这里遍历二叉树有先序遍历二叉树、中序遍历二叉树、后序遍历二叉树三种方法。

1.先序遍历二叉树

        若二叉树为空，则空操作；否则

1.访问根节点

2.先序遍历左子树

3.先序遍历后子树

2.中序遍历二叉树

        若二叉树为空，则空操作；否则

1..中序遍历左子树

2.访问根节点

3.中序遍历右子树

3.后序遍历二叉树

        若二叉树为空，则空操作；否则

1.后序遍历左子树

2.后序遍历右子树

3.访问根节点

2.线索二叉树

        线索二叉树是对普通二叉树进行改进的一种数据结构，它的主要目的是提高对二叉树的遍历效率。在普通二叉树中，为了实现中序遍历等操作，需要使用递归或者栈来实现，而线索二叉树则通过添加额外的线索信息，使得在遍历过程中能够直接找到下一个或上一个节点，从而减少了递归或栈的使用。

        线索二叉树的节点结构通常包含原有的数据域，以及左右子树的指针，同时还包含了指向前驱节点和后继节点的线索指针。这些线索指针可以用来指向前驱节点或后继节点，从而实现在遍历过程中的快速定位。

        线索二叉树分为前序线索二叉树、中序线索二叉树和后序线索二叉树。其中，中序线索二叉树应用最为广泛，因为中序线索二叉树能够实现对二叉树的中序遍历操作，并且在遍历过程中不需要使用递归或者栈，从而提高了遍历的效率。

        总的来说，线索二叉树是通过添加额外的线索信息，使得在遍历过程中能够直接找到下一个或上一个节点，从而减少了递归或栈的使用，提高了对二叉树的遍历效率。

1.定义

  1. // 二叉树节点的定义
  2. typedef char TElementType;
  3.  
  4. // 线索二叉树节点的定义
  5. typedef struct ThreadNode {
  6.     TElementType data;
  7.     struct ThreadNode * leftChild, * rightChild;
  8.     int ltag, rtag; // 线索标志，0表示孩子，1表示线索
  9. } ThreadNode, * ThreadTree;

2.中序线索化函数

  1. // 中序线索化函数
  2. void inThread(ThreadTree &p, ThreadNode* &pre) {
  3.     if (p != nullptr) {
  4.         inThread(p->leftChild, pre); // 左子树线索化
  5.         if (p->leftChild == nullptr) { // 左孩子为空，建立前驱线索
  6.             p->leftChild = pre;
  7.             p->ltag = 1;
  8.         }
  9.         if (pre != nullptr && pre->rightChild == nullptr) { // 建立前驱的后继线索
  10.             pre->rightChild = p;
  11.             pre->rtag = 1;
  12.         }
  13.         pre = p; // 更新前驱节点
  14.         inThread(p->rightChild, pre); // 右子树线索化
  15.     }
  16. }

3.中序遍历线索二叉树

  1. // 中序遍历线索二叉树
  2. void inOrderTraverse(ThreadTree &tree) {
  3.     ThreadNode *p = tree->leftChild;
  4.     while (p != tree) {
  5.         while (p->ltag == 0) {
  6.             p = p->leftChild;
  7.         }
  8.         cout << p->data << " ";
  9.         while (p->rtag == 1 && p->rightChild != tree) {
  10.             p = p->rightChild;
  11.             cout << p->data << " ";
  12.         }
  13.         p = p->rightChild;
  14.     }
  15. }

4.创建线索二叉树

  1. void createThreadBiTree(ThreadTree &tree) {
  2.     TElementType data;
  3.     cin >> data;
  4.     if (data == '#') { // '#'表示空节点
  5.         tree = nullptr;
  6.     } else {
  7.         tree = new ThreadNode{data, nullptr, nullptr, 0, 0};
  8.         createThreadBiTree(tree->leftChild); // 创建左子树
  9.         createThreadBiTree(tree->rightChild); // 创建右子树
  10.     }
  11. }

5.完整代码

  1. #include <iostream>
  2. using namespace std;
  3.  
  4. // 二叉树节点的定义
  5. typedef char TElementType;
  6.  
  7. // 线索二叉树节点的定义
  8. typedef struct ThreadNode {
  9.     TElementType data;
  10.     struct ThreadNode * leftChild, * rightChild;
  11.     int ltag, rtag; // 线索标志，0表示孩子，1表示线索
  12. } ThreadNode, * ThreadTree;
  13.  
  14. // 中序线索化函数
  15. void inThread(ThreadTree &p, ThreadNode* &pre) {
  16.     if (p != nullptr) {
  17.         inThread(p->leftChild, pre); // 左子树线索化
  18.         if (p->leftChild == nullptr) { // 左孩子为空，建立前驱线索
  19.             p->leftChild = pre;
  20.             p->ltag = 1;
  21.         }
  22.         if (pre != nullptr && pre->rightChild == nullptr) { // 建立前驱的后继线索
  23.             pre->rightChild = p;
  24.             pre->rtag = 1;
  25.         }
  26.         pre = p; // 更新前驱节点
  27.         inThread(p->rightChild, pre); // 右子树线索化
  28.     }
  29. }
  30.  
  31. // 中序遍历线索二叉树
  32. void inOrderTraverse(ThreadTree &tree) {
  33.     ThreadNode *p = tree->leftChild;
  34.     while (p != tree) {
  35.         while (p->ltag == 0) {
  36.             p = p->leftChild;
  37.         }
  38.         cout << p->data << " ";
  39.         while (p->rtag == 1 && p->rightChild != tree) {
  40.             p = p->rightChild;
  41.             cout << p->data << " ";
  42.         }
  43.         p = p->rightChild;
  44.     }
  45. }
  46.  
  47. // 创建线索二叉树
  48. void createThreadBiTree(ThreadTree &tree) {
  49.     TElementType data;
  50.     cin >> data;
  51.     if (data == '#') { // '#'表示空节点
  52.         tree = nullptr;
  53.     } else {
  54.         tree = new ThreadNode{data, nullptr, nullptr, 0, 0};
  55.         createThreadBiTree(tree->leftChild); // 创建左子树
  56.         createThreadBiTree(tree->rightChild); // 创建右子树
  57.     }
  58. }
  59.  
  60. // 测试线索二叉树操作
  61. void testThreadBitTree() {
  62.     // 创建线索二叉树
  63.     ThreadTree root = nullptr;
  64.     cout << "请输入二叉树的先序遍历序列，空节点用#表示：" << endl;
  65.     createThreadBiTree(root);
  66.     
  67.     // 中序线索化
  68.     ThreadNode *pre = nullptr;
  69.     inThread(root, pre);
  70.     // 设置线索头节点
  71.     pre->rightChild = root;
  72.     pre->rtag = 1;
  73.     root->rightChild = pre;
  74.  
  75.     // 中序遍历线索二叉树
  76.     cout << "中序遍历结果：";
  77.     inOrderTraverse(root);
  78.     cout << endl;
  79.  
  80.     // 释放内存
  81.     delete root;
  82. }
  83.  
  84. int main() {
  85.     // 测试线索二叉树操作
  86.     testThreadBitTree();
  87.  
  88.     return 0;
  89. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/489160
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号