对于任何数据结构，其基本操作无非遍历 + 访问，再具体一点就是：增删查改。

如何遍历 + 访问？我们从最高层来看，各种数据结构的遍历 + 访问无非两种形式：线性的和非线性的。

线性就是 for/while 迭代为代表，非线性就是递归为代表。再具体一步，无非以下几种框架：

数组遍历框架，典型的线性迭代结构：

// for循环用来遍历数组
void traverse1(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        // 访问数组元素 arr[i]
        // 在这里可以对数组元素 arr[i] 进行操作
    }
}
// while循环遍历数组
void traverse2(int[] arr) {
    int i = 0; 
    while (i < arr.length) {
        // 访问数组元素 arr[i]
        // 在这里可以对数组元素 arr[i] 进行操作
        i++; // 索引递增
    }
}

链表遍历框架，兼具迭代和递归结构：

/* 基本的单链表节点 */
class ListNode {
    int val;
    ListNode next;
    ListNode(int x) { this.val = x; }
}

class Solution {
    // 迭代遍历
    void traverse(ListNode head) {
        // p 用来遍历链表，初始指向链表的头节点
        for (ListNode p = head; p != null; p = p.next) {
            // 这里是迭代访问 p.val 的位置
            // 在这里可以进行一些操作，比如打印节点值等
            // System.out.println(p.val);
        }
    }

    // 递归遍历
    void traverse(ListNode head) {
        // 递归终止条件
        if (head == null) return;
        // 这里是递归访问 head.val 的位置
        // 在这里可以进行一些操作，比如打印节点值等
        // System.out.println(head.val);

        // 递归访问下一个节点
        traverse(head.next);
    }
}

二叉树遍历框架，典型的非线性递归遍历结构：

/* 基本的二叉树节点 */
class TreeNode {
    int val;
    TreeNode left, right;
    TreeNode(int x) { this.val = x; }
}

class Solution {
    void traverse(TreeNode root) {
        if (root == null) return; // 递归边界条件
        
        // 前序位置 - 在遍历左子树之前处理当前节点
        // 这里可以添加处理逻辑，比如打印 root.val 等
        // System.out.println("Pre-order: " + root.val);

        traverse(root.left);  // 遍历左子树

        // 中序位置 - 在遍历左子树之后、右子树之前处理当前节点
        // 对于二叉搜索树，这个位置的遍历会按升序访问节点
        // System.out.println("In-order: " + root.val);

        traverse(root.right); // 遍历右子树

        // 后序位置 - 在遍历完左右子树之后处理当前节点
        // 常用于后续清理或计算工作，比如删除节点或计算子树信息
        // System.out.println("Post-order: " + root.val);
    }
}

二叉树框架可以扩展为 N 叉树的遍历框架：

/* 基本的 N 叉树节点 */
class TreeNode {
    int val;
    List<TreeNode> children; // 使用列表存储所有子节点
}

void traverse(TreeNode root) {
    if (root == null) return; // 递归边界条件
    
    // process current node 
    // 处理当前节点逻辑（如果有需要）...

    // 遍历每个子节点
    for (TreeNode child : root.children)
        traverse(child);  // 递归地遍历每个子节点
}