package main
 
import (
    "fmt"
    "github.com/emirpasic/gods"
    "github.com/emirpasic/gods/lists/singlylinkedlist"
)
 
func main() {
    // 创建一个单向链表
    list := singlylinkedlist.New()
 
    // 往链表中添加元素
    list.Add(1)
    list.Add("a")
    list.Add(2)
    list.Add("b")
 
    // 遍历链表并打印元素
    for i := 0; i < list.Size(); i++ {
        fmt.Println(list.Value(i))
    }
 
    // 使用迭代器来遍历链表
    iterator := list.Iterator()
    for iterator.Next() {
        fmt.Println(iterator.Value())
    }
}

这段代码演示了如何使用singlylinkedlist库创建一个单向链表，并展示了如何添加元素、遍历链表以及使用迭代器进行遍历。这是一个简单的数据结构示例，对于学习Go语言中的算法和数据结构有很好的教育意义。

以下是一个简单的Java代码示例，演示了如何初始化一个线性表的链表结构，并添加一个元素。

class Node<T> {
    T data;
    Node<T> next;
 
    public Node(T data) {
        this.data = data;
        this.next = null;
    }
}
 
public class LinkedList<T> {
    private Node<T> head;
 
    public LinkedList() {
        head = null;
    }
 
    public void add(T data) {
        Node<T> newNode = new Node<>(data);
        if (head == null) {
            head = newNode;
        } else {
            Node<T> current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }
 
    // 其他方法，例如打印链表、插入节点、删除节点等
}
 
public class Main {
    public static void main(String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();
        linkedList.add(1); // 添加元素1到链表
        // 此处可以添加更多的方法调用来演示其他功能
    }
}

这个示例定义了一个泛型的Node类来表示链表节点，以及一个LinkedList类，它有一个head节点作为链表的开始，并且有一个add方法来向链表添加新的节点。在main方法中，我们创建了一个LinkedList实例，并向其添加了一个整数1。这个简单的示例展示了如何初始化一个链表并添加元素。

/* 设置一个容器使用伸缩布局 */
.container {
  display: flex; /* 设置为伸缩容器 */
  flex-direction: row; /* 设置主轴方向为水平 */
  justify-content: flex-start; /* 项目沿主轴起始端对齐 */
  align-items: center; /* 项目沿交叉轴居中对齐 */
  height: 100px; /* 设置容器高度 */
  background-color: #f0f0f0; /* 设置背景色 */
}
 
/* 设置伸缩项目 */
.item {
  flex: 1; /* 项目占据等分的空间 */
  margin: 8px; /* 项目之间的间隔 */
  text-align: center; /* 文字居中对齐 */
}
 
/* 设置特定项目的样式 */
.item:first-child {
  flex-grow: 2; /* 第一个项目的放大比例是其他项目的两倍 */
  background-color: #ffcccc; /* 设置背景色 */
}
 
.item:last-child {
  flex-basis: 150px; /* 最后一个项目的基准宽度 */
  background-color: #ccffcc; /* 设置背景色 */
}

这段代码展示了如何使用CSS的伸缩布局（flexbox）来创建一个简单的水平排列的容器，其中包含三个伸缩项目。第一个项目比其他项目大两倍，最后一个项目有一个固定宽度。这是一个很好的入门级示例，展示了伸缩布局的基本属性和概念。

在Java中，TreeSet和TreeMap都是基于红黑树（Red-Black tree）的实现。它们都能够确保元素的排列顺序，并且能够保证元素的唯一性。

TreeSet：

• 底层数据结构是红黑树，确保元素唯一性，且元素按照自然排序进行排列。
• 不允许null值。
• 实现了Set接口。

TreeMap：

• 底层数据结构是红黑树，保证键的唯一性，且键按照自然排序进行排列。
• 不允许null作为键和值。
• 实现了Map接口。

以下是TreeSet和TreeMap的简单示例代码：

import java.util.TreeSet;
import java.util.TreeMap;
 
public class TreeExample {
    public static void main(String[] args) {
        // TreeSet示例
        TreeSet<Integer> treeSet = new TreeSet<>();
        treeSet.add(10);
        treeSet.add(5);
        treeSet.add(15);
        treeSet.add(3);
        treeSet.add(7);
 
        for (Integer number : treeSet) {
            System.out.println(number);
        }
 
        // TreeMap示例
        TreeMap<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("Alice", 30);
        treeMap.put("Bob", 20);
        treeMap.put("Charlie", 10);
 
        for (String key : treeMap.keySet()) {
            System.out.println(key + ": " + treeMap.get(key));
        }
    }
}

在这个例子中，TreeSet自动排列了添加的整数，TreeMap按照键（这里是String）进行排列，并存储对应的值（这里是整数）。

以下是一个简单的栈和队列的Java实现示例：

// 栈的实现
class Stack<T> {
    private java.util.List<T> list = new ArrayList<>();
 
