给定一个整数数组，任务是找到将这些整数添加到AVL树中的顺序，从而无需旋转即可平衡该树。
例子 ：
Input : array = {1, 2, 3}
Output : 2 1 3
Input : array = {2, 4, 1, 3, 5, 6, 7}
Output : 4 2 6 1 3 5 7
方法 ：
- 对给定的整数数组进行排序。
- 按照此处介绍的方法从排序后的数组中创建AVL树。
- 现在，找到树的级别顺序遍历，这是必需的序列。
- 在上一步中找到的顺序中添加数字将始终保持树中所有节点的高度平衡属性。
下面是上述方法的实现：
C++
// C++ implementation of the approach
#include
using namespace std;
/* A Binary Tree node */
struct TNode {
int data;
struct TNode* left;
struct TNode* right;
};
struct TNode* newNode(int data);
/* Function to construct AVL tree
from a sorted array */
struct TNode* sortedArrayToBST(int arr[], int start, int end)
{
/* Base Case */
if (start > end)
return NULL;
/* Get the middle element
and make it root */
int mid = (start + end) / 2;
struct TNode* root = newNode(arr[mid]);
/* Recursively construct the
left subtree and make it
left child of root */
root->left = sortedArrayToBST(arr, start, mid - 1);
/* Recursively construct the
right subtree and make it
right child of root */
root->right = sortedArrayToBST(arr, mid + 1, end);
return root;
}
/* Helper function that allocates
a new node with the given data
and NULL to the left and
the right pointers. */
struct TNode* newNode(int data)
{
struct TNode* node = (struct TNode*)
malloc(sizeof(struct TNode));
node->data = data;
node->left = NULL;
node->right = NULL;
return node;
}
// This function is used for testing purpose
void printLevelOrder(TNode *root)
{
if (root == NULL) return;
queue q;
q.push(root);
while (q.empty() == false)
{
TNode *node = q.front();
cout << node->data << " ";
q.pop();
if (node->left != NULL)
q.push(node->left);
if (node->right != NULL)
q.push(node->right);
}
}
/* Driver program to
test above functions */
int main()
{
// Assuming the array is sorted
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
int n = sizeof(arr) / sizeof(arr[0]);
/* Convert List to AVL tree */
struct TNode* root = sortedArrayToBST(arr, 0, n - 1);
printLevelOrder(root);
return 0;
} Java
// Java implementation of the approach
import java.util.*;
class solution
{
/* A Binary Tree node */
static class TNode {
int data;
TNode left;
TNode right;
}
/* Function to con AVL tree
from a sorted array */
static TNode sortedArrayToBST(int arr[], int start, int end)
{
/* Base Case */
if (start > end)
return null;
/* Get the middle element
and make it root */
int mid = (start + end) / 2;
TNode root = newNode(arr[mid]);
/* Recursively con the
left subtree and make it
left child of root */
root.left = sortedArrayToBST(arr, start, mid - 1);
/* Recursively con the
right subtree and make it
right child of root */
root.right = sortedArrayToBST(arr, mid + 1, end);
return root;
}
/* Helper function that allocates
a new node with the given data
and null to the left and
the right pointers. */
static TNode newNode(int data)
{
TNode node = new TNode();
node.data = data;
node.left = null;
node.right = null;
return node;
}
// This function is used for testing purpose
static void printLevelOrder(TNode root)
{
if (root == null) return;
Queue q= new LinkedList();
q.add(root);
while (q.size()>0)
{
TNode node = q.element();
System.out.print( node.data + " ");
q.remove();
if (node.left != null)
q.add(node.left);
if (node.right != null)
q.add(node.right);
}
}
/* Driver program to
test above functions */
public static void main(String args[])
{
// Assuming the array is sorted
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
int n = arr.length;
/* Convert List to AVL tree */
TNode root = sortedArrayToBST(arr, 0, n - 1);
printLevelOrder(root);
}
}
//contributed by Arnab Kundu Python3
# Python3 code to print order of
# insertion into AVL tree to
# ensure no rotations
# Tree Node
class Node:
def __init__(self, d):
self.data = d
self.left = None
self.right = None
# Function to convert sorted array
# to a balanced AVL Tree/BST
# Input : sorted array of integers
# Output: root node of balanced AVL Tree/BST
def sortedArrayToBST(arr):
if not arr:
return None
# Find middle and get its floor value
mid = int((len(arr)) / 2)
root = Node(arr[mid])
# Recursively construct the left
# and right subtree
root.left = sortedArrayToBST(arr[:mid])
root.right = sortedArrayToBST(arr[mid + 1:])
# Return the root of the
# constructed tree
return root
# A utility function to print the
# Level Order Traversal of AVL Tree
# using a Queue
def printLevelOrder(root):
if not root:
return
q = []
q.append(root)
# Keep printing the top element and
# adding to queue while it is not empty
while q != []:
node = q.pop(0)
print(node.data, end=" ")
# If left node exists, enqueue it
if node.left:
q.append(node.left)
# If right node exists, enqueue it
if node.right:
q.append(node.right)
# Driver Code
arr = [1, 2, 3, 4, 5, 6, 7]
root = sortedArrayToBST(arr)
printLevelOrder(root)
# This code is contributed
# by Adikar BharathC#
// C# implementation of the approach
using System;
using System.Collections.Generic;
class GFG
{
/* A Binary Tree node */
public class TNode
{
public int data;
public TNode left;
public TNode right;
}
/* Function to con AVL tree
from a sorted array */
static TNode sortedArrayToBST(int []arr,
int start, int end)
{
/* Base Case */
if (start > end)
return null;
/* Get the middle element
and make it root */
int mid = (start + end) / 2;
TNode root = newNode(arr[mid]);
/* Recursively con the
left subtree and make it
left child of root */
root.left = sortedArrayToBST(arr, start, mid - 1);
/* Recursively con the
right subtree and make it
right child of root */
root.right = sortedArrayToBST(arr, mid + 1, end);
return root;
}
/* Helper function that allocates
a new node with the given data
and null to the left and
the right pointers. */
static TNode newNode(int data)
{
TNode node = new TNode();
node.data = data;
node.left = null;
node.right = null;
return node;
}
// This function is used for testing purpose
static void printLevelOrder(TNode root)
{
if (root == null) return;
Queue q = new Queue();
q.Enqueue(root);
while (q.Count > 0)
{
TNode node = q.Peek();
Console.Write( node.data + " ");
q.Dequeue();
if (node.left != null)
q.Enqueue(node.left);
if (node.right != null)
q.Enqueue(node.right);
}
}
/* Driver code */
public static void Main()
{
// Assuming the array is sorted
int []arr = { 1, 2, 3, 4, 5, 6, 7 };
int n = arr.Length;
/* Convert List to AVL tree */
TNode root = sortedArrayToBST(arr, 0, n - 1);
printLevelOrder(root);
}
}
/* This code contributed by PrinciRaj1992 */ 输出：
4 2 6 1 3 5 7