数据结构_树（2）

二叉搜索树

• 定义

  - 左子树的所有节点值小于根节点的键值
  - 右子树的所有节点值大于根节点的键值
  - 左右子树都是二叉搜索树
  

• 查找

  // 查找指定元素
  BinTree Find( int x, BinTree BST )
  {
      while ( BST )
      {
          if ( x > BST->Data )
          {
              BST = BST->Right;
          } else if ( x < BST->Data )
          {
              BST = BST->Left;
          } else {
              return BST;
          }
      }
      return (BinTree)NULL;
  }
  
  // 查找最小值类似与最大值
  // 查找最大值
  BinTree FindMax( BinTree BST )
  {
      if ( !BST )
      {
          return (BinTree)NULL;
      }
      while ( BST->Right )
      {
          BST = BST->Right;
      }
      return BST;
  }
  

• 插入
  

  BinTree Insert( int X, BinTree BST )
  {
      if ( !BST )
      {
          BST = (BinTree)malloc( sizeof( struct TreeNode ));
          BST->Data = X;
          BST->Left = BST->Right = NULL;
      } else {
          if ( X < BST->Data )
          {
              BST = BST->Left;
          } else if ( X > BST->Data ) {
              BST = BST->Right;
          }
      }
      return BST;
  }
  

• 删除

  BinTree Delete( ElementType X, BinTree BST )  
  {   
      Position Tmp;      
      if( !BST ) printf("要删除的元素未找到");      
      else if( X < BST->Data )              
          BST->Left = Delete( X, BST->Left); /* 左子树递归删除 */     
      else if( X > BST->Data )              
          BST->Right = Delete( X, BST->Right); /* 右子树递归删除 */     
      else /*找到要删除的结点 */           
          if( BST->Left && BST->Right ) { /*被删除结点有左右两个子结点 */
              Tmp = FindMin( BST->Right );                             
              /*在右子树中找最小的元素填充删除结点*/              
              BST->Data = Tmp->Data;               
              BST->Right = Delete( BST->Data, BST->Right);                                     /*在删除结点的右子树中删除最小元素*/          
          } else { /*被删除结点有一个或无子结点*/              
              Tmp = BST;               
              if( !BST->Left ) /* 有右孩子或无子结点*/                   
                  BST = BST->Right;               
              else if( !BST->Right ) /*有左孩子或无子结点*/                   
                  BST = BST->Left;              
              free( Tmp );          
          }     
      return BST; 
  }
  

平衡二叉树

• 定义

  平衡二叉树（Balanced Binary Tree）（AVL树）

  空树，或者任一结点左、右子树高度差的绝对值不超过1，即|BF(T) |≤ 1 ( BF(T) = hL-hR)

• 平衡二叉树的调整

  调整的原则，找到破坏节点和被破坏节点，进行旋转，通常是降低被破坏节点的高度。选择中间节点作为根节点进行旋转，如下所示

  RR旋转
  

  LL旋转

LR旋转

RL旋转

堆(heap)

• 定义

  优先队列（Priority Queue）：
  特殊的“队列”，取出元素的顺序是 依照元素的优先权（关键字）大小，而不是元素进入队列的先后顺序。 
  

• 优先队列的==完全二叉树==表示

• 特性

  结构性：用数组表示的完全二叉树； 
  有序性：任一结点的关键字是其子树所有结点的最大值(或最小值);
  

• 最大堆的操作

  typedef  struct  HeapStruct  *MaxHeap; 
  struct  HeapStruct {  
      ElementType *Elements;  /* 存储堆元素的数组 */  
      int Size;               /* 堆的当前元素个数 */  
      int Capacity;           /* 堆的最大容量*/ 
  };
  
  // 创建最大堆
  MaxHeap Create( int MaxSize ) {        
      /* 创建容量为MaxSize的空的最大堆 */ 
      MaxHeap H = malloc( sizeof( struct HeapStruct ) ); 
      H->Elements = malloc( (MaxSize+1) * sizeof(ElementType)); 
      H->Size = 0; 
      H->Capacity = MaxSize; 
      /* 定义“哨兵”为大于堆中所有可能元素的值，便于以后更快操作 */ 
      H->Elements[0] = MaxData;     
      return H; 
  }
  
  // 最大堆的插入
  void Insert( MaxHeap H, ElementType item ) { 
      /* 将元素item 插入最大堆H，其中H->Elements[0]已经定义为哨兵 */     
      int i;     
      if ( IsFull(H) ) {          
          printf("最大堆已满");         
          return;     
      }   
      i = ++H->Size; /* i指向插入后堆中的最后一个元素的位置 */   
      for ( ; H->Elements[i/2] < item; i/=2 )         
          H->Elements[i] = H->Elements[i/2]; /* 向下过滤结点 */   
      H->Elements[i] = item; /* 将item 插入 */ 
  }
  
  // 最大堆的删除，去最后一个节点值替换，并调整堆的次序
  ElementType DeleteMax( MaxHeap H ) {  
      /* 从最大堆H中取出键值为最大的元素，并删除一个结点 */     
      int Parent, Child;     
      ElementType MaxItem, temp;     
      if ( IsEmpty(H) ) {         
          printf("最大堆已为空");         
          return;     
      }     
      MaxItem = H->Elements[1]; /* 取出根结点最大值 */     
      /* 用最大堆中最后一个元素从根结点开始向上过滤下层结点 */     
      temp = H->Elements[H->Size--];   
      for( Parent=1; Parent*2<=H->Size; Parent=Child ) {       
          Child = Parent * 2;         
          if( (Child!= H->Size) &&       
             (H->Elements[Child] < H->Elements[Child+1]) )            
              Child++;  /* Child指向左右子结点的较大者 */         
          if( temp >= H->Elements[Child] ) break;     
          else  /* 移动temp元素到下一层 */         
              H->Elements[Parent] = H->Elements[Child];     
      }     
      H->Elements[Parent] = temp;     
      return MaxItem;
  }
  
  // 最大堆的建立