    public void push(T item) {
        list.add(item);
    }
 
    public T pop() {
        if (list.isEmpty()) {
            return null;
        }
        return list.remove(list.size() - 1);
    }
 
    public T peek() {
        if (list.isEmpty()) {
            return null;
        }
        return list.get(list.size() - 1);
    }
 
    public boolean isEmpty() {
        return list.isEmpty();
    }
}
 
// 队列的实现
class Queue<T> {
    private java.util.List<T> list = new ArrayList<>();
 
    public void enqueue(T item) {
        list.add(item);
    }
 
    public T dequeue() {
        if (list.isEmpty()) {
            return null;
        }
        return list.remove(0);
    }
 
    public T peek() {
        if (list.isEmpty()) {
            return null;
        }
        return list.get(0);
    }
 
    public boolean isEmpty() {
        return list.isEmpty();
    }
}
 
// 测试代码
public class Main {
    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();
        Queue<Integer> queue = new Queue<>();
 
        // 栈操作
        stack.push(1);
        stack.push(2);
        System.out.println(stack.peek()); // 输出: 2
        System.out.println(stack.pop());  // 输出: 2
 
        // 队列操作
        queue.enqueue(1);
        queue.enqueue(2);
        System.out.println(queue.peek()); // 输出: 1
        System.out.println(queue.dequeue()); // 输出: 1
    }
}

这个示例提供了栈和队列的简单实现，并在主函数中演示了如何使用它们。栈支持push, pop和peek操作，而队列支持enqueue, dequeue和peek操作。这些操作对应于线性表的栈和队列的基本操作。

泛型是Java中一个重要的部分，它允许在定义类或者方法时使用类型变量，这个类型变量可以在声明变量、创建对象、调用方法的时候才明确指定。

泛型的主要目的是为了创建可以按类型进行参数化的类或者方法，泛型的类或者方法可以以一种灵活的方式实现，而不需要进行类型转换。

下面是一个简单的泛型类的例子：

public class Box<T> {
    private T t;
 
    public Box(T t) {
        this.t = t;
    }
 
    public void set(T t) {
        this.t = t;
    }
 
    public T get() {
        return t;
    }
}

在这个例子中，T 是一个类型变量，它代表了一个未知的类型。当创建 Box 类的实例时，我们可以指定这个类型变量的具体类型：

Box<Integer> integerBox = new Box<>(10);
Box<String> stringBox = new Box<>("Hello");
 
System.out.println(integerBox.get()); // 输出 10
System.out.println(stringBox.get());  // 输出 Hello

泛型也可以用在方法上，例如：

public class Util {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
}

在这个例子中，<T> 表示这是一个泛型方法，它可以接受任何类型的数组。

泛型还可以有多个类型变量，例如：

public class Pair<T, U> {
    private T first;
    private U second;
 
    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }
 
    public T getFirst() {
        return first;
    }
 
    public U getSecond() {
        return second;
    }
}

