完全二叉树

2024年8月28日 | 阅读 21 分钟

完全二叉树是一种满足特定条件的二叉树。这些条件是：

完全二叉树中的每一层都应该是完全填充的，只有最后一层除外。某一层的完全填充意味着该层中的每个父节点都应该有两个子节点，即左节点和右节点。如果某一层的任何父节点没有右子节点和左子节点，则不被认为是完全填充的。
二叉树要被称为完全二叉树，还需要满足的另一个条件是，树的最后一层中的所有键都应尽可能靠左。这意味着如果父节点出现在完全二叉树的最后一层，那么它应该只有一个左子节点。

如果任何二叉树满足上述两个特定条件，则该二叉树被标记为完全二叉树。

现在，为了更好地理解，让我们编写一个 C++ 代码来创建和显示完全二叉树。

代码

// a sample C++ program to create a complete binary tree and print the complete binary tree 

#include <iostream>
#include <bits/stdc++.h>
using namespace std;

// A macro named SIZE is defined with a value of 50 that will represent the size of the queue that will be required for the various operations
#define SIZE 50

// A class named node is created that will act as a single node of the complete binary tree 
class node{


	public:
	
	// a variable named data of integer type is created that will hold the data that is present in that particular node of the complete binary tree
	int data;

	// two variables named right and left of the node type are created that will be used to hold the addresses of the right child node and the left child node of a parent node present on the complete binary tree
	node *right,*left;
}; // end of node class

// A class named Queue is created that provide all the utilities of the Queue class
class Queue
{
	public:
	int front, rear;
	int size;
	node**array;
};

// A utility function named newNode with one parameter of integer type holding the data is created that will be used to add a new node to the complete binary tree
node* newNode(int data) {

	// logic of adding a new node to the complete binary tree
	node* temp = new node();
	temp->data = data;
	temp->left = temp->right = NULL;
	return temp;
}

// A utility function named createQueue is written that will be used to create a new Queue
Queue* createQueue(int size){


	Queue* queue = new Queue();

	queue->front = queue->rear = -1;
	queue->size = size;

	queue->array = new node*[queue->size * sizeof( node* )];

	int i;

	// all the elements in the Queue object are initialized with NULL
	for (i = 0; i < size; ++i)
		queue->array[i] = NULL;

	// And in the end an object of the Queue is returned
	return queue;
}

// A function named isEmpty is created to check whether the Queue object that is passed as a parameter is Empty or not
int isEmpty(Queue* queue){

	return queue->front == -1;
}



// A function named isFull is created to check whether the Queue object that is passed as a paramter is full or not
int isFull(Queue* queue){ 
	return queue->rear == queue->size - 1;
}


// A function named hasOnlyOneItem is created to check whether the Queue object that is passed as a paramter has one element or more
int hasOnlyOneItem(Queue* queue){ 
	return queue->front == queue->rear; 
}

// A function named Enqueue is created to add data to the Queue object that is passed as a parameter
void Enqueue(node *root, Queue* queue)
{
	if (isFull(queue))
		return;

	queue->array[++queue->rear] = root;

	if (isEmpty(queue))
		++queue->front;
}

// A function named Dequeue is created to remove data from the Queue object that is passed as a parameter
node* Dequeue(Queue* queue)
{
	if (isEmpty(queue))
		return NULL;

	node* temp = queue->array[queue->front];

	if (hasOnlyOneItem(queue))
		queue->front = queue->rear = -1;
	else
		++queue->front;

	return temp;
}

// A function named getFront is written to get the front element from the Queue object that is passed as a paramter 
node* getFront(Queue* queue){ 
	return queue->array[queue->front]; 
}

// A utility function named hasBothChild is written to check whether the particular node has both the children nodes present or not
int hasBothChild(node* temp)
{
	return temp && temp->left && temp->right;
}

// A Function named insert is written that will be used to insert a new node in the complete binary tree
void insert(node **root, int data, Queue* queue)
{
	// Create a new node for given data
	node *temp = newNode(data);

	// If the tree is empty, initialize the root with new node.
	if (!*root)
		*root = temp;

	else
	{
		// get the front node of the queue.
		node* front = getFront(queue);

		// If the left child of this front node doesn't exist, set the
		// left child as the new node
		if (!front->left)
			front->left = temp;

		// If the right child of this front node doesn't exist, set the
		// right child as the new node
		else if (!front->right)
			front->right = temp;

		// If the front node has both the left child and right child,
		// Dequeue() it.
		if (hasBothChild(front))
			Dequeue(queue);
	}

	// Enqueue() the new node for later insertions
	Enqueue(temp, queue);
}

