6-1 second operating current binary search tree (30)

About half of large data structures

The set of operations binary search tree

This problem required to achieve a given species to five binary search tree operation.

Function interface definition:

BinTree Insert( BinTree BST, ElementType X );
BinTree Delete( BinTree BST, ElementType X );
Position Find( BinTree BST, ElementType X );
Position FindMin( BinTree BST );
Position FindMax( BinTree BST );

Wherein the BinTreestructure is defined as follows:

typedef struct TNode *Position;
typedef Position BinTree;
struct TNode{
    ElementType Data;
    BinTree Left;
    BinTree Right;
};

• Function InsertThe Xinsertion binary search tree BSTand returns a pointer to the root of the result of the tree;
• Function Deleteto Xthe binary search tree BSTdeletion and returns the pointer to the root of the result tree; if Xnot in the tree, then print a line Not Foundroot pointer and return the original tree;
• Function Findin the binary search tree BSTfound in X, it returns a pointer to the node; if no null pointer is returned;
• Function FindMinreturns the binary search tree BSTpointer smallest element nodes;
• Function FindMaxreturns the binary search tree BSTpointer largest element nodes.
• Referee test program example :

• #include <stdio.h>
  #include <stdlib.h>
  
  typedef int ElementType;
  typedef struct TNode *Position;
  typedef Position BinTree;
  struct TNode{
      ElementType Data;
      BinTree Left;
      BinTree Right;
  };
  
  void PreorderTraversal( BinTree BT ); /* 先序遍历，由裁判实现，细节不表 */
  void InorderTraversal( BinTree BT );  /* 中序遍历，由裁判实现，细节不表 */
  
  BinTree Insert( BinTree BST, ElementType X );
  BinTree Delete( BinTree BST, ElementType X );
  Position Find( BinTree BST, ElementType X );
  Position FindMin( BinTree BST );
  Position FindMax( BinTree BST );
  
  int main()
  {
      BinTree BST, MinP, MaxP, Tmp;
      ElementType X;
      int N, i;
  
      BST = NULL;
      scanf("%d", &N);
      for ( i=0; i<N; i++ ) {
          scanf("%d", &X);
          BST = Insert(BST, X);
      }
      printf("Preorder:"); PreorderTraversal(BST); printf("\n");
      MinP = FindMin(BST);
      MaxP = FindMax(BST);
      scanf("%d", &N);
      for( i=0; i<N; i++ ) {
          scanf("%d", &X);
          Tmp = Find(BST, X);
          if (Tmp == NULL) printf("%d is not found\n", X);
          else {
              printf("%d is found\n", Tmp->Data);
              if (Tmp==MinP) printf("%d is the smallest key\n", Tmp->Data);
              if (Tmp==MaxP) printf("%d is the largest key\n", Tmp->Data);
          }
      }
      scanf("%d", &N);
      for( i=0; i<N; i++ ) {
          scanf("%d", &X);
          BST = Delete(BST, X);
      }
      printf("Inorder:"); InorderTraversal(BST); printf("\n");
  
      return 0;
  }
  /* 你的代码将被嵌在这里 */

  Sample input:

• 10
  5 8 6 2 4 1 0 10 9 7
  5
  6 3 10 0 5
  5
  5 7 0 10 3

  Sample output:

• Preorder: 5 2 1 0 4 8 6 7 10 9
  6 is found
  3 is not found
  10 is found
  10 is the largest key
  0 is found
  0 is the smallest key
  5 is found
  Not Found
  Inorder: 1 2 4 6 8 9

  Subject to answer:

• BinTree Insert(BinTree BST, ElementType X)
  {
      if (BST == NULL)
      {
          BST = (BinTree)malloc(sizeof(BinTree));
          BST->Data = X;
          BST->Left = NULL;
          BST->Right = NULL;
      }
      if (X > BST->Data)
          BST->Right = Insert(BST->Right, X);
      if (X < BST->Data)
          BST->Left = Insert(BST->Left, X);
      return BST;
  }
  
  // 函数Delete将X从二叉搜索树BST中删除，并返回结果树的根结点指针；
  //如果X不在树中，则打印一行Not Found并返回原树的根结点指针；
  BinTree Delete(BinTree BST, ElementType X)
  {
      if (BST == NULL)
      {
          printf("Not Found\n");
          return NULL;
      }
  
      if (X > BST->Data)
      {
      	BST->Right = Delete(BST->Right, X);
  	}     
      else if (X < BST->Data)
      {
  		BST->Left = Delete(BST->Left, X);
  	}
      else if (X == BST->Data)
      {
          Position node;
          if (BST->Left && BST->Right)
          {
              node = FindMin(BST->Right);
              BST->Data = node->Data;
              BST->Right = Delete(BST->Right, BST->Data);
          }
          else
          {
              node = BST;
              if (BST->Left == NULL)
                  BST = BST->Right;
              else if (BST->Right == NULL)
                  BST = BST->Left;
              free(node);
          }
      }
      return BST;
  }
  
  //函数Find在二叉搜索树BST中找到X，返回该结点的指针；
  //如果找不到则返回空指针；
  Position Find(BinTree BST, ElementType X)
  {
      while (BST)
      {
          if (X == BST->Data)
              return BST;
          else if (X < BST->Data)
              BST = BST->Left;
          else if (X > BST->Data)
              BST = BST->Right;
      }
      return NULL;
  }
  
  //函数FindMin返回二叉搜索树BST中最小元结点的指针；
  Position FindMin(BinTree BST)
  {
      if (BST == NULL)
          return NULL;
      while (BST->Left)
          BST = BST->Left;
      return BST;
  }
  
  //函数FindMax返回二叉搜索树BST中最大元结点的指针。
  Position FindMax(BinTree BST)
  {
      if (BST == NULL)
          return NULL;
      while (BST->Right)
          BST = BST->Right;
      return BST;
  }