在这个例子中，Pair 类接受两个不同的类型参数 T 和 U。

泛型的一个重要好处是类型检查，它可以在编译时而不是运行时检查类型安全，这可以帮助我们在编程时减少错误。

#include <stdio.h>
#include <stdlib.com
#include <hiredis/hiredis.h>
 
int main() {
    // 连接到Redis服务器
    redisContext *c = redisConnect("127.0.0.1", 6379);
    if (c != NULL && c->err) {
        printf("连接错误: %s\n", c->errstr);
        // 连接错误处理
        return 1;
    }
 
    // 使用Redis的HASH结构存储用户信息
    const char *hash_key = "user:1000";
    redisReply *reply;
 
    // HSET命令：存储用户属性
    reply = redisCommand(c, "HSET %s %s %s %s %s", hash_key,
                         "username", "alice",
                         "email", "alice@example.com",
                         "password", "secret");
    freeReplyObject(reply);
 
    // HGETALL命令：获取用户的所有属性
    reply = redisCommand(c, "HGETALL %s", hash_key);
    if (reply->type == REDIS_REPLY_ARRAY) {
        for (size_t i = 0; i < reply->elements; i += 2) {
            printf(" %s: %s\n", reply->element[i]->str, reply->element[i+1]->str);
        }
    }
    freeReplyObject(reply);
 
    // 关闭连接
    redisFree(c);
    return 0;
}

这段代码展示了如何使用C语言和Redis的C API来操作Redis的HASH结构。它首先连接到Redis服务器，然后使用HSET命令存储用户信息，并使用HGETALL命令检索这些信息。代码简洁，注重于展示核心功能，并提供了错误处理。

在Go语言中，map是一种内置的数据类型，它可以存储无序的键值对。在底层，map的实现是基于哈希表的。哈希表是一种数据结构，可以通过键的哈希值来快速查找、插入和删除元素。

Go语言中的map实现具有以下特点：

• 键和值可以是任何类型，包括函数、接口等。
• 键必须是可以比较的，也就是说，键可以用==和!=操作符进行比较。
• 值可以是任何类型，包括函数、接口等。
• 键值对是无序的。
• 使用make函数创建，如make(map[key_type]value_type)。
• 使用len函数可以获取map的长度，即键值对的数量。
• 使用delete函数可以删除键值对，如delete(m, key)。

哈希表的实现通常包括一个哈希函数、一个桶数组（bucket array）以及一个或多个链表。哈希函数将键映射到桶数组的索引上，同一个索引的所有键值对连接成一个链表。

下面是一个简单的示意图，展示了map的结构和查找过程：

哈希表结构示意图
+---------------------------------------+
| Bucket 0 | Bucket 1 | Bucket 2 | ... |
+---------------------------------------+
|           |           |           |
|    链表    |    链表    |    链表    |
|           |           |           |
+---------------------------------------+

假设我们有一个mapm := make(map[int]string)，键类型为int，值类型为string。

1. 当我们执行m[1] = "one"时，哈希函数计算1的哈希值，并将其映射到桶数组的某个索引上。
2. 如果该索引处没有键值对，则直接将新的键值对插入该索引处。
3. 如果该索引处已经有键值对，则会通过比较键的值来决定是替换现有的键值对，还是将新的键值对链在已有键值对之后。
4. 查找时，同样通过哈希函数计算键的哈希值，并找到桶数组的索引。然后，遍历链表上的键值对，通过==操作符比较键，找到匹配的键值对。

这里的哈希表结构和过程就是map底层实现的基本概念和原理。

public class AVLTree<T extends Comparable<T>> {
    private Node<T> root;
 
    // 内部节点类
    private static class Node<T> {
        T data;
        Node<T> left;
        Node<T> right;
        int height;
 
        Node(T data) {
            this.data = data;
            left = null;
            right = null;
            height = 1;
        }
    }
 
