多平台统一管理软件接口，如何实现多平台统一管理软件接口
269
2022-09-08
java二叉树的数据插入算法介绍
java二叉树的数据插入算法介绍
目录例题:对于二叉树的遍历有三种方式二叉树插入数据的原理/思路是什么？代码实现整体代码全部代码
例题:
leetcode 第701题
二叉树插入数据
题目：
给定二叉搜索http://树（BST）的根节点和要插入树中的值，将值插入二叉搜索树。 返回插入后二叉搜索树的根节点。 输入数据 保证 ，新值和原始二叉搜索树中的任意节点值都不同。
对于二叉树的遍历有三种方式
前序遍历：根左右 的顺序
中序遍历：左根右 的顺序
后序遍历：左右根 的顺序
二叉树插入数据的原理/思路是什么？
二叉树的左侧的数会比右侧的数小，所以我们用需要插入的数据和根节点的值比较大小，如果插入的数据大于根节点，那么根节点就转移到右侧的节点上,此时重复上面的操作即可完成插入。
我们读一下TreeNode代码段：
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
}
很显然,二叉树之间是通过left,right来链接的,和ListNode的next非常的相似,只不过二叉树是双向链接,而链表则是单向。所以我们就需要获取到父节点，用父节点的left或right来链接插入的数。
那么我们如何获取到能正确插入该数据的节点呢？
1.我们可以通过循环移动节点的方式,来获取最后一个不为空的节点
//定义一个父级二叉树 用来记录上个操作的节点
TreeNode parent =root,cur=root;
while(cur!=null){
//如果p部位空的话,就和val比较来进行节点的移动
parent = cur; //记录上一个节点,用于最后的链接
cur = cur.val } 2.然后用最后一个不为空的节点的值与插入值进行比较插入即可,小的则插入左侧,大的则插入右侧。 代码实现 if(parent.val>val){ //如果父级的val是大于输入的val，那么插在左边 parent.left = new TreeNode(val); }else{ //否则插在右边 parent.right = new TreeNode(val); } 整体代码 if (root == null){ return new TreeNode(val); } //定义一个父级二叉树 用来记录上个操作的节点 TreeNode parent =root,cur=root; while(cur!=null){ //如果p部位空的话,就和val比较来进行节点的移动 parent = cur; //记录上一个节点,用于最后的链接 cur = cur.val } if(parent.val>val){ //如果父级的val是大于输入的val，那么插在左边 parent.left = new TreeNode(val); }else{ //否则插在右边 parent.right = new TreeNode(val); } return root; 当然,因为节点的移动一直重复一个操作,我们可以用更简单的递归实现 public TreeNode insertIntoBST(TreeNode root, int val) { if (root == null){ return new TreeNode(val); } if(root.val //因为父节点的值小于插入值,则要进行节点的右移 root.right = insertIntoBST(root.right,val); }else{ root.left = insertIntoBST(root.left,val); } return root; } 全部代码 package java算法.LeetCode; public class t701 { /** 701. 二叉搜索树中的插入操作 二叉树分为前序插入,中序插入，后序插入 解决思路 1.利用迭代思想实现二叉树的插入 */ } class TreeNode { int val; TreeNode left; TreeNode right; TreeNode() {} TreeNode(int val) { this.val = val; } TreeNode(int val, TreeNode left, TreeNode right) { this.val = val; this.left = left; this.right = right; } } /** * Definition for a binary thttp://ree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { * this.val = val; * this.left = left; * this.right = right; * } * } */ class Solution { /* 二叉树插入原理: 1.前序插入(根左右) 如果插入的树大于根,数则往右侧移动,与右侧分支的根进行比较，然后重复前面的操作 */ public TreeNode insertIntoBST(TreeNode root, int val) { //当传入的根节点为空,则将传入的值设置为节点 if (root == null){ //如果tree为空的,那么就创建一个新的二叉并赋值 return new TreeNode(val); } if (root.val //当当前的值是大于左侧的值，则往右侧移动 root.right=insertIntoBST(root.right,val); }else{ //反之 root.left=insertIntoBST(root.left,val); } return root; } //解法2：循环判断 public TreeNode insertIntoBST2(TreeNode root, int val) { if (root == null){ return new TreeNode(val); } TreeNode parent=root,p=root; while(true){ if (p!=null){ parent = p; //记录上个节点 p = p.val>val?p.left:p.right; }else{ //当p为null了,则已经找到位置了,现在则需要将值进行插入 if (parent.val>val){ parent.left = new TreeNode(val); }else{ parent.right = new TreeNode(val); } break; } } return root; } //解法三:循环遍历, /** * * @param root * @param val * @return * * 解法思路：我们先通过一个循环找到能插入位置的父节点， * 然后我们就对值与父节点的值进行比较,如果该值小于父节点的话我们就插入在父节点的左侧 */ public TreeNode insertBST3(TreeNode root,int val){ if (root == null){ return new TreeNode(val); } //定义一个父级二叉树 用来记录上个操作的节点 TreeNode parent =root,p=root; while(p!=null){ //如果p部位空的话,就和val比较来进行节点的移动 parent = p; //记录上一个节点,用于最后的链接 p = p.val } if(parentYzOibzCg.val>val){ //如果父级的val是大于输入的val，那么插在左边 parent.left = new TreeNode(val); }else{ //否则插在右边 parent.right = new TreeNode(val); } return root; } }
}
2.然后用最后一个不为空的节点的值与插入值进行比较插入即可,小的则插入左侧,大的则插入右侧。
代码实现
if(parent.val>val){
//如果父级的val是大于输入的val，那么插在左边
parent.left = new TreeNode(val);
}else{
//否则插在右边
parent.right = new TreeNode(val);
}
整体代码
if (root == null){
return new TreeNode(val);
}
//定义一个父级二叉树 用来记录上个操作的节点
TreeNode parent =root,cur=root;
while(cur!=null){
//如果p部位空的话,就和val比较来进行节点的移动
parent = cur; //记录上一个节点,用于最后的链接
cur = cur.val } if(parent.val>val){ //如果父级的val是大于输入的val，那么插在左边 parent.left = new TreeNode(val); }else{ //否则插在右边 parent.right = new TreeNode(val); } return root; 当然,因为节点的移动一直重复一个操作,我们可以用更简单的递归实现 public TreeNode insertIntoBST(TreeNode root, int val) { if (root == null){ return new TreeNode(val); } if(root.val //因为父节点的值小于插入值,则要进行节点的右移 root.right = insertIntoBST(root.right,val); }else{ root.left = insertIntoBST(root.left,val); } return root; } 全部代码 package java算法.LeetCode; public class t701 { /** 701. 二叉搜索树中的插入操作 二叉树分为前序插入,中序插入，后序插入 解决思路 1.利用迭代思想实现二叉树的插入 */ } class TreeNode { int val; TreeNode left; TreeNode right; TreeNode() {} TreeNode(int val) { this.val = val; } TreeNode(int val, TreeNode left, TreeNode right) { this.val = val; this.left = left; this.right = right; } } /** * Definition for a binary thttp://ree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { * this.val = val; * this.left = left; * this.right = right; * } * } */ class Solution { /* 二叉树插入原理: 1.前序插入(根左右) 如果插入的树大于根,数则往右侧移动,与右侧分支的根进行比较，然后重复前面的操作 */ public TreeNode insertIntoBST(TreeNode root, int val) { //当传入的根节点为空,则将传入的值设置为节点 if (root == null){ //如果tree为空的,那么就创建一个新的二叉并赋值 return new TreeNode(val); } if (root.val //当当前的值是大于左侧的值，则往右侧移动 root.right=insertIntoBST(root.right,val); }else{ //反之 root.left=insertIntoBST(root.left,val); } return root; } //解法2：循环判断 public TreeNode insertIntoBST2(TreeNode root, int val) { if (root == null){ return new TreeNode(val); } TreeNode parent=root,p=root; while(true){ if (p!=null){ parent = p; //记录上个节点 p = p.val>val?p.left:p.right; }else{ //当p为null了,则已经找到位置了,现在则需要将值进行插入 if (parent.val>val){ parent.left = new TreeNode(val); }else{ parent.right = new TreeNode(val); } break; } } return root; } //解法三:循环遍历, /** * * @param root * @param val * @return * * 解法思路：我们先通过一个循环找到能插入位置的父节点， * 然后我们就对值与父节点的值进行比较,如果该值小于父节点的话我们就插入在父节点的左侧 */ public TreeNode insertBST3(TreeNode root,int val){ if (root == null){ return new TreeNode(val); } //定义一个父级二叉树 用来记录上个操作的节点 TreeNode parent =root,p=root; while(p!=null){ //如果p部位空的话,就和val比较来进行节点的移动 parent = p; //记录上一个节点,用于最后的链接 p = p.val } if(parentYzOibzCg.val>val){ //如果父级的val是大于输入的val，那么插在左边 parent.left = new TreeNode(val); }else{ //否则插在右边 parent.right = new TreeNode(val); } return root; } }
}
if(parent.val>val){
//如果父级的val是大于输入的val，那么插在左边
parent.left = new TreeNode(val);
}else{
//否则插在右边
parent.right = new TreeNode(val);
}
return root;
当然,因为节点的移动一直重复一个操作,我们可以用更简单的递归实现
public TreeNode insertIntoBST(TreeNode root, int val) {
if (root == null){
return new TreeNode(val);
}
if(root.val //因为父节点的值小于插入值,则要进行节点的右移 root.right = insertIntoBST(root.right,val); }else{ root.left = insertIntoBST(root.left,val); } return root; } 全部代码 package java算法.LeetCode; public class t701 { /** 701. 二叉搜索树中的插入操作 二叉树分为前序插入,中序插入，后序插入 解决思路 1.利用迭代思想实现二叉树的插入 */ } class TreeNode { int val; TreeNode left; TreeNode right; TreeNode() {} TreeNode(int val) { this.val = val; } TreeNode(int val, TreeNode left, TreeNode right) { this.val = val; this.left = left; this.right = right; } } /** * Definition for a binary thttp://ree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { * this.val = val; * this.left = left; * this.right = right; * } * } */ class Solution { /* 二叉树插入原理: 1.前序插入(根左右) 如果插入的树大于根,数则往右侧移动,与右侧分支的根进行比较，然后重复前面的操作 */ public TreeNode insertIntoBST(TreeNode root, int val) { //当传入的根节点为空,则将传入的值设置为节点 if (root == null){ //如果tree为空的,那么就创建一个新的二叉并赋值 return new TreeNode(val); } if (root.val //当当前的值是大于左侧的值，则往右侧移动 root.right=insertIntoBST(root.right,val); }else{ //反之 root.left=insertIntoBST(root.left,val); } return root; } //解法2：循环判断 public TreeNode insertIntoBST2(TreeNode root, int val) { if (root == null){ return new TreeNode(val); } TreeNode parent=root,p=root; while(true){ if (p!=null){ parent = p; //记录上个节点 p = p.val>val?p.left:p.right; }else{ //当p为null了,则已经找到位置了,现在则需要将值进行插入 if (parent.val>val){ parent.left = new TreeNode(val); }else{ parent.right = new TreeNode(val); } break; } } return root; } //解法三:循环遍历, /** * * @param root * @param val * @return * * 解法思路：我们先通过一个循环找到能插入位置的父节点， * 然后我们就对值与父节点的值进行比较,如果该值小于父节点的话我们就插入在父节点的左侧 */ public TreeNode insertBST3(TreeNode root,int val){ if (root == null){ return new TreeNode(val); } //定义一个父级二叉树 用来记录上个操作的节点 TreeNode parent =root,p=root; while(p!=null){ //如果p部位空的话,就和val比较来进行节点的移动 parent = p; //记录上一个节点,用于最后的链接 p = p.val } if(parentYzOibzCg.val>val){ //如果父级的val是大于输入的val，那么插在左边 parent.left = new TreeNode(val); }else{ //否则插在右边 parent.right = new TreeNode(val); } return root; } }
//因为父节点的值小于插入值,则要进行节点的右移
root.right = insertIntoBST(root.right,val);
}else{
root.left = insertIntoBST(root.left,val);
}
return root;
}
全部代码
package java算法.LeetCode;
public class t701 {
/**
701. 二叉搜索树中的插入操作
二叉树分为前序插入,中序插入，后序插入
解决思路 1.利用迭代思想实现二叉树的插入
*/
}
class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
}
/**
* Definition for a binary thttp://ree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
/*
二叉树插入原理:
1.前序插入(根左右) 如果插入的树大于根,数则往右侧移动,与右侧分支的根进行比较，然后重复前面的操作
*/
public TreeNode insertIntoBST(TreeNode root, int val) {
//当传入的根节点为空,则将传入的值设置为节点
if (root == null){
//如果tree为空的,那么就创建一个新的二叉并赋值
return new TreeNode(val);
}
if (root.val //当当前的值是大于左侧的值，则往右侧移动 root.right=insertIntoBST(root.right,val); }else{ //反之 root.left=insertIntoBST(root.left,val); } return root; } //解法2：循环判断 public TreeNode insertIntoBST2(TreeNode root, int val) { if (root == null){ return new TreeNode(val); } TreeNode parent=root,p=root; while(true){ if (p!=null){ parent = p; //记录上个节点 p = p.val>val?p.left:p.right; }else{ //当p为null了,则已经找到位置了,现在则需要将值进行插入 if (parent.val>val){ parent.left = new TreeNode(val); }else{ parent.right = new TreeNode(val); } break; } } return root; } //解法三:循环遍历, /** * * @param root * @param val * @return * * 解法思路：我们先通过一个循环找到能插入位置的父节点， * 然后我们就对值与父节点的值进行比较,如果该值小于父节点的话我们就插入在父节点的左侧 */ public TreeNode insertBST3(TreeNode root,int val){ if (root == null){ return new TreeNode(val); } //定义一个父级二叉树 用来记录上个操作的节点 TreeNode parent =root,p=root; while(p!=null){ //如果p部位空的话,就和val比较来进行节点的移动 parent = p; //记录上一个节点,用于最后的链接 p = p.val } if(parentYzOibzCg.val>val){ //如果父级的val是大于输入的val，那么插在左边 parent.left = new TreeNode(val); }else{ //否则插在右边 parent.right = new TreeNode(val); } return root; } }
//当当前的值是大于左侧的值，则往右侧移动
root.right=insertIntoBST(root.right,val);
}else{
//反之
root.left=insertIntoBST(root.left,val);
}
return root;
}
//解法2：循环判断
public TreeNode insertIntoBST2(TreeNode root, int val) {
if (root == null){
return new TreeNode(val);
}
TreeNode parent=root,p=root;
while(true){
if (p!=null){
parent = p; //记录上个节点
p = p.val>val?p.left:p.right;
}else{
//当p为null了,则已经找到位置了,现在则需要将值进行插入
if (parent.val>val){
parent.left = new TreeNode(val);
}else{
parent.right = new TreeNode(val);
}
break;
}
}
return root;
}
//解法三:循环遍历,
/**
*
* @param root
* @param val
* @return
*
* 解法思路：我们先通过一个循环找到能插入位置的父节点，
* 然后我们就对值与父节点的值进行比较,如果该值小于父节点的话我们就插入在父节点的左侧
*/
public TreeNode insertBST3(TreeNode root,int val){
if (root == null){
return new TreeNode(val);
}
//定义一个父级二叉树 用来记录上个操作的节点
TreeNode parent =root,p=root;
while(p!=null){
//如果p部位空的话,就和val比较来进行节点的移动
parent = p; //记录上一个节点,用于最后的链接
p = p.val } if(parentYzOibzCg.val>val){ //如果父级的val是大于输入的val，那么插在左边 parent.left = new TreeNode(val); }else{ //否则插在右边 parent.right = new TreeNode(val); } return root; } }
}
if(parentYzOibzCg.val>val){
//如果父级的val是大于输入的val，那么插在左边
parent.left = new TreeNode(val);
}else{
//否则插在右边
parent.right = new TreeNode(val);
}
return root;
}
}
版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。
相关文章
发表评论
暂时没有评论，来抢沙发吧~