• 数据结构篇：链表和树结构的操作方法

    本节课在线学习视频（网盘地址，保存后即可免费观看）：

    ​​https://pan.quark.cn/s/e4f2ff1e1895​​

    链表和树是数据结构中两种非常重要和常见的结构。链表是一种线性数据结构，适用于需要频繁插入和删除操作的场景；而树是一种非线性数据结构，适用于表示层级关系的数据。本文将详细介绍链表和树结构的基本操作方法，并通过多个代码案例展示其具体实现。

    1. 链表

    链表是由一系列节点组成的线性数据结构，每个节点包含数据部分和指向下一个节点的指针。链表主要有单链表、双链表和循环链表三种类型。

    1.1 单链表

    单链表中的每个节点只包含一个指向下一个节点的指针。

    案例1：单链表的基本操作
    1. class ListNode {
    2.     int val;
    3.     ListNode next;
    4.  
    5.     ListNode(int val) {
    6.         this.val = val;
    7.     }
    8. }
    9.  
    10. public class SinglyLinkedList {
    11.     private ListNode head;
    12.  
    13.     // 插入节点到链表头
    14.     public void insertAtHead(int val) {
    15.         ListNode newNode = new ListNode(val);
    16.         newNode.next = head;
    17.         head = newNode;
    18.     }
    19.  
    20.     // 删除链表头节点
    21.     public void deleteHead() {
    22.         if (head != null) {
    23.             head = head.next;
    24.         }
    25.     }
    26.  
    27.     // 打印链表
    28.     public void printList() {
    29.         ListNode current = head;
    30.         while (current != null) {
    31.             System.out.print(current.val + " -> ");
    32.             current = current.next;
    33.         }
    34.         System.out.println("null");
    35.     }
    36.  
    37.     public static void main(String[] args) {
    38.         SinglyLinkedList list = new SinglyLinkedList();
    39.         list.insertAtHead(10);
    40.         list.insertAtHead(20);
    41.         list.insertAtHead(30);
    42.         System.out.println("Initial list:");
    43.         list.printList();
    44.  
    45.         list.deleteHead();
    46.         System.out.println("After deleting head:");
    47.         list.printList();
    48.     }
    49. }

    在这个例子中，我们实现了单链表的插入和删除操作，并打印链表的内容。

    1.2 双链表

    双链表中的每个节点包含两个指针，分别指向前一个节点和下一个节点。

    案例2：双链表的基本操作
    1. class DoublyListNode {
    2.     int val;
    3.     DoublyListNode prev;
    4.     DoublyListNode next;
    5.  
    6.     DoublyListNode(int val) {
    7.         this.val = val;
    8.     }
    9. }
    10.  
    11. public class DoublyLinkedList {
    12.     private DoublyListNode head;
    13.  
    14.     // 插入节点到链表头
    15.     public void insertAtHead(int val) {
    16.         DoublyListNode newNode = new DoublyListNode(val);
    17.         newNode.next = head;
    18.         if (head != null) {
    19.             head.prev = newNode;
    20.         }
    21.         head = newNode;
    22.     }
    23.  
    24.     // 删除链表头节点
    25.     public void deleteHead() {
    26.         if (head != null) {
    27.             head = head.next;
    28.             if (head != null) {
    29.                 head.prev = null;
    30.             }
    31.         }
    32.     }
    33.  
    34.     // 打印链表
    35.     public void printList() {
    36.         DoublyListNode current = head;
    37.         while (current != null) {
    38.             System.out.print(current.val + " <-> ");
    39.             current = current.next;
    40.         }
    41.         System.out.println("null");
    42.     }
    43.  
    44.     public static void main(String[] args) {
    45.         DoublyLinkedList list = new DoublyLinkedList();
    46.         list.insertAtHead(10);
    47.         list.insertAtHead(20);
    48.         list.insertAtHead(30);
    49.         System.out.println("Initial list:");
    50.         list.printList();
    51.  
    52.         list.deleteHead();
    53.         System.out.println("After deleting head:");
    54.         list.printList();
    55.     }
    56. }

    在这个例子中，我们实现了双链表的插入和删除操作，并打印链表的内容。

    1.3 循环链表

    循环链表中的最后一个节点指向链表中的第一个节点，从而形成一个环。

    案例3：循环单链表的基本操作
    1. class CircularListNode {
    2.     int val;
    3.     CircularListNode next;
    4.  
    5.     CircularListNode(int val) {
    6.         this.val = val;
    7.     }
    8. }
    9.  
    10. public class CircularLinkedList {
    11.     private CircularListNode head;
    12.  
    13.     // 插入节点到链表头
    14.     public void insertAtHead(int val) {
    15.         CircularListNode newNode = new CircularListNode(val);
    16.         if (head == null) {
    17.             head = newNode;
    18.             head.next = head;
    19.         } else {
    20.             CircularListNode temp = head;
    21.             while (temp.next != head) {
    22.                 temp = temp.next;
    23.             }
    24.             temp.next = newNode;
    25.             newNode.next = head;
    26.             head = newNode;
    27.         }
    28.     }
    29.  
    30.     // 打印链表
    31.     public void printList() {
    32.         if (head == null) return;
    33.         CircularListNode temp = head;
    34.         do {
    35.             System.out.print(temp.val + " -> ");
    36.             temp = temp.next;
    37.         } while (temp != head);
    38.         System.out.println("(head)");
    39.     }
    40.  
    41.     public static void main(String[] args) {
    42.         CircularLinkedList list = new CircularLinkedList();
    43.         list.insertAtHead(10);
    44.         list.insertAtHead(20);
    45.         list.insertAtHead(30);
    46.         System.out.println("Circular Linked List:");
    47.         list.printList();
    48.     }
    49. }

    在这个例子中，我们实现了循环单链表的插入和打印操作。

    2. 树结构

    树是一种层级数据结构，由节点和边组成。树的每个节点可以有零个或多个子节点，但每个节点只有一个父节点（根节点除外）。常见的树有二叉树、二叉搜索树和AVL树等。

    2.1 二叉树

    二叉树中的每个节点最多有两个子节点，分别称为左子节点和右子节点。

    案例4：二叉树的基本操作
    1. class TreeNode {
    2.     int val;
    3.     TreeNode left;
    4.     TreeNode right;
    5.  
    6.     TreeNode(int val) {
    7.         this.val = val;
    8.     }
    9. }
    10.  
    11. public class BinaryTree {
    12.     // 插入节点
    13.     public TreeNode insert(TreeNode root, int val) {
    14.         if (root == null) {
    15.             return new TreeNode(val);
    16.         }
    17.         if (val < root.val) {
    18.             root.left = insert(root.left, val);
    19.         } else {
    20.             root.right = insert(root.right, val);
    21.         }
    22.         return root;
    23.     }
    24.  
    25.     // 前序遍历
    26.     public void preOrderTraversal(TreeNode root) {
    27.         if (root != null) {
    28.             System.out.print(root.val + " ");
    29.             preOrderTraversal(root.left);
    30.             preOrderTraversal(root.right);
    31.         }
    32.     }
    33.  
    34.     // 中序遍历
    35.     public void inOrderTraversal(TreeNode root) {
    36.         if (root != null) {
    37.             inOrderTraversal(root.left);
    38.             System.out.print(root.val + " ");
    39.             inOrderTraversal(root.right);
    40.         }
    41.     }
    42.  
    43.     // 后序遍历
    44.     public void postOrderTraversal(TreeNode root) {
    45.         if (root != null) {
    46.             postOrderTraversal(root.left);
    47.             postOrderTraversal(root.right);
    48.             System.out.print(root.val + " ");
    49.         }
    50.     }
    51.  
    52.     public static void main(String[] args) {
    53.         BinaryTree tree = new BinaryTree();
    54.         TreeNode root = null;
    55.         int[] values = {30, 20, 40, 10, 25, 35, 50};
    56.  
    57.         for (int val : values) {
    58.             root = tree.insert(root, val);
    59.         }
    60.  
    61.         System.out.print("Pre-order traversal: ");
    62.         tree.preOrderTraversal(root);
    63.         System.out.println();
    64.  
    65.         System.out.print("In-order traversal: ");
    66.         tree.inOrderTraversal(root);
    67.         System.out.println();
    68.  
    69.         System.out.print("Post-order traversal: ");
    70.         tree.postOrderTraversal(root);
    71.         System.out.println();
    72.     }
    73. }

    在这个例子中，我们实现了二叉树的插入操作，以及前序遍历、中序遍历和后序遍历。

    2.2 二叉搜索树

    二叉搜索树（BST）是一种特殊的二叉树，满足以下性质：对于树中的每个节点，其左子树中的所有节点的值都小于该节点的值，右子树中的所有节点的值都大于该节点的值。

    案例5：二叉搜索树的查找和删除操作
    1. public class BinarySearchTree {
    2.     // 查找节点
    3.     public TreeNode search(TreeNode root, int val) {
    4.         if (root == null || root.val == val) {
    5.             return root;
    6.         }
    7.         if (val < root.val) {
    8.             return search(root.left, val);
    9.         }
    10.         return search(root.right, val);
    11.     }
    12.  
    13.     // 删除节点
    14.     public TreeNode delete(TreeNode root, int val) {
    15.         if (root == null) return null;
    16.  
    17.         if (val < root.val) {
    18.             root.left = delete(root.left, val);
    19.         } else if (val > root.val) {
    20.             root.right = delete(root.right, val);
    21.         } else {
    22.             if (root.left == null) return root.right;
    23.             if (root.right == null) return root.left;
    24.             TreeNode minNode = findMin(root.right);
    25.             root.val = minNode.val;
    26.             root.right = delete(root.right, minNode.val);
    27.         }
    28.         return root;
    29.     }
    30.  
    31.     // 查找最小节点
    32.     private TreeNode findMin(TreeNode node) {
    33.         while (node.left != null) {
    34.             node = node.left;
    35.         }
    36.         return node;
    37.     }
    38.  
    39.     public static void main(String[] args) {
    40.         BinarySearchTree bst = new BinarySearchTree();
    41.         TreeNode root = null;
    42.         int[] values = {50, 30, 70, 20, 40, 60, 80};
    43.  
    44.         for (int val : values) {
    45.             root = bst.insert(root, val);
    46.         }
    47.  
    48.         System.out.println("BST created.");
    49.         System.out.print("In-order traversal before deletion: ");
    50.         bst.inOrderTraversal(root);
    51.         System.out.println();
    52.  
    53.         root = bst.delete(root, 20);
    54.         System.out.print("In-order traversal after deleting 20: ");
    55.         bst.inOrderTraversal(root);
    56.         System.out.println();
    57.  
    58.         root = bst.delete(root, 30);
    59.         System.out.print("In-order traversal after deleting 30: ");
    60.         bst.inOrderTraversal(root);
    61.         System.out.println();
    62.  
    63.         root = bst.delete(root, 50);
    64.         System.out.print("In-order traversal after deleting 50: ");
    65.         bst.inOrderTraversal(root);
    66.         System.out.println();
    67.     }
    68. }
    69.

    在这个例子中，我们实现了二叉搜索树的查找和删除操作，并展示了删除节点后的中序遍历结果。

    2.3 AVL树

    AVL树是平衡二叉搜索树的一种，通过旋转操作保持树的平衡。我们在前面的博客中已经详细介绍了AVL树的旋转操作，这里补充一下综合操作。

    案例6：AVL树的插入和删除操作
    1. public class AVLTree {
    2.     private int height(TreeNode node) {
    3.         if (node == null) return 0;
    4.         return node.height;
    5.     }
    6.  
    7.     private int balanceFactor(TreeNode node) {
    8.         if (node == null) return 0;
    9.         return height(node.left) - height(node.right);
    10.     }
    11.  
    12.     private TreeNode rightRotate(TreeNode y) {
    13.         TreeNode x = y.left;
    14.         TreeNode T2 = x.right;
    15.  
    16.         x.right = y;
    17.         y.left = T2;
    18.  
    19.         y.height = Math.max(height(y.left), height(y.right)) + 1;
    20.         x.height = Math.max(height(x.left), height(x.right)) + 1;
    21.  
    22.         return x;
    23.     }
    24.  
    25.     private TreeNode leftRotate(TreeNode x) {
    26.         TreeNode y = x.right;
    27.         TreeNode T2 = y.left;
    28.  
    29.         y.left = x;
    30.         x.right = T2;
    31.  
    32.         x.height = Math.max(height(x.left), height(x.right)) + 1;
    33.         y.height = Math.max(height(y.left), height(y.right)) + 1;
    34.  
    35.         return y;
    36.     }
    37.  
    38.     private TreeNode insert(TreeNode node, int val) {
    39.         if (node == null) return new TreeNode(val);
    40.  
    41.         if (val < node.val) node.left = insert(node.left, val);
    42.         else if (val > node.val) node.right = insert(node.right, val);
    43.         else return node;
    44.  
    45.         node.height = 1 + Math.max(height(node.left), height(node.right));
    46.         int balance = balanceFactor(node);
    47.  
    48.         if (balance > 1 && val < node.left.val) return rightRotate(node);
    49.         if (balance < -1 && val > node.right.val) return leftRotate(node);
    50.         if (balance > 1 && val > node.left.val) {
    51.             node.left = leftRotate(node.left);
    52.             return rightRotate(node);
    53.         }
    54.         if (balance < -1 && val < node.right.val) {
    55.             node.right = rightRotate(node.right);
    56.             return leftRotate(node);
    57.         }
    58.  
    59.         return node;
    60.     }
    61.  
    62.     private TreeNode delete(TreeNode root, int val) {
    63.         if (root == null) return root;
    64.  
    65.         if (val < root.val) root.left = delete(root.left, val);
    66.         else if (val > root.val) root.right = delete(root.right, val);
    67.         else {
    68.             if ((root.left == null) || (root.right == null)) {
    69.                 TreeNode temp = null;
    70.                 if (temp == root.left) temp = root.right;
    71.                 else temp = root.left;
    72.  
    73.                 if (temp == null) {
    74.                     temp = root;
    75.                     root = null;
    76.                 } else root = temp;
    77.             } else {
    78.                 TreeNode temp = findMin(root.right);
    79.                 root.val = temp.val;
    80.                 root.right = delete(root.right, temp.val);
    81.             }
    82.         }
    83.  
    84.         if (root == null) return root;
    85.  
    86.         root.height = Math.max(height(root.left), height(root.right)) + 1;
    87.         int balance = balanceFactor(root);
    88.  
    89.         if (balance > 1 && balanceFactor(root.left) >= 0) return rightRotate(root);
    90.         if (balance > 1 && balanceFactor(root.left) < 0) {
    91.             root.left = leftRotate(root.left);
    92.             return rightRotate(root);
    93.         }
    94.         if (balance < -1 && balanceFactor(root.right) <= 0) return leftRotate(root);
    95.         if (balance < -1 && balanceFactor(root.right) > 0) {
    96.             root.right = rightRotate(root.right);
    97.             return leftRotate(root);
    98.         }
    99.  
    100.         return root;
    101.     }
    102.  
    103.     private TreeNode findMin(TreeNode node) {
    104.         while (node.left != null) node = node.left;
    105.         return node;
    106.     }
    107.  
    108.     public void inOrderTraversal(TreeNode root) {
    109.         if (root != null) {
    110.             inOrderTraversal(root.left);
    111.             System.out.print(root.val + " ");
    112.             inOrderTraversal(root.right);
    113.         }
    114.     }
    115.  
    116.     public static void main(String[] args) {
    117.         AVLTree avl = new AVLTree();
    118.         TreeNode root = null;
    119.         int[] values = {10, 20, 30, 40, 50, 25};
    120.  
    121.         for (int val : values) {
    122.             root = avl.insert(root, val);
    123.         }
    124.  
    125.         System.out.print("In-order traversal before deletion: ");
    126.         avl.inOrderTraversal(root);
    127.         System.out.println();
    128.  
    129.         root = avl.delete(root, 10);
    130.         System.out.print("In-order traversal after deleting 10: ");
    131.         avl.inOrderTraversal(root);
    132.         System.out.println();
    133.  
    134.         root = avl.delete(root, 30);
    135.         System.out.print("In-order traversal after deleting 30: ");
    136.         avl.inOrderTraversal(root);
    137.         System.out.println();
    138.  
    139.         root = avl.delete(root, 50);
    140.         System.out.print("In-order traversal after deleting 50: ");
    141.         avl.inOrderTraversal(root);
    142.         System.out.println();
    143.     }
    144. }

    在这个例子中，我们实现了AVL树的插入和删除操作，并展示了删除节点后的中序遍历结果。

    3. 注意事项

    • 在链表操作中，注意处理空链表和单节点链表的特殊情况。
    • 在树操作中，确保在插入或删除节点后正确调整节点的高度，并进行必要的旋转操作以保持树的平衡。
    • 对于大规模数据，链表和树的操作可能需要考虑空间和时间复杂度，以提高性能。

    结语

    本文详细介绍了链表和树结构的基本操作方法，包括单链表、双链表、循环链表的插入和删除操作，以及二叉树、二叉搜索树和AVL树的插入、查找和删除操作。通过这些代码案例，可以帮助你更好地理解和应用链表和树结构。在实际开发中，选择合适的数据结构和操作方法，可以显著提升代码的效率和可维护性。希望这些示例和注意事项能帮助你更好地掌握链表和树结构的操作方法。

  • 相关阅读:
    素数判定算法 初级
    前端react面试题指北
    高性能计算和并行计算的关系
    锁的优化机制了解吗？
    奋斗正当时，城链科技战略峰会广州站圆满召开
    Vue3 学习笔记 —— 破坏式更新、自定义指令 directive
    2022 6月软件测试面试题（400道）【附带答案】持续更新...
    java实现一个简单的监听器
    HTML静态网页成品作业(HTML+CSS)——家乡泉州介绍网页(3个页面)（表格布局）
    Running job: job_1709516801756_0003
  • 原文地址：https://blog.csdn.net/weixin_41489908/article/details/139701465