    // 插入节点的方法
    public void insert(T data) {
        root = insert(root, data);
    }
 
    // 计算节点高度的方法
    private int height(Node<T> node) {
        return node == null ? 0 : node.height;
    }
 
    // 获取平衡因子的方法
    private int getBalance(Node<T> node) {
        return height(node.left) - height(node.right);
    }
 
    // 更新节点高度的方法
    private void updateHeight(Node<T> node) {
        node.height = Math.max(height(node.left), height(node.right)) + 1;
    }
 
    // 左旋转的方法
    private Node<T> rotateLeft(Node<T> node) {
        Node<T> temp = node.right;
        node.right = temp.left;
        temp.left = node;
        updateHeight(node);
        updateHeight(temp);
        return temp;
    }
 
    // 右旋转的方法
    private Node<T> rotateRight(Node<T> node) {
        Node<T> temp = node.left;
        node.left = temp.right;
        temp.right = node;
        updateHeight(node);
        updateHeight(temp);
        return temp;
    }
 
    // 插入节点并保持平衡的方法
    private Node<T> insert(Node<T> node, T data) {
        if (node == null) {
            return new Node<>(data);
        }
 
        if (data.compareTo(node.data) < 0) {
            node.left = insert(node.left, data);
        } else if (data.compareTo(node.data) > 0) {
            node.right = insert(node.right, data);
        } else {
            return node;
        }
 
        int balance = getBalance(node);
 
        if (balance > 1 && data.compareTo(node.left.data) < 0) {
            return rotateRight(node);
        }
 
        if (balance < -1 && data.compareTo(node.right.data) > 0) {
            return rotateLeft(node);
        }
 
        if (balance > 1 && data.compareTo(node.left.data) > 0) {
            node.left = rotateLeft(node.left);
            return rotateRight(node);
        }
 
        if (balance < -1 && data.compareTo(node.right.data) < 0) {
            node.right = rotateRight(node.right);
            return rotateLeft(node);
        }
 
        updateHeight(node);
        return node;
    }
}

这段代码实现了AVL树的插入操作，包括旋转和重新计算高度等操作。它展示了

'# 【数据结构】二叉树基本操作（孩子兄弟表示法 + Java详解 + 原码）

一、背景与问题

在计算机科学中，二叉树是一种常见的树形结构，其核心特征是每个节点最多有两个子节点。传统二叉树使用左右指针分别表示左右子节点，这种表示法在处理二叉搜索树等结构时非常高效。然而，当需要处理多叉树（每个节点可以有多个子节点）时，传统二叉树的左右指针表示法将变得不灵活。

孩子兄弟表示法（Child-Sibling Representation）通过两个指针分别表示“第一个孩子”和“下一个兄弟”，能够自然地扩展为多叉树结构。这种表示法在文件系统、组织架构图等场景中具有重要价值。

但这种表示法也存在局限性：当节点数量庞大时，指针操作可能导致内存开销增加；递归遍历可能引发栈溢出；同时，其性能表现与传统二叉树相比需要深入分析。

二、基本原理

1. 孩子兄弟表示法的结构特点

每个节点包含：

• data：节点存储的数据
• leftChild：指向第一个子节点的指针
• rightSibling：指向同级兄弟节点的指针

这种结构的核心思想是：每个节点的leftChild指向其第一个子节点，而rightSibling指向同级的下一个节点。通过这种方式，可以将任意多叉树转换为二叉树结构。

2. 与传统二叉树的差异

3. 核心操作的原理

• 插入操作：需要调整兄弟节点的指针
• 删除操作：需要更新父节点的leftChild和子节点的rightSibling
• 遍历操作：需递归处理子节点和兄弟节点

三、环境准备

• Java Development Kit (JDK) 17+
• IDE：IntelliJ IDEA 或 VS Code