// Standard level order traversal to test above function
// This function will the data associated with all the nodes of the complete binary tree
void levelOrder(node* root)
{
	Queue* queue = createQueue(SIZE);

	Enqueue(root, queue);

	while (!isEmpty(queue))
	{
		node* temp = Dequeue(queue);

		cout<<temp->data<<" ";

		if (temp->left){
			Enqueue(temp->left, queue);
			// cout<<"\n";
		}

		if (temp->right){
			Enqueue(temp->right, queue);
			// cout<<"\n";
		}
	}
}

// main function is written to call all these functions and check the functionalities
int main()
{
	node* root = NULL;
	Queue* queue = createQueue(SIZE);
	

	char ch;

            // Do-while loop
            // Do part for performing actions
            do
            // Menu is displayed
            // Users enter 'y' to continue 'n' if
            // entered by user , the program terminates

            {
                  // Menu
                  // Display messages
                  cout<<"Please Choose one of the Operations::"<<endl;
                  cout<<"1. To Insert Data in the Complete binary tree."<<endl;
                  cout<<"2. To Display Data from the Complete binary tree."<<endl;
                  cout<<"\n";
                  

                  int choice;
                  cin>>choice;

                  // Switch case
                  switch (choice) {

                  // Case 1
                  case 1:

                        // Display message
                        cout<<"Enter the data that you want to add to the Complete binary tree::"<<endl;
                        int key;
                        cin>>key;
                        insert(&root,key,queue);
                        cout<<"Data Added Successfully."<<endl;
                        // Break statement to terminate a case
                        break;

                  // Case 2
                  case 2:

                        // Display message
                        cout<<"Contents of the Complete binary tree are::"<<endl;
                        levelOrder(root);
                        // Break statement to terminate a case
                        break;

                  default:
                        // Print statement
                        cout<<"Please enter a valid option from the menu to proceed further.\n "<<endl;
                        // Break statement
                        break;
                  }


                  cout<<"\nType [N or n] to terminate the program.\nType [Y or y] to continue the program.\n";
                  cin>>ch;
                  
            } while (!(ch == 'N' || ch == 'n'));



	return 0;
}
//end of the main function

输出

Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.

1
Enter the data that you want to add to the Complete binary tree::
12      
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.

1
Enter the data that you want to add to the Complete binary tree::
14
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.

1 
Enter the data that you want to add to the Complete binary tree::
16     
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.

1
Enter the data that you want to add to the Complete binary tree::
18
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.

1
Enter the data that you want to add to the Complete binary tree::
15
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.

1
Enter the data that you want to add to the Complete binary tree::
24
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.

2
Contents of the Complete binary tree are::
12 14 16 18 15 24 
Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
N

因此，在我们上面编写和执行的 C++ 程序中，我们提供了一种菜单驱动的方法来向完全二叉树添加数据，并通过打印完全二叉树中存在的数据来验证添加操作。

这里我们首先通过调用 insert 函数向完全二叉树添加了六个节点，该函数将向现有的完全二叉树添加或追加一个新节点。这些完全二叉树新节点的值由用户在向完全二叉树添加节点时输入。因此，用户输入菜单中显示的任何选项，操作都成功执行。

那么，现在让我们用 Java 编程语言编写完全二叉树的代码。

代码

// a sample Java program to create a complete binary tree and print the complete binary tree 


// From the package named util the Scanner class is imported in order to get input from the user from the console
import java.util.Scanner;

// A class named Tree is created that will act as the complete binary tree 
class Tree {

	// An object of the Node class named root is created that will act as the root of the complete binary tree
	Node root;

	// A static inner class named Node is created that will act as a single node of the complete binary tree
	static class Node {

		// A variable named data of integer type is created that will be used to store the actual data in each node of the complete binary tree 
		int data;

		// two variables named right and left of the node type are created that will be used to hold the addresses of the right child node and the left child node of a parent node present on the complete binary tree
		Node left, right;

		// A constructor of the Node class with one paramter of integer type holding the data is created that will be used to add a new node to the complete binary tree
		Node(int data)
		{
			this.data = data;
			this.left = null;
			this.right = null;
		}
	} // end of the inner class Node



