【PAT甲级】1115 Counting Nodes in a BST (30分)：构造BST+DFS树的遍历

1115 Counting Nodes in a BST (30分)

A Binary Search Tree (BST) is recursively defined as a binary tree which has the following properties:

• The left subtree of a node contains only nodes with keys less than or equal to the node's key.
• The right subtree of a node contains only nodes with keys greater than the node's key.
• Both the left and right subtrees must also be binary search trees.

Insert a sequence of numbers into an initially empty binary search tree. Then you are supposed to count the total number of nodes in the lowest 2 levels of the resulting tree.

Input Specification:

Each input file contains one test case. For each case, the first line gives a positive integer N (≤1000) which is the size of the input sequence. Then given in the next line are the N integers in [−10001000] which are supposed to be inserted into an initially empty binary search tree.

Output Specification:

For each case, print in one line the numbers of nodes in the lowest 2 levels of the resulting tree in the format:

n1 + n2 = n

      
    

where n1 is the number of nodes in the lowest level, n2 is that of the level above, and n is the sum.

Sample Input:

9
25 30 42 16 20 20 35 -5 28

      
    

Sample Output:

2 + 4 = 6

分析：构造BST+DFS树的遍历

构造BST，计算倒数两层节点的总个数

代码

• 柳神

  1.一边输入数据一边构造BST，能使代码量变少

  2.不需要记录每个节点的层数，depth作为函数的参数，在DFS遍历时记录num[]和最大深度maxDepth，最后得到num[maxDepth-1]和num[maxDepth-2]即可。

  3.注意最后一层是maxDepth-1，因为比较depth和maxDepth谁更大时的depth比实际多+1（此时root==NULL)。

  #include <iostream>
  #include <vector>
  using namespace std;
  struct node {
      int v;
      struct node *left, *right;
  };
  node* build(node *root, int v) {
      if(root == NULL) {
          root = new node();
          root->v = v;
          root->left = root->right = NULL;
      } else if(v <= root->v)
          root->left = build(root->left, v);
      else
          root->right = build(root->right, v);
      return root;
  }
  vector<int> num(1000);
  int maxdepth = -1;
  void dfs(node *root, int depth) {
      if(root == NULL) {
          maxdepth = max(depth, maxdepth);
          return ;
      }
      num[depth]++;
      dfs(root->left, depth + 1);
      dfs(root->right, depth + 1);
      
  }
  int main() {
      int n, t;
      scanf("%d", &n);
      node *root = NULL;
      for(int i = 0; i < n; i++) {
          scanf("%d", &t);
          root = build(root, t);
      }
      dfs(root, 0);
      printf("%d + %d = %d", num[maxdepth-1], num[maxdepth-2], num[maxdepth-1] + num[maxdepth-2]);
      return 0;
  }
  

  
  

• 我的做法（不太简洁）

  /*构造BST，计算倒数两层节点的总个数*/
  
  #include<iostream>
  
  using namespace std;
  
  const int maxN=1010;
  struct node {
  	int dt;//数据
  	int layer;//所在层数
  	node* lchild;
  	node* rchild;
  };
  int num[maxN];//记录每层节点的个数
  int maxLayer=-1;//节点的最深层数
  int N;
  
  /*构造树*/
  //创建新节点
  node* newNode(int d) {
  	node* Node=new node;//申请一个node型变量的地址空间
  	Node->dt=d;
  	Node->lchild=NULL;
  	Node->rchild=NULL;
  
  	return Node;
  }
  //插入节点
  void insert(node* &root,int d) {
  	if(root==NULL) {//若某个节点没有左、右孩子，则将data作为它的孩子
  		root=newNode(d);
  		return;
  	}
  	if(d<=root->dt) { //去左子树
  		insert(root->lchild,d);
  	} else//去右子树
  		insert(root->rchild,d);
  
  }
  //构造BST
  node* create(int data[],int n) {//data节点数据，n节点个数
  	node* root=newNode(data[0]);//创建根节点
  
  	for(int i=1; i<n; i++) {//根节点已经创建了，从1开始！
  		insert(root,data[i]);
  	}
  
  	return root;
  }
  
  /*DFS遍历树，记录每个节点层数和每层节点个数*/
  void DFS(node* root) {
  	if(root->layer>maxLayer)
  		maxLayer= root->layer;
  
  	num[root->layer]++;
  	if(root->lchild!=NULL) {
  		root->lchild->layer=root->layer+1;
  		DFS(root->lchild);
  	}
  	if(root->rchild!=NULL) {
  		root->rchild->layer=root->layer+1;
  		DFS(root->rchild);
  	}
  }
  
  int main() {
  	fill(num,num+maxN,0);
  	scanf("%d",&N);
  	int data[N];
  	for(int i=0; i<N; i++) {
  		scanf("%d",&data[i]);
  	}
  
  	node* root=create(data,N);
  	root->layer=0;//根节点层数为0
  	DFS(root);
  
  	printf("%d + %d = %d",num[maxLayer],num[maxLayer-1],num[maxLayer]+num[maxLayer-1]);
  }
  

小知识

• （与本题无关）有关结构体struct：

  • 定义结构体时，不能定义自身类型的变量（会导致循环定义），但可以定义自身类型的指针变量。
  • 另外声明结构体变量的两种方法

  #include<iostream>
  
  using namespace std;
  
  struct node {
  	int data;
  	node* child;//不能定义node,但可以定义node*
  };
  
  int main() {
  	/*方一*/
  	node* childN=new node();
  	childN->data=2;
  	cout<<childN->data<<endl;
  	
  	/*方二*/
  //	struct node childN;
  //	childN.data=2;
  //	cout<<childN.data<<endl;
  
  	return 0;
  }
  

• 选择更大的数并返回：max(x,y)

• Java里有NULL和null，C++里只有NULL！！

备错本

• [1115 Counting Nodes in a BST：LIU]

  • build函数内，为root声明变量地址root =new node();，不需要node* root =new node();，这样是重新声明另一个变量。

    node* build(node* &root,int v) {
    	if(root==NULL) {
    		root =new node();//声明节点变量
    		root->data=v;
    		root->lchild=root->rchild=NULL;
    	} else if(v<=root->data) { //左子树
    		root->lchild=build(root->lchild,v);
    	} else { //右子树
    		root->rchild=build(root->rchild,v);
    	}
    
    	return root;
    }
    

    //main函数
    node* root=NULL;
    for(int i=0; i<N; i++) {
        scanf("%d",&v);
        root=build(root,v);
    }
    

    
    

• [1115 Counting Nodes in a BST：我的做法]

  • create()先创建根节点，之后循环插入其他节点时，注意data[]下标是从1开始的。我错写成从0开始，结果在root=25的左孩子又插入了一边25。

    //插入节点
    void insert(node* &root,int d) {
    	if(root==NULL) {//若某个节点没有左、右孩子，则将data作为它的孩子
    		root=newNode(d);
    		return;
    	}
    	if(d<=root->dt) { //去左子树
    		insert(root->lchild,d);
    	} else//去右子树
    		insert(root->rchild,d);
    
    }
    //构造BST
    node* create(int data[],int n) {//data节点数据，n节点个数
    	node* root=newNode(data[0]);//创建根节点
    //	cout<<"root.data="<<root->dt<<endl;
    	if(root==NULL) {
    		cout<<"root是空的"<<endl;
    	}
    
    	for(int i=1; i<n; i++) {//根节点已经创建了，从1开始！ 
    		insert(root,data[i]);
    	}
    
    	return root;
    }