二叉排序树
1.概念介绍:对于二叉排序树的任何一个非叶子节点,要求左子节点的值要小于当前节点,右子节点的值要大于当前节点
2.代码实现插入和遍历
package binarysorttree;
public class BinarySortTree {
public static void main(String[] args) {
int[] arr = {7,3,10,12,5,1,9};
binaryTree binaryTree = new binaryTree();
for(int i=0;i<arr.length;i++){
binaryTree.add(new Node(arr[i]));
}
binaryTree.midOrder();
}
}
class binaryTree{
Node root;
//插入
public void add(Node node){
if(root == null){
root = node;
}else{
root.addNode(node);
}
}
//中序遍历
public void midOrder(){
if(root != null){
root.midOrder();
}
}
}
class Node{
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
//插入
public void addNode(Node node){
if(this.value>node.value){
if(this.left==null){
this.left = node;
}else{
this.left.addNode(node);
}
}else{
if(this.right == null){
this.right = node;
}else{
this.right.addNode(node);
}
}
}
//中序遍历
public void midOrder(){
if(this.left != null){
this.left.midOrder();
}
System.out.println(this);
if(this.right != null){
this.right.midOrder();
}
}
}
3.二叉排序树删除节点思路分析
a.删除叶子节点:找到要删除节点,和要删除节点的父节点,删除即可
b.删除非叶子节点(一个子节点):找到要删除节点,和要删除节点的父节点,需要判断要删除节点的子节点是右还是左,还需要判断要删除节点是父节点的左节点还是右节点,再进行删除
c.删除非叶子节点(两个节点):找到要删除节点,和要删除节点的父节点,找到要删除节点右子树最小值,将此值删除,并替换要删除节点
4.代码实现
package binarysorttree;
public class BinarySortTree {
public static void main(String[] args) {
int[] arr = {7,3,10,12,5,1,9,2};
binaryTree binaryTree = new binaryTree();
for(int i=0;i<arr.length;i++){
binaryTree.add(new Node(arr[i]));
}
binaryTree.midOrder();
System.out.println();
binaryTree.deleteNode(2);
binaryTree.deleteNode(5);
binaryTree.deleteNode(9);
binaryTree.deleteNode(12);
binaryTree.deleteNode(7);
binaryTree.deleteNode(3);
binaryTree.deleteNode(10);
binaryTree.deleteNode(1);
binaryTree.midOrder();
}
}
class binaryTree{
Node root;
//插入
public void add(Node node){
if(root == null){
root = node;
}else{
root.addNode(node);
}
}
//中序遍历
public void midOrder(){
if(root != null){
root.midOrder();
}
}
//查找要删除节点的父节点
public Node fintParentNode(int value){
if(root == null){
return null;
}else {
return root.fintParentNode(value);
}
}
//查找要删除的节点
public Node findNode(int value){
if(root == null){
return null;
}else{
return root.findNode(value);
}
}
//找到以当前节点为root的子树最小值,并删除
public Node deleteByRoot(Node node){
Node tage = node;
while(true){
if(tage.left!=null){
tage = tage.left;
}else{
break;
}
}
deleteNode(tage.value);
return tage;
}
//删除节点
public void deleteNode(int value){
Node node = this.findNode(value);
if(root == null){
return;
}else{
if(node == null){
return;
}
if(root.right == null && root.left == null){
root = null;
return;
}
Node nodeParent = this.fintParentNode(value);
//删除叶子节点
if(node.left == null && node.right == null){
if(nodeParent.right!=null && nodeParent.right.value == node.value){
nodeParent.right = null;
}
if(nodeParent.left!=null && nodeParent.left.value == node.value){
nodeParent.left = null;
}
}else if(node.left != null && node.right != null){
//删除非叶子节点(有两个子节点)
//需要找到当前要删除节点的右子树中最小值
Node deleNode = deleteByRoot(node.right);
node.value = deleNode.value;
}else{
//删除非叶子节点(只有一个子节点)
if(node.left != null){
if(nodeParent != null){
if(nodeParent.left.value == value){
nodeParent.left = node.left;
}else {
nodeParent.right = node.left;
}
}else{
root = node.left;
}
}else{
if(nodeParent != null){
if(nodeParent.left.value == value){
nodeParent.left = node.right;
}else{
nodeParent.right = node.right;
}
}else{
root = node.right;
}
}
}
}
}
}
class Node{
int value;
Node left;
Node right;
public Node(int value) {
this.value = value;
}
@Override
public String toString() {
return "Node{" +
"value=" + value +
'}';
}
//找到要删除节点的父节点
public Node fintParentNode(int value){
if((this.left!=null && this.left.value == value) || (this.right!=null && this.right.value == value)){
return this;
}else if(value > this.value){
if(this.right != null){
return this.right.fintParentNode(value);
}
return null;
}else{
if(this.left != null){
return this.left.fintParentNode(value);
}
return null;
}
}
//找到要删除的当前节点
public Node findNode(int value){
if(this.value == value){
return this;
}else{
if(value > this.value){
if(this.right != null){
return this.right.findNode(value);
}
return null;
}else {
if(this.left != null){
return this.left.findNode(value);
}
return null;
}
}
}
//插入
public void addNode(Node node){
if(this.value>node.value){
if(this.left==null){
this.left = node;
}else{
this.left.addNode(node);
}
}else{
if(this.right == null){
this.right = node;
}else{
this.right.addNode(node);
}
}
}
//中序遍历
public void midOrder(){
if(this.left != null){
this.left.midOrder();
}
System.out.println(this);
if(this.right != null){
this.right.midOrder();
}
}
}
平衡二叉树
1.引出案例:假如有数列1,2,3,4,5,6,此时你创建一个二叉排序树,左子树全部为空,形状类似一条直线,此时查询速度很低,还不如单链表,此时需要构建平衡二叉树
2.AVL树左旋转思路分析
a.当右子树高度大于左子树高度超过1时,使用AVL树左旋转
b.创建一个新的节点newNode,newNode的值与当前根节点值相同
c.把新节点的左子树设置为当前节点的左子树
d.把新节点的右子树设置为当前节点的右子树的左子树
e.把当前节点的值设置成当前节点的右子节点的值
f.把当前节点的右子树设置为当前节点的右子节点的右子节点
g.把当前节点的左子树设置为新节点
3.代码实现
//在Node节点类中
//返回当前节点的右子树的高度
public int treeHightRight(){
if(right == null){
return 0;
}else{
return right.treeHight();
}
}
//返回当前节点的左子树的高度
public int treeHightLeft(){
if(left == null){
return 0;
}else{
return left.treeHight();
}
}
//返回当前节点的右子树或左子树中最高高度
public int treeHight(){
return Math.max(left == null?0:left.treeHight(),right == null?0:right.treeHight())+1;
}
//左旋转
public void leftMove(){
Node node = new Node(value);
node.left = left;
node.right = right.left;
node.value = right.value;
right = right.right;
left = node;
}
//插入
public void addNode(Node node){
if(this.value>node.value){
if(this.left==null){
this.left = node;
}else{
this.left.addNode(node);
}
}else{
if(this.right == null){
this.right = node;
}else{
this.right.addNode(node);
}
}
if((treeHightRight()-treeHightLeft()) > 1){
leftMove();
}
}
4.AVL树右旋转思路分析
a.当左子树高度大于右子树高度超过1时,使用AVL树右旋转
b.创建一个新的节点newNode,newNode的值与当前节点值相同
c.把新节点的右子树设置为当前节点的右子树
d.把新节点的左子树设置为当前节点的左子树的右子树
e.把当前节点的值设置成当前节点的左子节点的值
f.把当前节点的左子树设置为当前节点的左子节点的左子节点
g.把当前节点的右子树设置为新节点
5.代码实现
//右旋转
public void rightMove(){
Node node = new Node(value);
node.right = right;
node.left = left.right;
node.value = left.value;
left = left.left;
right = node;
}
//插入
public void addNode(Node node){
if(this.value>node.value){
if(this.left==null){
this.left = node;
}else{
this.left.addNode(node);
}
}else{
if(this.right == null){
this.right = node;
}else{
this.right.addNode(node);
}
}
if((treeHightRight()-treeHightLeft()) > 1){
leftMove();
}
if((treeHightLeft()-treeHightRight()) > 1){
rightMove();
}
}
6.AVL树双旋转思路分析
在符合右旋转条件时,如果它的左子树的右子树高度大于它的左子树的左子树的高度,先对当前节点的左节点进行左旋转,再对当前节点进行右旋转,否则直接进行右旋转会导致再次不平衡,左旋转同理
7.代码实现
//插入
public void addNode(Node node){
if(this.value>node.value){
if(this.left==null){
this.left = node;
}else{
this.left.addNode(node);
}
}else{
if(this.right == null){
this.right = node;
}else{
this.right.addNode(node);
}
}
if((treeHightRight()-treeHightLeft()) > 1){
if(right!=null && right.treeHightLeft()>right.treeHightRight()){
right.rightMove();
}
leftMove();
}
if((treeHightLeft()-treeHightRight()) > 1){
if(left!=null && left.treeHightRight()>left.treeHightLeft()){
left.leftMove();
}
rightMove();
}
}
多叉树
1.二叉树的问题:二叉树的操作效率较高,但是如果数据量大,会造成树的高度比较高,节点比较多,影响IO操作
2.2-3树:
a.2-3树的所有叶子节点都在同一层(只要是B树都满足此条件)
b.有两个子节点的节点叫做二节点,二节点要么没有子节点,要么有两个子节点
c.有三个子节点的节点叫做三节点,三节点要么没有子节点,要么有三个子节点
d.2-3树是由二节点和三节点构成的树
e.2-3树上面的节点依旧遵循二叉排序树的原则
3.B树,B+树,B星树
B树:
对于B树而言,关键字分布在整棵树中,叶子节点和非叶子节点都存放关键字
B+树:
对于B+树而言,所有的关键字都出现在叶子节点的链表中,链表中的数据也是有序的,非叶子节点相当于叶子节点的索引(稀疏索引),更适合文件索引系统
B星树:
B星树在B+树的基础上增加啦,B+树中非根和非叶子节点的指向兄弟的指针,提高空间使用率