	// A Function named insertLevelOrder is created to add the elements of the array to the nodes of the complete binary tree
	public Node insertLevelOrder(int[] arr, Node root,int i)
	{
		// Base case for recursion
		if (i < arr.length) {
			Node temp = new Node(arr[i]);
			root = temp;

			// insert left child
			root.left = insertLevelOrder(arr, root.left,2 * i + 1);

			// insert right child
			root.right = insertLevelOrder(arr, root.right,2 * i + 2);
		}
		return root;
	}

	// A Function named inOrder with one parameter of the Node type that is the root of the complete binary tree is passed to this function
	// that will be used to print all the nodes in the complete binary tree in inOrder fashion.
	public void inOrder(Node root)
	{
		if (root != null) {
			inOrder(root.left);
			System.out.print(root.data + " ");
			inOrder(root.right);
		}
	}

}//end of the Tree class


// A main Class is written to call all the fucntions of the Tree class
class Main{

	// main function
	public static void main(String args[])
	{

		// an object of the Tree class is created that will be used to call all the functions of the Tree class
		Tree t2 = new Tree();
		int arr[] = new int[8]; //{ 1, 2, 3, 4, 5, 6, 6, 6, 6 };
		int index=0;
		Scanner sc = new Scanner(System.in);

		char ch;

            // Do-while loop
            // Do part for performing actions
            do
            // Menu is displayed
            // Users enter 'y' to continue 'n' if
            // entered by user , the program terminates

            {
                  // Menu
                  // Display messages
                  System.out.print("Please Choose one of the Operations from the menu Displayed below::");
                  System.out.print("\n");
                  System.out.print("1. To Insert Data in the Complete binary tree.");
                  System.out.print("\n");
                  System.out.print("2. To Display Data from the Complete binary tree.");
                  System.out.print("\n");
                  

                  int choice;
                  choice = sc.nextInt();

                  // Switch case
                  switch (choice) {

                  // Case 1
                  case 1:

                        // Display message
                        System.out.print("Enter the data that you want to add to the Complete binary tree::");
                        System.out.print("\n");
                        int key;
                        key=sc.nextInt();
                        arr[index] =key;
                        index = index + 1;
                        System.out.print("Data Added Successfully.");
                        System.out.print("\n");
                        // Break statement to terminate a case
                        break;

                  // Case 2
                  case 2:

                        // Display message
                        System.out.print("Contents of the Complete binary tree are::");
                        System.out.print("\n");
                        t2.root = t2.insertLevelOrder(arr, t2.root, 0);
                       	t2.inOrder(t2.root);
                        // Break statement to terminate a case
                        break;

                  default:
                        // Print statement
                        System.out.print("Please enter a valid option from the menu to proceed further.");
                        System.out.print("\n");
                        // Break statement
                        break;
                  }

                  System.out.print("\n");
                  System.out.print("Type [N or n] to terminate the program.");
                  System.out.print("\n");
                  System.out.print("Type [Y or y] to continue the program.");
                  System.out.print("\n");
                  sc.nextLine();
                  ch = sc.nextLine().charAt(0);
                  
            } while (!(ch == 'N' || ch == 'n'));


	}
} // end of the main class 

输出

Please Choose one of the Operations from the menu Displayed below::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.
1
Enter the data that you want to add to the Complete binary tree::
11
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations from the menu Displayed below::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.
1
Enter the data that you want to add to the Complete binary tree::
23
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations from the menu Displayed below::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.
1 
Enter the data that you want to add to the Complete binary tree::
16
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations from the menu Displayed below::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.
1
Enter the data that you want to add to the Complete binary tree::
76
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations from the menu Displayed below::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.
1
Enter the data that you want to add to the Complete binary tree::
43
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations from the menu Displayed below::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.
1
Enter the data that you want to add to the Complete binary tree::
33
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations from the menu Displayed below::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.
1
Enter the data that you want to add to the Complete binary tree::
92
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations from the menu Displayed below::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.
1
Enter the data that you want to add to the Complete binary tree::
31
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
y
Please Choose one of the Operations from the menu Displayed below::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.
2
Contents of the Complete binary tree are::
31 76 23 43 11 33 16 92 
Type [N or n] to terminate the program.
Type [Y or y] to continue the program.
n

因此，在我们上面编写和执行的 Java 程序中，我们提供了一种菜单驱动的方法来向完全二叉树添加数据，它将提供两个功能；一个用于向完全二叉树添加数据，另一个功能则可以帮助我们通过打印完全二叉树中存在的数据来验证添加操作。