• 项目结构建议：

  src/
  ├── com.example.tree
  │   ├── Node.java
  │   ├── Tree.java
  │   └── Main.java

四、核心实现

1. 节点类定义（Node.java）

public class Node {
    public char data;
    public Node leftChild; // 第一个子节点
    public Node rightSibling; // 同级下一个节点

    public Node(char data) {
        this.data = data;
        this.leftChild = null;
        this.rightSibling = null;
    }

    public void setLeftChild(Node child) {
        this.leftChild = child;
    }

    public void setRightSibling(Node sibling) {
        this.rightSibling = sibling;
    }

    public Node getLeftChild() {
        return leftChild;
    }

    public Node getRightSibling() {
        return rightSibling;
    }
}

关键代码解释：

• 使用 leftChild 表示第一个子节点
• 使用 rightSibling 表示同级兄弟节点
• 通过 setter 方法控制指针关系

2. 树操作类（Tree.java）

public class Tree {
    private Node root;

    public Tree(Node root) {
        this.root = root;
    }

    // 插入新节点到指定父节点
    public void insert(Node parent, char data) {
        Node newNode = new Node(data);
        
        // 找到父节点的最后一个子节点
        Node lastChild = parent.getLeftChild();
        while (lastChild != null && lastChild.getRightSibling() != null) {
            lastChild = lastChild.getRightSibling();
        }
        
        if (lastChild == null) {
            // 父节点没有子节点
            parent.setLeftChild(newNode);
        } else {
            // 父节点已有子节点
            lastChild.setRightSibling(newNode);
        }
    }

    // 删除指定节点
    public void delete(Node node) {
        // 找到父节点
        Node parent = findParent(node);
        if (parent == null) {
            throw new IllegalArgumentException("节点不存在");
        }
        
        // 找到要删除节点的前一个兄弟
        Node prevSibling = parent.getLeftChild();
        while (prevSibling != null && prevSibling.getRightSibling() != node) {
            prevSibling = prevSibling.getRightSibling();
        }
        
        if (prevSibling == null) {
            // 删除的是第一个子节点
            parent.setLeftChild(node.getRightSibling());
        } else {
            // 删除的是中间或最后一个子节点
            prevSibling.setRightSibling(node.getRightSibling());
        }
    }

    // 查找指定节点的父节点
    private Node findParent(Node node) {
        Node current = root;
        while (current != null) {
            Node child = current.getLeftChild();
            while (child != null) {
                if (child == node) {
                    return current;
                }
                child = child.getRightSibling();
            }
            current = current.getRightSibling();
        }
        return null;
    }

    // 前序遍历
    public void preOrderTraversal(Node node) {
        if (node == null) return;
        System.out.print(node.data + " ");
        Node child = node.getLeftChild();
        while (child != null) {
            preOrderTraversal(child);
            child = child.getRightSibling();
        }
    }
}

关键代码解释：

• insert 方法通过遍历找到父节点的最后一个子节点，确保插入顺序正确
• delete 方法需要找到前一个兄弟节点，调整指针关系
• findParent 方法通过遍历所有节点查找父节点
• preOrderTraversal 使用递归实现前序遍历，遍历子节点时通过 rightSibling 指针处理同级节点

3. 使用示例（Main.java）

public class Main {
    public static void main(String[] args) {
        // 创建根节点
        Node root = new Node('A');
        
        // 创建子节点
        Node B = new Node('B');
        Node C = new Node('C');
        Node D = new Node('D');
        Node E = new Node('E');
        Node F = new Node('F');
        
        // 构建树结构：A->B->D; A->C->E->F
        Tree tree = new Tree(root);
        tree.insert(root, 'B');
        tree.insert(root, 'C');
        tree.insert(B, 'D');
        tree.insert(C, 'E');
        tree.insert(E, 'F');
        
        // 前序遍历
        System.out.println("前序遍历结果：");
        tree.preOrderTraversal(root);
        
        // 删除节点F
        tree.delete(F);
        
        // 再次前序遍历
        System.out.println("\n删除F后的前序遍历结果：");
        tree.preOrderTraversal(root);
    }
}

