001_容器的基本使用_vector

  1. // 001_容器的基本使用_vector.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
  2. //
  4. #include "pch.h"
  5. #include <iostream>
  6. #include <vector>
  7. using namespace std;
  9. int main()
  10. {    // vecNum是一个类对象
  11.     vector<int> vecNum;
  13.     // 增
  14.     // 将一个元素存入到动态数组中. 此时数组的元素个数等于1
  15.     vecNum.push_back(100);
  17.     // 插入的时候, 只能传递一个迭代器
  18.     // 要插入到哪个位置就需要先得到该位置的迭代器
  19.     // 迭代器就类似于一个指针
  20.     // 1. 定义迭代器
  21.     // 1.1 iterator是一个类名, 这个类定义在了vector类中.
  22.     //     iterator是一个类中类
  23.     // 1.2 vector<int>::iterator是说明iterator是在vector<int>类中的
  24.     //       vector<int>::就相当于选择指定作用域
  25.     vector<int>::iterator itr = vecNum.begin(); // 得到动态数组的第1个元素的迭代器对象
  26.     // 2. 迭代器的三种用法:
  27.     // 2.1 自增运算符: ++itr或者itr++,
  28.     //       作用: 找到容器中的下一个元素
  29.     // 2.2 自减运算符: --itr或者itr--,
  30.     //       作用: 找到容器中的上一个元素
  31.     // 2.3 取内容运算符: *itr
  32.     //        作用: 获取迭代器对应的元素的内容
  33.     cout << "itr=" << *itr << endl;// 输出了100,因为100就是第一个元素,itr刚好指向了第一个元素
  35.     // 2.3 如果容器的元素个数发生了变化(增加/删除),迭代器对象有可能
  36.     //     就失效了 , 因此,最后重新获取一个迭代器.
  37.     vecNum.insert(itr, 200);
  39.     // 删
  40.     // erase只能接收一个迭代器. 删除哪个,就需要传递哪个
  41.     // 元素对应的迭代器
  42.     // vecNum.begin() + 1 : 指的是第二个元素
  43.     vecNum.erase(vecNum.begin() + 1);
  45.     vecNum.push_back(300);
  46.     vecNum.push_back(400);
  47.     // 改(访问)
  48.     cout << "当前元素个数:" << vecNum.size() << endl;
  49.     cout << "第1个元素的值是: " << vecNum[0]<<endl;
  50.     itr = vecNum.begin();
  51.     cout << "第2个元素的值是: " << *(itr + 1) << endl;
  53.     vecNum[0] = 10000;// 通过[]运算符来修改
  54.     cout << "第1个元素的值是: " << vecNum[0] << endl;
  55.     itr = vecNum.begin();
  56.     *(itr + 1) = 20000; // 通过迭代器来修改
  57.     cout << "第2个元素的值是: " << *(itr + 1) << endl;
  59.     // 查(遍历)
  60.     // 下标遍历法
  61.     for (int i = 0; i < vecNum.size(); ++i) {
  62.         cout << vecNum[i]<<',';
  63.     }
  64.     cout << endl;
  65.     // 迭代器遍历法(通用)
  66.     // auto : 自动根据begin函数返回值类型来推测
  67.     //        出itr的变量类型,此处推测出来的是:vector<int>::iterator
  68.     for (auto itr = vecNum.begin();
  69.          itr != vecNum.end();/*循环结束条件*/
  70.          ++itr)
  71.     {
  72.         // 通过迭代器来取得元素的值
  73.         cout << *itr << ',';
  74.     }
  75.     cout << endl;
  76.     // c++的新式循环
  77.     // 格式: for( 元素类型 变量名 : 可迭代对象){}
  78.     // 元素类型 : 就是从可迭代对象中取出的元素的类型
  79.     // 变量名       : 随便起
  80.     // 可迭代对象: 所有的容器, 可以是一个数组.
  81.     // auto& d : vecNum
  82.     // auto 自动类型, 能够自动推测出从vecNum中取出的元素的数据类型是什么
  83.     // &  : 表示引用类型, 表示从vecNum中取出的元素将会被赋值给变量d
  84.     //        如果使用引用, 那么d就没有内存,直接引用vecNum中的元素, 修改
  85.     //        了d也就等于修改了保存在vecNum中的元素,顺便还能提升循环的效率
  86.     //        (没有引用的话,从vecNum获取一个元素时,就需要拷贝一次0
  87.     // 循环会自动遍历完可迭代对象的所有元素,然后自动退出.
  88.     for (auto& d : vecNum) {
  89.         cout << d << ',';
  90.     }
  91. }