这里，我们首先通过调用 insert 函数向完全二叉树添加了八个节点，它们的值分别为 31、76、23、43、11、33、16 和 92。该函数将向现有的完全二叉树添加或追加一个新节点，但如果将要添加的节点是第一个节点，它将创建一个新的完全二叉树作为完全二叉树的根。这些完全二叉树新节点的值由用户在向完全二叉树添加节点时输入，并作为参数传递给 insert 函数中的完全二叉树的 add 函数。因此，用户输入菜单中显示的任何选项，操作都成功执行。如果用户输入的选项不是指定的任何操作，则会显示错误消息“请从菜单中输入有效选项以继续。”。为了退出程序，用户需要输入“N”或“n”，为了继续程序以获取更多选项，用户输入“Y”或“y”。

那么，现在让我们用 Python 编程语言编写完全二叉树的代码。

代码

# a sample Java program to create a complete binary tree and print the complete binary tree 


# A global variable named SIZE is defined with a value of 50 that will represent the size of the queue that will be required for the various operations
SIZE = 50


# A class named node is created that will acts a single node of the complete binary tree 
class node:
	
	# A constructor of the Node class with one paramter of integer type holding the data is created that will be used to add a new node to the complete binary tree	
	def __init__(self, data):
	
		self.data = data
		self.right = None
		self.left = None

# A class named Queue is created that provide all the utilities of the Queue class
class Queue:
	
	def __init__(self):
	
		self.front = None
		self.rear = None
		self.size = 0
		self.array = []


# A utility function named newNode with one paramter of integer type holding the data is created that will be used to add a new node to the complete binary tree
def newNode(data):
	
	# logic of adding a new node to the complete binary tree
	temp = node(data)
	return temp

# A utility function named createQueue is written that will be used to create a new Queue
def createQueue(size):
	
	global queue
	queue = Queue();
	queue.front = queue.rear = -1;
	queue.size = size;

	# all the elements in the Queue object are initialized with NULL
	queue.array = [None for i in range(size)]

	# And in the end an object of the Queue is returned
	return queue;
	
# A function named isEmpty is created to check whether the Queue object that is passed as a paramter is Empty or not
def isEmpty(queue):

	return queue.front == -1


# A function named isFull is created to check whether the Queue object that is passed as a paramter is full or not
def isFull(queue):
	
	return queue.rear == queue.size - 1;


# A function named hasOnlyOneItem is created to check whether the Queue object that is passed as a paramter has one element or more
def hasOnlyOneItem(queue):
	
	return queue.front == queue.rear;

# A function named Enqueue is created to add data to the Queue object that is passed as a paramter and root of the complete binary tree
def Enqueue(root):

	if (isFull(queue)):
		return;
	
	queue.rear+=1
	queue.array[queue.rear] = root;

	if (isEmpty(queue)):
		queue.front+=1;


# A function named Dequeue is created to remove data from the Queue object that is passed as a paramter
def Dequeue():

	if (isEmpty(queue)):
		return None;

	temp = queue.array[queue.front];

	if(hasOnlyOneItem(queue)):
		queue.front = queue.rear = -1;
	else:
		queue.front+=1

	return temp;

# A function named getFront is written to get the front element from the Queue object that is passed as a paramter 
def getFront(queue):
	
	return queue.array[queue.front];


#  A utility function named hasBothChild is written to check whether the a particular node has both the children nodes present or not
def hasBothChild(temp):

	return (temp and temp.left and
			temp.right);
	

#  A Function named insert is written that will be used to insert a new node in complete binary tree
def insert(root, data, queue):

	# Create a new node for
	# given data
	temp = newNode(data);

	# If the tree is empty,
	# initialize the root
	# with new node.
	if not root:
		root = temp;
	else:
	
		# get the front node of
		# the queue.
		front = getFront(queue);

		# If the left child of this
		# front node doesn't exist,
		# set the left child as the
		# new node
		if (not front.left):
			front.left = temp;

		# If the right child of this
		# front node doesn't exist, set
		# the right child as the new node
		elif (not front.right):
			front.right = temp;

		# If the front node has both the
		# left child and right child,
		# Dequeue() it.
		if (hasBothChild(front)):
			Dequeue();

	# Enqueue() the new node for
	# later insertions
	Enqueue(temp);
	return root

