在文章中已经讨论了在BST中插入新节点的递归方法： SET 1.在这篇文章中，讨论了一种在BST中插入节点的迭代方法。
插入钥匙
始终在叶节点处插入一个新密钥。从根开始搜索密钥，直到我们找到叶子节点。找到叶节点后，将新节点添加为叶节点的子节点。
范例：
Input:To the given BST insert 40
Output:
Explanation:The new node 40 is a leaf node. Start searching from the root till a leaf node is hit, i.e while searching if a new value is greater than current node move to right child else to left child.
Input:To the given BST insert 600
Output:
Explanation:The new node 600 is a leaf node. Start searching from the root till a leaf node is hit, i.e while searching if a new value is greater than current node move to right child else to left child.
解决方案：
方法：
- 要注意的是，新密钥总是插入在叶子节点处。
- 从root开始并运行循环，直到到达空指针为止。
- 保留当前节点的前一个指针。
- 如果当前节点为null，则根据其值在该节点上创建新节点并将其插入，并使其成为父节点/上一节点的子节点之一。
- 如果当前节点的值小于新值，则移至当前节点的右子节点，否则移至左子节点。
下面是上述方法的实现：
C++
// C++ program to demonstrate insert operation
// in binary search tree
#include
using namespace std;
// BST node
struct Node {
int key;
struct Node *left, *right;
};
// Utitlity function to create a new node
Node* newNode(int data)
{
Node* temp = new Node;
temp->key = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}
// A utility function to insert a new
// Node with given key in BST
Node* insert(Node* root, int key)
{
// Create a new Node containing
// the new element
Node* newnode = newNode(key);
// Pointer to start traversing from root and
// traverses downward path to search
// where the new node to be inserted
Node* x = root;
// Pointer y maintains the trailing
// pointer of x
Node* y = NULL;
while (x != NULL) {
y = x;
if (key < x->key)
x = x->left;
else
x = x->right;
}
// If the root is NULL i.e the tree is empty
// The new node is the root node
if (y == NULL)
y = newnode;
// If the new key is less then the leaf node key
// Assign the new node to be its left child
else if (key < y->key)
y->left = newnode;
// else assign the new node its right child
else
y->right = newnode;
// Returns the pointer where the
// new node is inserted
return y;
}
// A utility function to do inorder
// traversal of BST
void Inorder(Node* root)
{
if (root == NULL)
return;
else {
Inorder(root->left);
cout << root->key << " ";
Inorder(root->right);
}
}
// Driver code
int main()
{
/* Let us create following BST
50
/ \
30 70
/ \ / \
20 40 60 80 */
Node* root = NULL;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
// Print inoder traversal of the BST
Inorder(root);
return 0;
} Java
// Java program to demonstrate insert operation
// in binary search tree
import java.util.*;
class solution
{
// BST node
static class Node {
int key;
Node left, right;
};
// Utitlity function to create a new node
static Node newNode(int data)
{
Node temp = new Node();
temp.key = data;
temp.left = null;
temp.right = null;
return temp;
}
// A utility function to insert a new
// Node with given key in BST
static Node insert(Node root, int key)
{
// Create a new Node containing
// the new element
Node newnode = newNode(key);
// Pointer to start traversing from root and
// traverses downward path to search
// where the new node to be inserted
Node x = root;
// Pointer y maintains the trailing
// pointer of x
Node y = null;
while (x != null) {
y = x;
if (key < x.key)
x = x.left;
else
x = x.right;
}
// If the root is null i.e the tree is empty
// The new node is the root node
if (y == null)
y = newnode;
// If the new key is less then the leaf node key
// Assign the new node to be its left child
else if (key < y.key)
y.left = newnode;
// else assign the new node its right child
else
y.right = newnode;
// Returns the pointer where the
// new node is inserted
return y;
}
// A utility function to do inorder
// traversal of BST
static void Inorder(Node root)
{
if (root == null)
return;
else {
Inorder(root.left);
System.out.print( root.key +" ");
Inorder(root.right);
}
}
// Driver code
public static void main(String args[])
{
/* Let us create following BST
50
/ \
30 70
/ \ / \
20 40 60 80 */
Node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
// Print inoder traversal of the BST
Inorder(root);
}
}
//contributed by Arnab KunduPython3
"""Python3 program to demonstrate insert
operation in binary search tree """
# A Binary Tree Node
# Utility function to create a
# new tree node
class newNode:
# Constructor to create a newNode
def __init__(self, data):
self.key= data
self.left = None
self.right = self.parent = None
# A utility function to insert a new
# Node with given key in BST
def insert(root, key):
# Create a new Node containing
# the new element
newnode = newNode(key)
# Pointer to start traversing from root
# and traverses downward path to search
# where the new node to be inserted
x = root
# Pointer y maintains the trailing
# pointer of x
y = None
while (x != None):
y = x
if (key < x.key):
x = x.left
else:
x = x.right
# If the root is None i.e the tree is
# empty. The new node is the root node
if (y == None):
y = newnode
# If the new key is less then the leaf node key
# Assign the new node to be its left child
elif (key < y.key):
y.left = newnode
# else assign the new node its
# right child
else:
y.right = newnode
# Returns the pointer where the
# new node is inserted
return y
# A utility function to do inorder
# traversal of BST
def Inorder(root) :
if (root == None) :
return
else:
Inorder(root.left)
print( root.key, end = " " )
Inorder(root.right)
# Driver Code
if __name__ == '__main__':
""" Let us create following BST
50
/ \
30 70
/ \ / \
20 40 60 80 """
root = None
root = insert(root, 50)
insert(root, 30)
insert(root, 20)
insert(root, 40)
insert(root, 70)
insert(root, 60)
insert(root, 80)
# Prinoder traversal of the BST
Inorder(root)
# This code is contributed by
# SHUBHAMSINGH10C#
// C# program to demonstrate insert
// operation in binary search tree
using System;
class GFG
{
// BST node
class Node
{
public int key;
public Node left, right;
};
// Utitlity function to create a new node
static Node newNode(int data)
{
Node temp = new Node();
temp.key = data;
temp.left = null;
temp.right = null;
return temp;
}
// A utility function to insert a new
// Node with given key in BST
static Node insert(Node root, int key)
{
// Create a new Node containing
// the new element
Node newnode = newNode(key);
// Pointer to start traversing from root and
// traverses downward path to search
// where the new node to be inserted
Node x = root;
// Pointer y maintains the trailing
// pointer of x
Node y = null;
while (x != null)
{
y = x;
if (key < x.key)
x = x.left;
else
x = x.right;
}
// If the root is null i.e the tree is empty
// The new node is the root node
if (y == null)
y = newnode;
// If the new key is less then the leaf node key
// Assign the new node to be its left child
else if (key < y.key)
y.left = newnode;
// else assign the new node its right child
else
y.right = newnode;
// Returns the pointer where the
// new node is inserted
return y;
}
// A utility function to do inorder
// traversal of BST
static void Inorder(Node root)
{
if (root == null)
return;
else
{
Inorder(root.left);
Console.Write( root.key +" ");
Inorder(root.right);
}
}
// Driver code
public static void Main(String []args)
{
/* Let us create following BST
50
/ \
30 70
/ \ / \
20 40 60 80 */
Node root = null;
root = insert(root, 50);
insert(root, 30);
insert(root, 20);
insert(root, 40);
insert(root, 70);
insert(root, 60);
insert(root, 80);
// Print inoder traversal of the BST
Inorder(root);
}
}
// This code is contributed 29AjayKumar输出：
20 30 40 50 60 70 80
复杂度分析：
- 时间复杂度： O(h)，其中h是二叉搜索树的高度。在最坏的情况下，高度等于节点数。
- 空间复杂度： O(1)，不需要额外的空间。