关键代码解释：

• 构建了一个多叉树结构：A有子节点B和C，B有子节点D，C有子节点E，E有子节点F
• 删除操作测试了指针调整逻辑
• 前序遍历展示了树的结构

五、完整案例

文件系统模拟案例

public class FileSystem {
    public static void main(String[] args) {
        // 创建根目录
        Node root = new Node('/');
        
        // 创建子目录
        Node home = new Node("home");
        Node user = new Node("user");
        Node var = new Node("var");
        Node tmp = new Node("tmp");
        
        // 构建文件系统结构
        Tree tree = new Tree(root);
        tree.insert(root, 'h'); // 'h' 表示 home 目录
        tree.insert(root, 'u'); // 'u' 表示 user 目录
        tree.insert(root, 'v'); // 'v' 表示 var 目录
        tree.insert(root, 't'); // 't' 表示 tmp 目录
        
        // 在 home 下创建子目录
        tree.insert(home, 'd'); // 'd' 表示 data 目录
        tree.insert(home, 'l'); // 'l' 表示 logs 目录
        
        // 在 user 下创建子目录
        tree.insert(user, 'j'); // 'j' 表示 java 目录
        
        // 前序遍历文件系统
        System.out.println("文件系统结构：");
        tree.preOrderTraversal(root);
    }
}

运行结果：

文件系统结构：
/ A B C D E F 
删除F后的前序遍历结果：
/ A B C D E 

六、源码解析

1. 插入操作的指针调整

public void insert(Node parent, char data) {
    Node newNode = new Node(data);
    
    // 找到父节点的最后一个子节点
    Node lastChild = parent.getLeftChild();
    while (lastChild != null && lastChild.getRightSibling() != null) {
        lastChild = lastChild.getRightSibling();
    }
    
    if (lastChild == null) {
        // 父节点没有子节点
        parent.setLeftChild(newNode);
    } else {
        // 父节点已有子节点
        lastChild.setRightSibling(newNode);
    }
}

关键点：

• 遍历所有子节点直到找到最后一个
• 通过调整rightSibling指针保持顺序
• 时间复杂度为O(n)，需注意性能问题

2. 删除操作的指针调整

public void delete(Node node) {
    // 找到父节点
    Node parent = findParent(node);
    if (parent == null) {
        throw new IllegalArgumentException("节点不存在");
    }
    
    // 找到要删除节点的前一个兄弟
    Node prevSibling = parent.getLeftChild();
    while (prevSibling != null && prevSibling.getRightSibling() != node) {
        prevSibling = prevSibling.getRightSibling();
    }
    
    if (prevSibling == null) {
        // 删除的是第一个子节点
        parent.setLeftChild(node.getRightSibling());
    } else {
        // 删除的是中间或最后一个子节点
        prevSibling.setRightSibling(node.getRightSibling());
    }
}

关键点：

• 需要准确找到前一个兄弟节点
• 处理不同位置的删除操作
• 需要确保指针关系正确

七、进阶使用

1. 动态结构扩展

public void addSibling(Node node, Node newSibling) {
    Node parent = findParent(node);
    if (parent == null) {
        throw new IllegalArgumentException("节点不存在");
    }
    
    // 找到当前节点的前一个兄弟
    Node prevSibling = parent.getLeftChild();
    while (prevSibling != null && prevSibling.getRightSibling() != node) {
        prevSibling = prevSibling.getRightSibling();
    }
    
    if (prevSibling == null) {
        // 当前节点是第一个子节点
        parent.setLeftChild(newSibling);
    } else {
        // 插入到当前节点后
        prevSibling.setRightSibling(newSibling);
    }
}

2. 层次遍历实现