002_容器的使用_list

  1. // 002_容器的使用_list.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
  2. //
  4. #include "pch.h"
  5. #include <iostream>
  6. #include <list>
  7. using namespace std;
  8. int main()
  9. {
  10.     list<int> listNum;
  11.     // 增
  12.     listNum.push_back(100);
  13.     listNum.push_back(300);
  14.     listNum.insert(listNum.begin(), 200);
  15.     // **注意** : list迭代器只能使用++,或--, 不能使用+运算符
  18.     // 删
  19.     // 只能用迭代器, 但如果要删除第2个元素
  20.     list<int>::iterator itr = listNum.begin();
  21.     // itr = itr + 3;list迭代器只能使用++,或--, 不能使用+运算符
  22.     ++++itr; // 自增2次指向第2个元素
  23.     // 所有容器的erase都会删除迭代器指向的元素
  24.     // 然后删除之后itr指向就无效了, 因此就变成了一个无效迭代器
  25.     // erase会通过返回值返回一个有效的迭代器(一般是删除位置的下一个元素的迭代器)
  26.     itr = listNum.erase(itr);
  28.     // 改
  29.     // 只能通过迭代器去修改
  30.     // 例如:修改第1个元素
  31.     itr = listNum.begin();
  32.     cout << "第1个元素: " << *itr << endl;
  33.     *itr = 111111;
  34.     cout << "第1个元素: " << *itr << endl;
  35.     // 例如:修改第2个元素
  36.     ++itr; // 自增找到第二个元素
  37.     cout << "第2个元素: " << *itr << endl;
  38.     *itr = 111111;
  39.     cout << "第2个元素: " << *itr << endl;
  41.     // 查
  42.     // 通过迭代器来遍历
  43.     for (auto i = listNum.begin(); i != listNum.end(); ++i) {
  44.         cout << *i << ',';
  45.     }
  46.     cout << endl;
  47.     // 通过新式循环来遍历
  48.     for (auto& d : listNum) {
  49.         cout << d << ',';
  50.     }
  51.     cout << endl;
  52. }

003_容器的基本使用_map

  1. // 003_容器的基本使用_map.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
  2. //
  4. #include "pch.h"
  5. #include <iostream>
  6. #include <map>
  7. #include <string>
  8. #include <set>
  9. using namespace std;
  11. int main()
  12. {
  13.     // 什么是键值对?
  14.     // 键 : 相当于一个索引.相当于目录中的一下.
  15.     // 值 : 就是一堆真正要保存的数据. 键相当于值的摘要.用于代表这个值.
  16.     // 例如 , 姓名:小明. 姓名:小红, 其中姓名就是键,小明就是值
  17.     //         年龄: 18 , 年龄就是键,18就是值.
  18.     //         4544545 : 小名
  19.     //        4544545就是键,小名值.
  20.     // 总是用键来索引值.
  22.     // <string, string> 
  23.     // 第一个string指的是键的类型
  24.     // 第二个string指的是值的类型
  25.     // 当需要将数据保存到map容器中时,
  26.     //   保存的数据的键值对必须都是string类型.
  27.     map<string, string> m1;
  28.     map<int, string> m2;
  29.     // 增
  30.     // pair是一个键值对类
  31.     // map就是用于保存键值对类的平衡二叉树.
  32.     // map是一个平衡二叉树(红黑树)
  33.     // 树中节点的数据类型是 std::pair<typename,typename>
  34.     // 插入数据到map中的时候, 必须先给出键值对来初始化一个pair对象
  35.     // 然后再pair对象插入到map中.
  36.     pair<string,string> p1("姓名","小明");
  37.     m1.insert(p1);
  38.     //p1是一个键值对对象
  39.     cout<<"p1.first="<< p1.first<<endl; // 键值对中的键
  40.     cout << "p1.second=" << p1.second << endl;// 键值对中的值
  43.     // 也可以直接在实参中调用pair的构造函数来构造一个pair对象
  44.     m1.insert(pair<string, string>("年龄", "18"));
  46.     // 第三种方法,直接使用`[]`运算符来插入
  47.     // 实际上[]运算符会在二叉树中以"性别"作为键来搜索pair对象
  48.     // 如果没有搜索到, 函数会自动在树中插入一个用"性别"作为键
  49.     // 的pair对象, 然后再将新pair对象值赋值成"男"
  50.     m1["性别"] = "男";
  52.     // m1["姓名"]运算符会在树中以"姓名"作为键找到对应的pair
  53.     // 对象, 然后将pair对象的值返回.
  54.     string str = m1["姓名"]; // str被赋值成"小明"
  55.     str = m1["aaa"]; // 如果获取一个不存在的键的时候,就会插入一个,值有可能会随机(取决于值的类型有无构造函数)
  57.     // 删
  58.     // 直接传入一个键就行了. 对应的键值对就会被删除.
  59.     m1.erase("姓名");
  61.     // 改
  62.     cout << "性别:" << m1["性别"] << endl;
  63.     m1["性别"] = "女";
  64.     cout << "性别:" << m1["性别"] << endl;
  66.     // 查
  67.     // map保存的节点是pair对象
  68.     // 所以map的迭代器指向的元素都是pair对象.
  69.     // 
  70.     cout << "遍历map\n";
  71.     for (auto itr = m1.begin();
  72.          itr != m1.end();
  73.          ++itr)
  74.     {
  75.         itr->first; //(*itr).first
  76.         cout << itr->first << "="
  77.             <<itr->second << endl;
  78.     }
  82.     m2.insert(pair<int, string>(1, "123456"));
  83.     m2.insert(pair<int, string>(2, "456789"));
  84.     m2[100] = "1111";
  86.     cout << "遍历map\n";
  87.     for (auto itr = m2.begin();
  88.          itr != m2.end();
  89.          ++itr)
  90.     {
  91.         itr->first; //(*itr).first
  92.         cout << itr->first << "="
  93.             << itr->second << endl;
  94.     }
  96. }

