我在尝试编写一个平衡二叉树函数balance_bst(bstNode root)，但是我在实现时遇到了困难。
我把这个函数实现成了一个模板函数，因为我的bstNode类也是一个模板类。
以下是我代码的一部分：
template<class Item, class Key>
class bstNode{
public:
//Constructor
bstNode(const Item& init_data = Item(), const Key& init_key = Key(), bstNode<Item, Key>* l_child = NULL, bstNode<Item, Key>* r_child = NULL){
data_field = init_data;
key_field = init_key;
l_ptr = l_child;
r_ptr = r_child;
}
//Destructor
~bstNode(){
data_field = 0;
key_field = 0;
l_ptr = r_ptr = NULL;
}
//Basic Member Functions
bstNode<Item, Key>*& left( ) { return l_ptr; } //returns left child pointer by reference
bstNode<Item, Key>*& right( ) { return r_ptr; } //returns right child pointer by reference
bstNode<Item, Key>* left( ) const { return l_ptr; } //returns left child pointer by reference
bstNode<Item, Key>* right( ) const { return r_ptr; } //returns right child pointer by reference
const Item& data() const{ return data_field; } //returns reference to data_field
const Key& key()const { return key_field; }
Item& data() { return data_field; } //returns reference to data_field
Key& key() { return key_field; }
void set_data(const Item& new_data){ data_field = new_data; } //sets data_field to new_data
void set_key(const Key& new_key){ key_field = new_key; } //sets key_field to new_key
void set_left(bstNode* new_left){ l_ptr = new_left; } //sets left child pointer to new_left
void set_right(bstNode* new_right){ r_ptr = new_right; } //sets right child pointer to new_right
private:
bstNode<Item, Key> *l_ptr, //pointer to left child node
*r_ptr; //pointer to right child node
Item data_field;
Key key_field;
};
template<class Item, class Key>
void balance_bst(bstNode<Item, Key>*& root){ //unfinished
std::vector< bstNode<Item, Key>* > nodes;
sorter(root, nodes);
size_t i = nodes.size()/2; //size() divided by 2 will yield
//index of middle element of vector for
//odd-isized arrays and the greater of the
//middle two elements for an even-sized array
while(i>=0){
root->set_key(nodes[i]->key());
root->set_data(nodes[i]->data());
//.....MORE CODE HERE: recursive call??
}
}
template<class Item, class Key>
void sorter(bstNode<Item, Key>*& root, std::vector<bstNode<Item, Key>* >& tree_nodes){
if(root == NULL)
return;
sorter(root->left(), tree_nodes);
tree_nodes.push_back(root);
sorter(root->right(), tree_nodes);
}
我一直在尝试修改 balance_bst 函数，我认为递归是显而易见的解决方案，但我似乎无法理清这个问题的思路...
sorter 基本上使用中序处理算法将 BST 的元素插入到向量中。只要 "root" 是指向二叉搜索树的根节点的指针(即所有节点的关键值小于节点的左子树的关键值，并且所有节点的关键值大于节点的右子树的关键值)，那么插入到向量中的节点将按升序排列。
然后，为了创建一个平衡的树，我将向量的中心节点插入到树的根部，然后应该能够递归地插入左右子节点，这些子节点将位于向量左半部分和右半部分的中间位置。
注意：我知道这是使用整数除法，比如 7/2=3，这将是一个大小为 7 的数组中间元素的索引。 对于偶数大小的数组，上面实现的算法将找到向量中两个中间元素中较大的元素的索引。
总之，欢迎并鼓励任何建议或观察！ 预先感谢。
编辑：我的问题是如何实现平衡二叉搜索树的函数？ (一个平衡的 BST 是在给定节点数量的情况下具有它所能达到的最小深度。)