# Standard level order traversal to test above function
# This function will the data associated with all the nodes of the complete binary tree
def levelOrder(root):

	queue = createQueue(SIZE);
	Enqueue(root);
	
	while (not isEmpty(queue)):
		temp = Dequeue();		
		print(temp.data, end = ' ')
		if (temp.left):
			Enqueue(temp.left);
		if (temp.right):
			Enqueue(temp.right);

# main function
def main():

	root = None

	queue = createQueue(SIZE)


	while(True):

    	# Menu
        # Display messages
		print("Please Choose one of the Operations::")
		print("1. To Insert Data in the Complete binary tree.")
		print("2. To Display Data from the Complete binary tree.")
		print("\n")
                  
		choice = int(input())

		# case 1
		if choice==1:
			# Display message
			print("Enter the data that you want to add to the Complete binary tree::")
			key = int(input())
			root=insert(root, key, queue);
			print("Data Added Successfully.")
	        # Break statement to terminate a case
			# break

		# Case 2
		if choice == 2:
			# Display message
			print("Contents of the Complete binary tree are::")
			levelOrder(root);
			# Break statement to terminate a case
			# break

                  

		print("\nType [N or n] to terminate the program.\nType [Y or y] to continue the program.\n")
		ch=input()
                  
		if ((ch == 'N' or ch == 'n')):
			break


# call to the main function
if __name__ == "__main__":
	
	main()

输出

Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.


1
Enter the data that you want to add to the Complete binary tree::
23
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.


1
Enter the data that you want to add to the Complete binary tree::
76
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.


1
Enter the data that you want to add to the Complete binary tree::
42
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.


1
Enter the data that you want to add to the Complete binary tree::
11
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.


30

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.


1
Enter the data that you want to add to the Complete binary tree::
56
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.


1
Enter the data that you want to add to the Complete binary tree::
68
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.


1
Enter the data that you want to add to the Complete binary tree::
03
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.


1
Enter the data that you want to add to the Complete binary tree::
44
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.


1
Enter the data that you want to add to the Complete binary tree::
17
Data Added Successfully.

1
Enter the data that you want to add to the Complete binary tree::
28
Data Added Successfully.

Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

y
Please Choose one of the Operations::
1. To Insert Data in the Complete binary tree.
2. To Display Data from the Complete binary tree.


2
Contents of the Complete binary tree are::
23 76 42 11 56 68 3 44 17 28
Type [N or n] to terminate the program.
Type [Y or y] to continue the program.

N

因此，在我们上面编写和执行的 Python 程序中，我们提供了一种菜单驱动的方法来向完全二叉树添加数据，它将提供两个功能；一个用于向完全二叉树添加数据，另一个功能则可以帮助我们通过打印完全二叉树中存在的数据来验证添加操作。

这里我们首先通过调用 insert 函数向完全二叉树添加节点，该函数将向现有的完全二叉树添加或追加一个新节点，但如果将要添加的节点是第一个节点，它将创建一个新的完全二叉树作为完全二叉树的根。这些完全二叉树新节点的值由用户在向完全二叉树添加节点时输入，并作为参数传递给 insert 函数中的完全二叉树的 add 函数。因此，用户输入菜单中显示的任何选项，操作都成功执行。如果用户输入的选项不是指定的任何操作，则会显示错误消息“请从菜单中输入有效选项以继续。”。为了退出程序，用户需要输入“N”或“n”，为了继续程序以获取更多选项，用户输入“Y”或“y”。

因此，本文解释了完全二叉树数据结构以及我们可以在完全二叉树上执行的基本函数或操作。我们还了解了完全二叉树在 Java、Python 和 C++ 等各种编程语言中的使用，以及在这些数据结构上执行基本操作所需的功能。除了这些示例，在各种场景中我们都可以使用完全二叉树。

下一主题线索二叉树

完全二叉树

代码

代码

代码

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

数据结构教程

DS 数组

DS 链表

DS 栈

DS 队列

DS 树

DS 图

DS 搜索

DS 排序

哈希与堆

差异

二叉树

二叉搜索树

AVL 树

单向链表

双向链表

循环链表

循环双向链表

DS 选择题

其他

完全二叉树

代码

代码

代码

相关帖子

最大异或

最长回文子串

迭代电话号码的字母组合

数组的平衡索引

循环链表导论和应用

安全消息编码

Hopcroft-Karp 算法用于最大匹配

数据结构中的 K-D 树

梳排序和希尔排序的区别

堆和堆的关系是什么

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器