树，二叉树，查找

一，树，二叉树，查找（初步学习，如有不足，烦请告知）

一：思维导图

联系：

1. 树与二叉树可以相互转换
2. 查找中的树表查找;就是利用了二叉树，降低了时间复杂度

二：概念

1. 树

1. 基本术语：
   1. 度：
      1. 节点的度：节点的分支数
      2. 树的度：树中节点的最大分支数
2. 树的性质：
   1. 树的节点数=所有节点的度+1（总结点数=分支数+1）
   2. 度为m的树的第i层最多有m^(i-1)（i>=1）个节点
   3. 高度为h的m次数最多有(m^h-1)/(m-1)个节点
   4. 具有n个节点的m次树的最小高度为⌈logm (n(m-1)+1)⌉
3. 树的基本运算：
   1. 树的先根遍历：访问根节点，再按照从左到右的顺序先根遍历每一棵子树
   2. 树的后根遍历：按照从左到右的顺序后根遍历每一棵子树，再访问根节点

2. 二叉树

1. 定义：递归定义，度最多为2

2. 性质：

   1. 在二叉树的第i层上组多有2^(i-1)个节点（i>=1)
   2. 深度为h的二叉树最多含有2^h-1个节点
   3. n0=n2+1

3. 三个特殊二叉树

   1. 满二叉树：深度为k,含有2^k-1个节点
   2. 完全二叉树：树中n个节点，节点的编号依次与满二叉树中一一对应
      1. 任意一个编号为i的节点
         1. 若i=1,为根节点，否则编号为i/2为其双亲节点
         2. 若2i>n,该节点无左孩子，否则，编号为2i的节点为左孩子
         3. 若2i+1>n,该节点无左孩子，否则，编号为2i+1的节点为右孩子
      2. 具有n(n>0)个节点的完全二叉树的高度为：⌈log2 (n+1)⌉或者⌈log2 (n+1) ⌉
   3. 偏二叉树（单支树）

4. 二叉树的构造

   1. 根据中序序列和前序序列：前序序列确定根，中序序列确定左右子树

   2. 根据后序序列和中序序列：后序序列确定根，中序序列确定左右子树

   3. 根据顺序数列构造链式二叉树：

      Node GreatTree(string s, int  i) {
          if (i > s.size()-1) {
              return NULL;
          }
          if (s[i] == '#') {
              return NULL;
          }
          Node root = new treeNode;
          root->Data = s[i];
          root->lchild = GreatTree(s, i * 2);
          root->rchild = GreatTree(s, i * 2 + 1);
          return root;
      }
      

   4. 根据先序序列

      BiTree Create(string str,int &i) {
          if (i > str.size() - 1) {
              return NULL;
          }
          else if (str[i] == '#') {
              return NULL;
          }
          else {
              BiTree T = new BiTNode;
              T->ch = str[i];
              T->lchild = Create(str, ++i);
              T->rchild = Create(str, ++i);
              return T;
          }
      
      }
      

5. 树、二叉树和森林的转换

   1. 树转为二叉树：用孩子-兄弟存储法
   2. 森林转为二叉树：第一棵树提供左子树和根节点，每一棵树用树转为二叉树的方法
   3. 二叉树转为树、森林：上述做法的逆运算

6. 特殊构造的二叉树：

   1. 线索二叉树
      1. 当我们通过中序线索二叉树输出中序序列时：当我们找第一个节点时，该节点为最左下节点
   2. 哈夫曼树(带权路径最小)
      1. 构造方法：找还没参与过构造的最小和次小节点构造，当参与构造序列中所有元素参与构造，构造结束

3. 查找

1. 树表查找：

   1. AVL树（bf<=1)的二叉排序树
   2. B-树和B+树：
      1. 主要运用于外存

2. 哈希表的查找：

   1. 哈希表的构造：

      1. 除留余数法：

         h(k)=m%p(p为素数，p<=m)

   2. 哈希冲突的解决方法：

      1. 拉链法：所有有冲突的元素在一条链表上

      2. 开放定址法:

         1. 线性探测法：

            1. d0=h(k);

            2. di=(di-1)mod p;

         2. 平方探测法：

            1. d0=h(k);
            2. di=(d0+-i^2) mod p;

三，小问号+小思考

1.二叉树的非递归算法（主要学习了一下课本，有更好的想法时会回来改）

1. 现在我们有一棵树（问题）