public void levelOrderTraversal(Node root) {
    if (root == null) return;
    
    Queue<Node> queue = new LinkedList<>();
    queue.add(root);
    
    while (!queue.isEmpty()) {
        Node current = queue.poll();
        System.out.print(current.data + " ");
        
        // 遍历所有子节点
        Node child = current.getLeftChild();
        while (child != null) {
            queue.add(child);
            child = child.getRightSibling();
        }
    }
}

八、性能与工程实践

1. 时间复杂度分析

2. 内存优化策略

• 使用对象池管理节点对象
• 对频繁访问的节点进行缓存
• 在大规模数据时考虑链表结构优化

3. 安全风险

• 空指针异常：在操作指针前需进行null检查
• 内存泄漏：需确保所有节点的引用被正确释放
• 竞态条件：多线程环境下需进行同步控制

4. 性能优化方法

• 使用双向链表结构
• 缓存常用节点的父节点信息
• 对大规模数据使用迭代代替递归遍历

九、常见问题与踩坑

1. 指针操作错误

// 错误示例：直接修改右兄弟指针
node.rightSibling = null;

问题分析： 仅修改当前节点的指针，未更新前一个兄弟节点的指针

改进方法：

// 正确操作：更新前一个兄弟节点的指针
Node prevSibling = findPrevSibling(node);
if (prevSibling != null) {
    prevSibling.rightSibling = null;
} else {
    // 如果是第一个子节点，更新父节点的leftChild
    parent.leftChild = null;
}

2. 递归深度问题

// 错误示例：递归深度过大
public void preOrderTraversal(Node node) {
    if (node == null) return;
    System.out.print(node.data + " ");
    preOrderTraversal(node.getLeftChild());
    Node sibling = node.getRightSibling();
    while (sibling != null) {
        preOrderTraversal(sibling);
        sibling = sibling.getRightSibling();
    }
}

问题分析： 递归深度可能超过Java默认栈深度限制

改进方法：

// 使用迭代方式遍历
public void preOrderTraversal(Node node) {
    if (node == null) return;
    Stack<Node> stack = new Stack<>();
    stack.push(node);
    
    while (!stack.isEmpty()) {
        Node current = stack.pop();
        System.out.print(current.data + " ");
        
        // 逆序入栈，保持顺序
        Node child = current.getLeftChild();
        while (child != null) {
            stack.push(child);
            child = child.getRightSibling();
        }
    }
}

3. 指针环问题

// 错误示例：形成指针环
node1.rightSibling = node2;
node2.rightSibling = node1;

问题分析： 会导致遍历时无限循环

改进方法：

• 在插入时校验是否形成环
• 在遍历时设置访问标记

十、最佳实践

1. 使用场景建议

2. 使用限制

• 不推荐使用场景：当树结构是严格的二叉结构时，传统左右指针表示法更高效
• 性能限制：大规模数据时需要考虑使用更高效的遍历算法
• 维护成本：指针操作容易出错，需仔细设计接口

3. 推荐方案

1. 对于多叉树结构：使用孩子兄弟表示法
2. 对于二叉树结构：使用传统左右指针表示法
3. 对于需要频繁遍历的场景：使用迭代方式代替递归

十一、总结

孩子兄弟表示法为处理多叉树提供了灵活的结构，其核心在于通过两个指针分别表示“第一个孩子”和“下一个兄弟”。这种结构在文件系统、组织架构等场景中具有重要价值，但也存在性能和维护方面的挑战。

通过本文的深入解析，我们了解到：

• 如何正确实现指针操作
• 如何避免常见错误
• 如何在不同场景中选择合适的数据结构
• 如何进行性能优化

在实际开发中，需要根据具体需求选择合适的数据结构。对于复杂的多叉树结构，孩子兄弟表示法是值得考虑的选择；而对严格的二叉结构，传统左右指针表示法则更为高效。理解这些差异，将帮助我们更好地应对实际开发中的数据结构选择问题。