rust match如何处理递归结构

在Rust中，match语句可以用来处理递归结构。递归结构是指一个结构体包含另一个相同类型的结构体作为其成员。这里有一个例子，展示了如何使用match处理一个简单的递归结构：

首先，定义一个递归结构Node，表示一个二叉树节点：

#[derive(Debug)]
struct Node {
    value: i32,
    left: Option<Box<Node>>,
    right: Option<Box<Node>>,
}

接下来，使用match语句处理这个递归结构。这里有一个函数print_tree，它接受一个Node指针，并打印出整个二叉树的结构：

fn print_tree(node: &Option<Box<Node>>) {
    match node {
        None => println!("Empty tree"),
        Some(n) => {
            match n.left {
                None => println!("Node {}: No left child", n.value),
                Some(left) => {
                    match left.left {
                        None => println!("Node {}: No left-left child", n.value),
                        Some(left_left) => println!("Node {}: Left-left child {}", n.value, left_left.value),
                    }
                    match left.right {
                        None => println!("Node {}: No right child", n.value),
                        Some(right) => {
                            match right.left {
                                None => println!("Node {}: No right-left child", n.value),
                                Some(right_left) => println!("Node {}: Right-left child {}", n.value, right_left.value),
                            }
                            match right.right {
                                None => println!("Node {}: No right-right child", n.value),
                                Some(right_right) => println!("Node {}: Right-right child {}", n.value, right_right.value),
                            }
                        }
                    }
                }
            }
            match n.right {
                None => println!("Node {}: No right child", n.value),
                Some(right) => {
                    match right.left {
                        None => println!("Node {}: No right-left child", n.value),
                        Some(right_left) => println!("Node {}: Right-left child {}", n.value, right_left.value),
                    }
                    match right.right {
                        None => println!("Node {}: No right-right child", n.value),
                        Some(right_right) => println!("Node {}: Right-right child {}", n.value, right_right.value),
                    }
                }
            }
        }
    }
}

这个print_tree函数使用嵌套的match语句来处理递归结构。它首先检查当前节点是否为空，然后处理左子树和右子树。对于左子树和右子树，它也使用嵌套的match语句来处理它们的子节点。

下面是一个使用这个函数的例子：

fn main() {
    let mut root = Node {
        value: 1,
        left: Some(Box::new(Node {
            value: 2,
            left: Some(Box::new(Node {
                value: 4,
                left: None,
                right: None,
            })),
            right: Some(Box::new(Node {
                value: 5,
                left: None,
                right: None,
            })),
        })),
        right: Some(Box::new(Node {
            value: 3,
            left: None,
            right: None,
        })),
    };

    print_tree(&Some(Box::new(root)));
}

这个例子创建了一个简单的二叉树，并使用print_tree函数打印出它的结构。输出结果如下：

Node 1: No left child
Node 1: Right child
Node 2: No left child
Node 2: Right child
Node 4: No left child
Node 4: No right child
Node 5: No left child
Node 5: No right child
Node 3: No left child
Node 3: No right child