我们可以轻易看出它的先序输出序列为：1 2 4 5 3 6 7，中序输出序列为 4 2 5 1 6 3 7，后序输出序列为 4 5 2 6 7 3 1,怎样非递归对它进行先/中/后序非递归遍历（当我们需要用非递归算法时，我们需要一个存储结构存储中间状态，我们选用了栈）

2. 1. void PreOrder(Bitree T) {//先序遍历非递归算法
          stack<Bitree>st;
          Bitree q;
          if (T) {
              st.push(T);
              while (!st.empty()) {
                  q = st.top();
                  cout << q->data << " ";
                  st.pop();//访问并出栈每次部分二叉树的根节点
                  if (q->rchild != NULL) {//先将右孩子进栈
                      st.push(q->rchild);
                  }
                  if (q->lchild != NULL) {
                      st.push(q->lchild);
                  }
              }
          }
      
      }
      

   2. 部分实例分析（先序输出序列为：1 2 4 5 3 6 7）：

      1. 由于树不空，我们将根节点进栈，我们将1进栈，访问并出栈1，现在我们已经输出了1;
      2. 之后我们将3先进栈（3为根节点1的右子树的根节点，由于栈先进后出，右孩子比左孩子先进栈，先进后处理），然后我们将2进栈，与递归操作相似，2为根节点1的左子树的根节点，再对2进行出栈访问，进栈2的右孩子，进栈2的左孩子
      3. 在栈不为空的时候，循环操作

3. 1. void InOrder(Bitree T) {
          stack<Bitree>st;
       while (!st.empty() || T) {
              while (T) {
            st.push(T);
                  T = T->lchild;//将根节点和左孩子依次进栈
           }
              if (!st.empty()) {
               T = st.top();
                  st.pop();
                  cout << T->data << ' ';
                  T = T->rchild;//处理右子树
           }
          }
      
      }
      

   2. 对于非递归中序遍历，先将根和左下节点进栈，依次访问出栈，并处理右子树，循环以上操作，

   3. 部分实例分析(中序输出序列为 4 2 5 1 6 3 7)：

      1. 我们先将1,2,4都进栈，相当于我们定位到最左边的子树的根节点4，然后我们出栈并访问4，相当于输出顺序中的“左”，现在已经输出4
      2. 由于4没有右孩子处理，我们将出栈并访问2，相当于输出顺序中的“根”，截止现在输出 4 2
      3. 我们对5进栈处理，由于5没有左孩子，我们出栈并访问5，相当于输出序列的“右”，截止现在输出 4 2 5……

4. 1. void PostOrder(Bitree T) {
          Bitree r=NULL;//用来作为前驱
       int flag = 1;//标记栈顶节点是否已处理了右子树
          stack<Bitree>st;
       do {
              while (T) {
               st.push(T);
                  T = T->lchild;//将T所有的左下节点进栈
           }
              r = NULL;//在每一个栈顶节点还未处理前值为NULL
              flag = 1;
              while (!st.empty()&&flag) {
                  T = st.top();
                  if (r == T->rchild) {//此时以T为根节点的树左右孩子均已处理
                      cout << T->data << " ";
                      r = T;//r标记前一个处理节点
                      st.pop();
      
                  }
                  else {
                      T = T->rchild;//处理该节点的右孩子
                      flag = 0;//此时不应该处理栈顶节点
                  }
      
              }
          } while (!st.empty());
      
      }
      

   2. 对于非递归后序遍历：我们对于根节点只有在左右子树都访问过的时候，才访问。每一次的栈顶节点相当于每一个部分树的根节点，我们就需要一个指针和标记（标记当前栈顶节点的左右子树是否已访问），确定是否访问栈顶节点

   3. 部分实例分析(后序输出序列为 4 5 2 6 7 3 1)：

      1. 我们先将1,2,4都进栈，此时栈顶元素为4，4没有右孩子，出栈访问4，现在已经输出4；

      2. 此时栈顶元素为2，2的右孩子5还没有被处理，则先处理5，将5进栈，由于5没有左右孩子，访问并出栈5 ，截止现在输出了4 5；

      3. 2 的右孩子5已被处理，则将2 出栈并访问，截止现在输出了 4 5 2……

2. 排序树的删除节点（针对被删除节点有左右子树的情况）

1. 之前我的解决方法

   void Delete1(Bitree &p, Bitree& l) {//删除节点有左右子树，找删除节点的左子树中最大的节点，替换它
   	Bitree q;
   	if (l->rchild != NULL) {
   		Delete1(p, l->rchild);//找删除节点的左子树中最大的节点,即前继节点
   	}
   	else {
   		p->key = l->key;
   		q = l;
   		l = l->lchild;
   		delete (q);
   		
   	}
   }
   

