算法导论9.1-1习题解答(二叉树)

CLRS 9.1-1 :

证明：在最坏情况下，利用n + [lgn] - 2此比较，即可找到n个元素中的第2小元素。（提示：同时找最小元素)

算法思想：

1.将数组中的元素分组，每组两个元素，然后比较每组中的两个元素得到最小值，重新得到包含原来一半元素的数组，继续重复上述过程，那么最后一个元素必然为最小值。如图所示，数组为{2, 1, 4, 3, 5}

2.上述过程形成的是一个二叉树，其中叶子节点都为数组元素，非叶子节点刚好4个，这是二叉树的性质。

3.然后我们来找第二小元素，第二小元素必然跟着1，首先赋值为5，然后再赋值为3， 然后赋值为2，即为所求。

PS：本章讨论的元素都互异，不存在相同值(见原书)

#include < iostream >
using  namespace std;
class Node
{
public :
  Node * left;
  Node * right;
  int data;
  Node();
  Node( int d);
};
class BinaryTree
{
public :
  Node * root;
  // 创建树
  void create_tree(Node ** node, int len);
  // 求最小值
  int min( int a, int b);
  // 寻找第二小值
  int search_second_small();
  BinaryTree();
};
int main()
{
  int arr[ 10 ] = { 89 , 123 , 7 , 9 , 2 , 5 , 25 , 8 , 43 , 23 };

  // 叶子节点
  Node ** node = new Node * [ 10 ];
  for ( int i = 0 ; i < 10 ; i ++ )
    node[i] = new Node(arr[i]);
  BinaryTree * bi_tree = new BinaryTree();
  bi_tree -> create_tree(node, 10 );
  cout << bi_tree -> root -> data << endl;
  cout << bi_tree -> search_second_small() << endl;
  return  0 ;
}
Node::Node()
{
  left = right = NULL;
}
Node::Node( int d)
{
  data = d;
  left = right = NULL;
}
void BinaryTree::create_tree(Node ** node, int len)
{
  // len == 2时，就剩下两个元素进行比较了，得到最后一个元素为root节点，即最小值节点
  if (len == 2 )
  {
    root -> left = node[ 0 ];
    root -> right = node[ 1 ];
    root -> data = min(node[ 0 ] -> data, node[ 1 ] -> data);
  }
  else
  {
    int new_len = (len % 2 ) ? (len / 2 + 1 ) : len / 2 ;
    Node ** new_node = new Node * [new_len];
    // new_node元素个数为奇数
    if (len % 2 )
    {
      for ( int i = 0 ; i < new_len - 1 ; i ++ )
      {
        // 构建父亲节点
        new_node[i] = new Node(min(node[ 2 * i] -> data, node[ 2 * i + 1 ] -> data));
        new_node[i] -> left = node[ 2 * i];
        new_node[i] -> right = node[ 2 * i + 1 ];
      }
      new_node[new_len - 1 ] = node[len - 1 ];
    }
    // new_node元素个数为偶数
    else
    {
      for ( int i = 0 ; i < new_len; i ++ )
      {
        // 构建父亲节点
        new_node[i] = new Node(min(node[ 2 * i] -> data, node[ 2 * i + 1 ] -> data));
        new_node[i] -> left = node[ 2 * i];
        new_node[i] -> right = node[ 2 * i + 1 ];
      }
    }
    create_tree(new_node, new_len);
    delete[] new_node;
  }
}
int BinaryTree::min( int a, int b)
{
  return a < b ? a : b;
}
int BinaryTree::search_second_small()
{
  int second = 1000000 ;
  Node * p = root;
  while (p -> left != NULL && p -> right != NULL)
  {
    if (p -> data == p -> left -> data && second > p -> right -> data)
    {
      second = p -> right -> data;
      p = p -> left;
    }
    else  if (p -> data == p -> right -> data && second > p -> left -> data)
    {
      second = p -> left -> data;
      p = p -> right;
    }
    else
      return second;
  }
  return second;
}
BinaryTree::BinaryTree()
{
  root =  new Node();
}