数据结构-二叉树(21.7.22)

我们之前学过了数组和链表，各有优缺点，还互补
二叉搜索树就既有链表的好处，也有数组的好处 ，好像用的最多的是二叉平衡树，有种特殊的二叉平衡树就是红黑树
管他有没有用的，学了先

一、基本概念

1、每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
2、二叉树的子树有左右之分，其子树的次序不能颠倒。
5、满二叉树——每一层都是满的
6、完全二叉树——满二叉树的最后一层且最后几个编号缺失
3、第 i 层最多有 2^i-1 个结点
4、深度为 h 的二叉树的最大结点数是2^h- 1
7、节点数量为k，1号点为根结点的完全二叉树：
（1）i>1的节点，其父结点是i/2；
（2）如果2i>k，那么i没有孩子；如果2i+1>k，那么i没有右孩子；
（3）如果结点i有孩子，那么他的左孩子是2i,右孩子是2i+1;
8、定义（节点写法,看作链表节点）

struct node
{  
     int value;//节点的值，如果是字母就换成char型的
     node * l,*r ;//左孩子和右孩子
     node(int value = 0,node *l=NULL,node *r =NULL):value(value),l(l),r(r){}//构造函数
};

二、存储结构

1、顺序存储：用数组来存储，一般使用数组只适合表示完全二叉树
2、链式存储：使用指针来实现，并指向左右子节点

三、二叉树的遍历

就像以前学过的搜索，分为广度和深度，深度又分了三种情况
1、层次遍历：A B C D E F G H I G K（迭代法）

2、先序遍历（父节点，左儿子，右儿子）：A B D H I E J C F K G

1、递归法
void preorder(node *root(头节点指针)，vec（数组）)
{
   if(root !=NULL)//终止条件
   {
         vec[k++] = root -> value; //value初始值是0，
         //vec.pushback(root -> value);//另一种写法
         preorder(root -> l);
         preorder(root -> r);
   }
}
2、迭代法（用栈模拟）
把数据放进数组里，因为栈的先进后出，所以先放右孩子，先弹出左孩子
void preorder(node *root)
{
    stack<node*> s;
    node *p =root;
    while(p!=NULL||!s.empty())
    {
         while(p!=NULL)//左不为空
         {
              s.push(p);
              将 p -> data存入数组
              p = p -> l;
         }
         if(!s.empty())
         {
              p = s.top();
              s.pop();//删除栈的最后一个元素
              p = p -> r;//左为空，走右子树
         }
    }
}

3、中序遍历（左儿子，父节点，右儿子）：H D I B E J A F K C G

1、递归
void inorder (node *root,vec)
{
   if(root !=NULL)
   {
         preorder(root -> l);
         vec[k++] = root -> value;
         preorder(root -> r);
   }
}
2、非递归
void preorder(node *root)
{
    stack<node*> s;
    node *p =root;
    while(p!=NULL||!s.empty())
    {
         while(p!=NULL)//左不为空
         {
              s.push(p);
              p = p -> l;
         }
         if(!s.empty())
         {
              p = s.top();
              将 p -> data存入数组//放在这是代表第二次遇见，即返回的时候才存入父节点
              s.pop();//删除栈的最后一个元素
              p = p -> r;//左为空，走右子树
         }
    }
}

4、后序遍历（左儿子，右儿子，父节点）：H I D J E B K F G C A

1、递归
void postorder (node *root,vec)
{
   if(root !=NULL)
   {
         preorder(root -> l);
         preorder(root -> r);
         vec[k++] = root -> value;
   }
}
2、非递归
需要判断当它第二次出现在栈顶时才能存入数组，即左边走一次再右边走一次回来才行
太麻烦了，不如直接递归吧