2. 在pta中和别人学习到的一种,算是调用自身，我觉得挺好玩的

   BinTree Delete(BinTree BST, ElementType X) {
       if (!BST) {
           printf("Not Found
   ");
       }
       else if (X > BST->Data) {
           BST->Right = Delete(BST->Right, X);
       }
       else if (X < BST->Data) {
           BST->Left = Delete(BST->Left, X);
   
       }
       else {
           if (BST->Left && BST->Right) {
               BinTree p = FindMin(BST->Right);//BinTree p = FindMax(BST->Left);
               BST->Data = p->Data:
               BST->Right = Delete(BST->Right, BST->Data);//BST->Left = Delete(BST->Left, BST->Data);
           }
           else {
               if (!BST->Left) {
                   BST = BST->Right;
               }
               else if (!BST->Right) {
                   BST = BST->Left;
               }
           }
       }
       return BST;
   }
   
   

3. 稍微复杂的AVL平衡（刚开始的时候，我更倾向于超星上的插入，不过我在这里用的是旋转）

1. 先让我举个例子（取自ppt）

   插入8 12 1 10 15 9时

   

   1. 我们确定发现节点为8，将发现节点8和离插入节点9最近的两个节点进行重排，其他节点先不变，将RL型转为RR型，再逆时针旋转

   2. 将RL型转为RR型

   

3. AVl树的一些计算（由于课上讲的较少）

1. 先让我举个例子（来自课堂派）

   若AVL树的深度为6,（空树的深度为0，只有一个节点的深度为1），求问此时AVL树的最少节点为多少？

   1. 设每棵树的深度为h，深度为h的树的最少节点为Min(h)

   2. Min(0)=0,Min(1)=1,Min(2)=2,Min(3)=Min(1)+Min(2)+1,我们可以得出Min(h)=Min(h-1)+MIn(h-2)+1(h>=2);

   3. 文字版规律叙述：原理是AVl树的每棵部分树都是AVL树，就一颗深度为h的AVL树为根节点和左子树、右子树组成（根节点在这种情况不影响平衡因子），节点最少的情况为，当左子树（右子树）看成深度为h-1的AVL树，当右子树（左子树）看成深度为h-2的AVL树，Min(h)=Min(h-1)+MIn(h-2)+1(h>=2);

   4. 图画版规律叙述（我就举几个情况）：

   

4. B-树节点的删除（节点插入的逆运算，课上没咋讲，是的，没错，它不能直接删除）

1. 先让我举个例子（来自作业）的3阶B-树

我们要先删除节点100，再删除节点60

2. 让我们开始搞

   1. 先熟悉一下B-树删除一个节点原理

      原理：非根节点的关键字个数不能少于⌈m/2⌉-1,否则

      1. 若被删除关键字所在节点为非叶子节点，找后继节点替代，后继节点肯定为叶子结点，然后就转为删除叶子节点中的关键字的问题
      2. 删除的关键字在叶子结点
         1. 若删除关键字所在的节点关键字>⌈m/2⌉-1,直接删除该关键字
         2. 当左/右兄弟中关键字富余，从左/右兄弟中调用一个关键字，再删除关键字
         3. 进行节点合并（将双亲节点中下移一个关键字，与被删除节点和相邻兄弟节点合并 ），再删除关键字

   3. 1. 删除100

         

         删除后

         

      2. 删除60

         1. 还没删除前是这样

         

         2. 我们发现60的兄弟节点的关键字不富余，我们则要进行节点合并

         

         删除后

         

5. 哈希函数中AVL不成功的计算

1. 让我们先举个例子，题目来自课堂派

让我们先了解一下这时候的不成功是什么情况：

1. 本题哈希函数，我们记为h(key)=key%p我们得到的值记为d0=h(hey),若我们发现d0所在地址的关键字与我们查找的关键字不同，我们向di=(di-1 +1)%p(本题p为11)查找，直到当我们找到的地址里啥也没有(可能出现折返查找的情况(因为我们进行了取余操作))，我们才灰心丧气，查找不成功，注意：由于我们没有进去比对的话，我们不知道里面没关键字，所以找到空也记为1次

2. 不成功情况为11，就某数%11肯定是共有11种情况（0~10）

3. 让我们再举个例子，还是来自课堂派
   

   1. 不成功情况为找到空指针：此时空指针的话，我们要查找的数就没有进去比对的存储空间，因为为空，所以我们找到空指针时不记次数