您的位置:

Java树形结构的解释和用法

Java树形结构的解释和用法

更新:

Java树形结构是一种可以存储元素的有层级关系的数据结构,每个元素以节点的形式存在,并且一个根节点会关联多个子节点,子节点再关联更多的子节点,以此类推。

一、树的基本概念

1、树形结构是一种递归式数据结构,它包括一个值,同时还可能包括指向其他树的引用(树是由节点(储存元素)和边(连接节点)组成的集合)

2、树形结构的特性如下: 每个节点有零个或多个子节点; 没有父节点的节点称为根节点; 每一个非根节点有且只有一个父节点; 除了根节点外,每个子节点又可以分为多个不重叠的子树.

class Node {  
    int data;  
    Node left, right;  
 
    public Node(int item) {  
        data = item;  
        left = right = null;  
    }  
}

二、二叉树和二叉搜索树

1、二叉树是每个节点最多只能有两个子节点的树形结构结构,一般子节点称为“左子节点”和“右子节点”。

二叉树形结构的遍历有三种方式:前序遍历、中序遍历和后序遍历。

void printPreorder(Node node) { 
    if (node == null) 
        return; 
  
    // 先输出当前节点的数据 
    System.out.print(node.data + " "); 
  
    // 递归打印左子节点 
    printPreorder(node.left); 
  
    // 现在递归打印右子节点 
    printPreorder(node.right); 
}

二叉搜索树(BST)是一种特性的二叉树:每个节点的值,都大于其左子树的所有节点的值,并且小于右子树形结构的所有节点的值。

class Node { 
    int key; 
    Node left, right; 
   
    public Node(int item) { 
        key = item; 
        left = right = null; 
    } 
} 
   
class BinaryTree { 
    Node root; 
    void insert(int key) { root = insertRec(root, key); }
    
    Node insertRec(Node root, int key) {
        if (root == null) { 
            root = new Node(key); 
            return root; 
        } 
        if (key < root.key) 
            root.left = insertRec(root.left, key); 
        else if (key > root.key) 
            root.right = insertRec(root.right, key); 
        return root; 
    } 
   
    void inorder() { inorderRec(root); } 
    void inorderRec(Node root) { 
        if (root != null) { 
            inorderRec(root.left); 
            System.out.println(root.key); 
            inorderRec(root.right); 
        } 
    } 
}

三、平衡二叉树形结构与红黑树形结构

1、平衡二叉搜索树是其每一个节点的两个子树的高度差最多为1的二叉搜索树,它通过旋转操作,保障树的平衡,从而优化了树的查询速度。

2、红黑树则是一种自平衡的二叉查找树,它在执行插入和删除操作的时候,通过特定的操作保持树的平衡。

以下是其特性:

(1)每个节点或是红色,或是黑色。

(2)根节点是黑色。

(3)每个叶节点(叶节点默认是空节点(NIL)或null)都是黑色的。

(4)如果一个节点是红的,则它的子节点都是黑的。

(5)从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

class Node {
    int data;
    Node parent;
    Node left;
    Node right;
    int color;
}
public class RedBlackTree {

    private Node root;
    private Node TNULL;

    // Preorder
    private void preOrderHelper(Node node) {
        if (node != TNULL) {
            preOrderHelper(node.left);
            preOrderHelper(node.right);
        }
    }

    // In-order
    private void inOrderHelper(Node node) {
        if (node != TNULL) {
            inOrderHelper(node.left);
            inOrderHelper(node.right);
        }
    }

    // Post order
    private void postOrderHelper(Node node) {
        if (node != TNULL) {
            postOrderHelper(node.left);
            postOrderHelper(node.right);
        }
    }

    // Balance the tree after deletion of a node
    private void fixDelete(Node x) {
        Node s;
        while (x != root && x.color == 0) {
            if (x == x.parent.left) {
                s = x.parent.right;
                if (s.color == 1) {
                    // case 3.1
                    s.color = 0;
                    x.parent.color = 1;
                    leftRotate(x.parent);
                    s = x.parent.right;
                }

                if (s.left.color == 0 && s.right.color == 0) {
                    // case 3.2
                    s.color = 1;
                    x = x.parent;
                } else {
                    if (s.right.color == 0) {
                        // case 3.3
                        s.left.color = 0;
                        s.color = 1;
                        rightRotate(s);
                        s = x.parent.right;
                    } 

                    // case 3.4
                    s.color = x.parent.color;
                    x.parent.color = 0;
                    s.right.color = 0;
                    leftRotate(x.parent);
                    x = root;
                }
            } else {
            // same as "if (x == x.parent.left)" the other way around
            }
        }
        x.color = 0;
    }

    // Balance the tree after insertion of a node
    private void fixInsert(Node k) {
        Node u;
        while (k.parent.color == 1) {
            if (k.parent == k.parent.parent.right) {
                u = k.parent.parent.left;

                // uncle is RED
                if (u.color == 1) {
                    u.color = 0;
                    k.parent.color = 0;
                    k.parent.parent.color = 1;
                    k = k.parent.parent;
                } else {
                    if (k == k.parent.left) {
                        k = k.parent;
                        rightRotate(k);
                    }
                    // uncle is BLACK
                    k.parent.color = 0;
                    k.parent.parent.color = 1;
                    leftRotate(k.parent.parent);
                }
            } else {
                // mirror image of above code
                // the other way around
            }
            if (k == root) {
                break;
            }
        }
        root.color = 0;
    }

    // ...
}
Java树形结构的解释和用法

Java树形结构是一种可以存储元素的有层级关系的数据结构,每个元素以节点的形式存在,并且一个根节点会关联多个子节点,子节点再关联更多的子节点,以此类推。一、树的基本概念1、树形结构是一种递归式数据结构

2023-12-08
java树形结构,java树形结构查询

2023-01-07
Java树形结构查询用法

在Java中,树形结构查询主要是通过特定的数据结构和相关算法,来实现对特定的树形结构数据的查询操作,从而获取树中的某个或者某些节点的信息。一、常用的树形数据结构在Java中,常用的树形结构包括二叉树、

2023-12-08
Java树形结构查询用法

在Java中,树形结构查询主要是通过特定的数据结构和相关算法,来实现对特定的树形结构数据的查询操作,从而获取树中的某个或者某些节点的信息。一、常用的树形数据结构在Java中,常用的树形结构包括二叉树、

2023-12-08
java树形结构json(java树形结构扁平化实例)

本文目录一览: 1、java 递归数据库生成 树形结构问题 2、java实现树形结构,可以把String[] a = {"1", "1-3-4", "1-2", "1-2"}这个数组,转变成如图的树j

2023-12-08
java树形结构,java树形结构递归实现

2022-11-29
java树,java树形结构递归实现

2022-11-27
Java递归树形结构详解

2023-05-17
java树形json(Java树形结构筛选查询)

本文目录一览: 1、java如何获取树形格式的json,麻烦提供下思路 2、java 机构树怎么生成json 3、java实现 输入json字符串,返回树形显示 java如何获取树形格式的json,麻

2023-12-08
Java 树形结构

2023-05-18
java树,java树结构

2023-01-08
java实现遍历树形菜单方法,java 树形菜单

2022-11-20
java树结构,java树结构递归

2022-11-30
java树结构,java树结构 工具类

2023-01-07
Java数据结构学习笔记

2023-05-11
重学java笔记,java笔记总结

2022-11-23
JavaTreeNode:树形结构之Java实现

2023-05-18
java笔记,大学java笔记

2022-11-28
java笔记,尚硅谷java笔记

2022-12-01
java学习笔记(java初学笔记)

2022-11-14