A星算法

A星算法.zip

平衡二叉树

  1. // 二叉树.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
  2. //
  3. #include "pch.h"
  4. #include <stdio.h>
  8. // 二叉查找树
  9. class AVLTree {
  10. public:
  11.     struct Node {
  12.         int nData;        // 节点的数据域
  13.         Node* pLeft;    // 左子树指针
  14.         Node* pRight;    // 右子树指针
  16.         Node() :pLeft(), pRight() {}
  17.         Node(int nData)
  18.             :nData(nData), pLeft(), pRight()
  19.         {}
  20.     };
  21. public:
  23.     int m_nCount = 0; // 树中节点个数
  24.     Node* m_pRoot = 0;// 根节点指针:记录树中的根节点地址.
  26. protected:
  27.     // 参数1是指针的引用, 为的是能够在
  28.     // 函数内部修改函数外部的实参(可以参考交换两个变量的函数)
  29.     /*!
  30.      * 函数名 : insert
  31.      * 功  能 : 将数据nData插入到pTree作为根节点的树居中
  32.      * 参  数 : Node * & pTree 树的根节点.
  33.      * 参  数 : int nData 插入的数据
  34.      * 返回值 :  void
  35.      */
  36.     bool insert(Node*& pTree, int nData) {
  37.         // 1. 判断树的根节点是否为NULL,如果为NULL
  38.         //    直接插入到根节点
  39.         bool isInsert = false;
  40.         if (pTree == nullptr) {
  41.             pTree = new Node(nData);
  42.             // 递增节点个数
  43.             ++m_nCount;
  44.             return true;
  45.         }
  46.         // 2. 如果不为空,则判断插入的数据和根节点
  47.         //    所保存的数据的大小关系
  48.         if (nData < pTree->nData) {
  49.             // 3. 如果插入数据小于根节点数据,那么就将
  50.             //    根节点的左子树作为新的根节点,让后将
  51.             //    数据插入到左子树中.
  52.             isInsert = insert(pTree->pLeft, nData);
  53.         }
  54.         else {
  55.             // 否则就插入到右子树中.
  56.             isInsert = insert(pTree->pRight, nData);
  57.         }
  58.         if (isInsert) {
  59.             sort(pTree);
  60.         }
  61.         return isInsert;
  62.     }
  64.     Node*& find(Node*& pTree, int nData) {
  65.         if (pTree == nullptr) {
  66.             return pTree;
  67.         }
  68.         // 1. 判断当前节点保存的数据是否
  69.         //    就是要查找的数据
  70.         if (pTree->nData == nData) {
  71.             // 如果是, 就返回节点本身
  72.             return pTree;
  73.         }
  74.         // 如果不是, 则判断这个数据是在节点的左子树中
  75.         // 还是在右子树中.
  76.         // 因为二叉树是左小右大的.
  77.         // 因此, 比较要删除的数据和当前节点的大小关系
  78.         // 就能知道是在左子树还是在右子树中
  79.         else if (nData < pTree->nData) {
  80.             return find(pTree->pLeft, nData);
  81.         }
  82.         else {
  83.             return find(pTree->pRight, nData);
  84.         }
  85.     }
  86.     bool remove(Node*& pTree, int nData) {
  87.         if (pTree == nullptr) {
  88.             return false;
  89.         }
  90.         bool isRemove = false;
  91.         printf("-------- 删除:%d-----  \n", nData);
  92.         printTree();
  94.         // 1. 在树中查找到要删除的节点.
  95.         Node*& pFindNode = find(pTree, nData);
  96.         // 是否能够找到节点.
  97.         if (pFindNode == nullptr) {
  98.             return false;
  99.         }
  100.         // 2. 找到节点的就是被删除的节点
  101.         //    删除时要判断节点是否是一个叶子节点
  102.         //    如果是叶子节点可以直接删除
  103.         if (pFindNode->pLeft == nullptr && pFindNode->pRight == nullptr) {
  104.             // 直接删除
  105.             delete pFindNode;
  106.             // 将指针设置为空,由于pFindNode是一个指针
  107.             // 的引用, 因此它修改的是哪里????(实际上修改的是
  108.             // 父节点的右子树指针或左子树指针)
  109.             pFindNode = nullptr;
  110.             // 递减节点个数
  111.             --m_nCount;
  112.             return true;
  113.         }
  114.         // 3. 如果不是叶子节点. 就需要在被删除节点的
  115.         //    子树中找到一个叶子节点, 然后两者的值
  116.         //    互换, 再删除掉叶子节点
  117.         // 3.1 再找叶子节点的时候, 需要考虑子树高度差
  118.         //    因此会在树高比较高的子树中找叶子节点.
  119.         int nLeftHeight = getHeight(pFindNode->pLeft);
  120.         int nRightHeight = getHeight(pFindNode->pRight);
  121.         // 3.2 树中左小右大的关系, 因此, 需要左子树中
  122.         //     找最大值, 在右子树中找最小值.    
  123.         if (nLeftHeight >= nRightHeight) {
  124.             // 左子树比较高,需要找最大值
  125.             Node*& pNode = getMax(pFindNode->pLeft);
  126.             // 将当前被找到的节点和叶子节点的数据域
  127.             // 进行调换
  128.             int t = pFindNode->nData;
  129.             pFindNode->nData = pNode->nData;
  130.             pNode->nData = t;
  131.             // 删除叶子节点
  132.             // 递归删除.
  133.             isRemove = remove(pFindNode->pLeft, pNode->nData);
  134.         }
  135.         else {
  136.             // 右子树比较高,需要找最小值
  137.             Node*& pNode = getMin(pFindNode->pRight);
  138.             int t = pFindNode->nData;
  139.             pFindNode->nData = pNode->nData;
  140.             pNode->nData = t;
  141.             // 删除叶子节点
  142.             // 递归删除.
  143.             isRemove = remove(pFindNode->pRight, pNode->nData);
  144.         }
  145.         // 如果删除成功,就检测树是否平衡
  146.         if (isRemove) {
  147.             sort(pTree);
  148.         }
  149.         return isRemove;
  150.     }
  151.     /*!
  152.      * 函数名 : getHeight
  153.      * 功  能 : 求一个树的高度
  154.      * 参  数 : Node * pTree
  155.      * 返回值 :  int
  156.      */
  157.     int getHeight(Node* pTree) {
  158.         if (pTree == nullptr) {
  159.             return 0;
  160.         }
  161.         // 求出左子树的高度
  162.         int nLeftHeight =
  163.             getHeight(pTree->pLeft);
  165.         // 求出右子树的高度
  166.         int nRightHeight =
  167.             getHeight(pTree->pRight);
  168.         // 取左右子树高度的最大值作为子树的高度
  169.         int nHeight = nLeftHeight > nRightHeight ? nLeftHeight : nRightHeight;
  171.         // 本节点的高度 = 自身高度 + 子树的高度
  172.         return 1 + nHeight;
  173.     }
  175.     Node*& getMin(Node*& pTree) {
  176.         if (pTree == nullptr) {
  177.             return pTree;
  178.         }
  180.         // 二叉树是左小右大的.
  181.         // 一个树的最小值就在树的最左边
  183.         if (pTree->pLeft == nullptr) {
  184.             // 如果本节点的左子节点已经为空了
  185.             // 说明了本节点就是树中最左边的节点
  186.             // 就返回节点自身.
  187.             return pTree;
  188.         }
  189.         return getMin(pTree->pLeft);
  190.     }
  192.     Node*& getMax(Node*& pTree) {
  193.         if (pTree == nullptr) {
  194.             return pTree;
  195.         }
  196.         // 二叉树是左小右大的.
  197.         // 一个树的最大值就在树的最右边
  198.         if (pTree->pRight == nullptr) {
  199.             // 如果本节点的右子节点已经为空了
  200.             // 说明了本节点就是树中最右边的节点
  201.             // 就返回节点自身.
  202.             return pTree;
  203.         }
  204.         return getMax(pTree->pRight);
  205.     }
  207.     // 清空整颗树(后序遍历
  208.     void clear(Node*& pTree) {
  209.         clear(pTree->pLeft);
  210.         clear(pTree->pRight);
  211.         delete pTree;
  212.     }
  213.     // 前序方式遍历树
  214.     void printTreeByPreOrder(Node*& pTree) {
  215.         if (pTree == nullptr) {
  216.             return;
  217.         }
  218.         printf("%d,", pTree->nData);
  219.         printTreeByPreOrder(pTree->pLeft);
  220.         printTreeByPreOrder(pTree->pRight);
  221.     }
  222.     // 中序方式遍历树
  223.     void printTreeByInOrder(Node*& pTree) {
  224.         if (pTree == nullptr) {
  225.             return;
  226.         }
  227.         printTreeByInOrder(pTree->pLeft);
  228.         printf("%d,", pTree->nData);
  229.         printTreeByInOrder(pTree->pRight);
  230.     }
  231.     // 后序方式遍历树
  232.     void printTreeByPostOrder(Node*& pTree) {
  233.         if (pTree == nullptr) {
  234.             return;
  235.         }
  236.         printTreeByPostOrder(pTree->pLeft);
  237.         printTreeByPostOrder(pTree->pRight);
  238.         printf("%d,", pTree->nData);
  239.     }
  241.     void printTree(Node*& pTree, int nWidth, char ch) {
  242.         if (pTree == nullptr) {
  243.             return;
  244.         }
  245.         printTree(pTree->pLeft, nWidth + 2, '/');
  246.         printf("%*c%d\n", nWidth, ch, pTree->nData);
  247.         printTree(pTree->pRight, nWidth + 2, '\\');
  248.     }
  251.     /*!
  252.      * 函数名 : sortLeft
  253.      * 功  能 : 将一颗右单斜的树进行左旋,然后使其平衡
  254.      * 参  数 : Node * & pTree
  255.      * 返回值 :  void
  256.      */
  257.     void sortLeft(Node*& K) {
  258.         /*
  259.         *  K(7)
  260.         *    \                M(9)
  261.         *    M(9)             (    \
  262.         *   /   \          K(7)      N(10)
  263.         * L(8)   N(10)        )
  264.         *                    L(8)
  265.         *
  266.         * K->pRight = L
  267.         * M->pLeft = K
  268.         * K = M
  269.         */
  270.         Node* M = K->pRight;
  271.         Node*L = M->pLeft;
  272.         Node* N = M->pRight;
  273.         K->pRight = L;
  274.         M->pLeft = K;
  275.         K = M;
  276.     }
  278.     /*!
  279.      * 函数名 : sortRight
  280.      * 功  能 : 将一颗左单斜的树进行左旋,然后使其平衡
  281.      * 返回值 :  void
  282.      */
  283.     void sortRight(Node*& K) {
  284.         /*
  285.         *      K(6)                M(4)
  286.         *      /                /  )
  287.         *     M(4)             N(2)  K(6)
  288.         *    /   \                   (
  289.         *  N(2)  R(5)              R(5)
  290.         *
  291.         * K->pLeft = R
  292.         * M->pRight = K
  293.         * K = M
  294.          */
  295.         Node* M = K->pLeft;
  296.         Node* N = M->pLeft;
  297.         Node* R = M->pRight;
  298.         K->pLeft = R;
  299.         M->pRight = K;
  300.         K = M;
  301.     }
  303.     /*!
  304.      * 函数名 : sortLeftRight
  305.      * 功  能 : 先左旋再右旋,将右歪斜树变成平衡树
  306.      * 参  数 : Node * &
  307.      * 返回值 :  void
  308.      */
  309.     void sortRightLeft(Node*& K ) {
  310.         /*
  311.         *    K(6)     K(6)            N(7)
  312.         *    \           \              /      \
  313.         *      M(8)      N(7)      K(6)  M(8)
  314.         *      /            \
  315.         *    N(7)        M(8)
  316.         *       /
  317.         *   ??
  318.         * 1. 以M作为顶点. 将M形成树视为左单斜树,使用右单旋使其平衡
  319.         * 2. 以K作为顶点, 将K形成的是右单斜树, 使用左单旋使其平衡
  320.         */
  321.         sortRight(K->pRight);
  322.         sortLeft(K);
  323.     }
  325.     void sortLeftRight(Node*& K) {
  326.         sortLeft(K->pLeft);
  327.         sortRight(K);
  328.     }
  330.     void sort(Node*& pTree) {
  331.         // 1. 判断树的形状:
  332.         int nLeftHeight = getHeight(pTree->pLeft);
  333.         int nRightHeight = getHeight(pTree->pRight);
  334.         if (nLeftHeight - nRightHeight > 1) {
  335.             // 1.1 左斜
  336.             nLeftHeight = getHeight(pTree->pLeft->pLeft);
  337.             nRightHeight = getHeight(pTree->pLeft->pRight);
  338.             if (nLeftHeight > nRightHeight) {
  339.                 // 1.1.1 左单斜
  340.                 sortRight(pTree);
  341.             }
  342.             else {
  343.                 // 1.1.2 左歪斜
  344.                 sortLeftRight(pTree);
  345.             }
  346.         }
  347.         else if (nLeftHeight - nRightHeight < -1) {
  348.             // 1.2 右斜
  349.             nLeftHeight = getHeight(pTree->pRight->pLeft);
  350.             nRightHeight = getHeight(pTree->pRight->pRight);
  351.             if (nRightHeight > nLeftHeight) {
  352.                 // 1.2.1 右单斜
  353.                 sortLeft(pTree);
  354.             }
  355.             else {
  356.                 // 1.2.2 右歪斜
  357.                 sortRightLeft(pTree);
  358.             }
  359.         }
  360.     }
  361. public:
  362.     void insert(int nData) {
  363.         insert(m_pRoot, nData);
  364.     }
  365.     void remove(int nData) {
  366.         remove(m_pRoot, nData);
  367.     }
  368.     void printTree() {
  369.         printTree(m_pRoot, 2, '*');
  370.         printf("\n");
  371.     }
  372. };
  373. struct MyStruct {
  374.     int nNum = 0;
  375.     const char* pStr;
  376. };
  377. const char*& fun(const char*& p) {
  378.     return p;
  379. }
  380. int main() {
  382.     MyStruct stc = { 0, "hello" };
  383.     const char*& p = fun(stc.pStr);
  384.     p = "呵呵";
  386.     AVLTree tree;
  387. //     tree.insert(10);
  388. //     tree.insert(5);
  389. //     tree.insert(20);
  390. //     tree.insert(7);
  391. //     tree.insert(6);
  392. //     tree.printTree();
  393. // 
  394. // 
  395. //     tree.remove(10);
  396. //     tree.printTree();
  397.     // 测试平衡性
  398.     for (int i = 0; i<10;++i)
  399.     {
  400.         tree.insert(i);
  401.         tree.printTree( );
  402.     }
  403.     printf("删除\n");
  404.     for (int i = 0; i < 10; ++i) {
  405.         tree.remove(i);
  406.         printf("删除并旋转之后:\n");
  407.         tree.printTree();
  408.     }
  409. }