Scénarios d'application des fermetures Java dans les structures de données et les algorithmes

Les fermetures sont largement utilisées dans l'inversion de listes chaînées, la traversée de structures arborescentes et la programmation dynamique dans les structures de données et les algorithmes. En accédant et en modifiant les variables de portée externe, les fermetures évitent le risque de débordement de pile récursif lors de l'inversion des listes chaînées ; créent des itérateurs personnalisés lors du parcours des structures arborescentes ;

Scénarios d'application des fermetures Java dans les structures de données et les algorithmes

Les fermetures sont une fonctionnalité importante du langage de programmation qui permet aux fonctions d'accéder et de modifier les variables définies dans la portée externe. Cela rend les fermetures puissantes dans les structures de données et les algorithmes.

1. Inversion de listes chaînées

L'une des solutions courantes pour inverser les listes chaînées consiste à utiliser des fermetures. Il peut inverser efficacement les éléments d'une liste chaînée tout en évitant le risque de débordement de pile provoqué par l'utilisation de la récursivité.

public class Node {
    int val;
    Node next;

    public Node(int val) {
        this.val = val;
    }
}

public static Node reverseList(Node head) {
    Node newHead = null;

    // 闭包函数，负责更新新链表指向
    Function<Node, Node> reverse = (prev) -> {
        if (head == null) {
            return prev;
        }

        Node next = head.next;
        head.next = prev;
        head = next;

        return reverse.apply(head);
    };

    return reverse.apply(newHead);
}

2. Traversée de structure arborescente

Les fermetures peuvent être utilisées pour créer des itérateurs personnalisés pour parcourir des structures arborescentes, telles que la traversée en pré-commande, la traversée dans l'ordre et la traversée après-commande.

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    public TreeNode(int val) {
        this.val = val;
    }
}

// 前序遍历
Function<TreeNode, List<Integer>> preOrder = (root) -> {
    if (root == null) {
        return Collections.emptyList();
    }

    List<Integer> result = new ArrayList<>();
    result.add(root.val);
    result.addAll(preOrder.apply(root.left));
    result.addAll(preOrder.apply(root.right));

    return result;
};

3. Programmation dynamique

Le mode mémo dans l'algorithme de programmation dynamique peut stocker efficacement les résultats intermédiaires et éviter les calculs répétés. Parmi eux, les fermetures peuvent être utilisées pour transmettre des mémos en tant que paramètres aux fonctions récursives.

public int fib(int n) {
    if (n <= 1) {
        return 1;
    }

    // 闭包函数，存储中间结果
    Function<Integer, Integer> memo = (x) -> {
        if (x <= 1) {
            return 1;
        } else if (memo.containsKey(x)) {
            return memo.get(x);
        } else {
            int result = fib(x - 1) + fib(x - 2);
            memo.put(x, result);
            return result;
        }
    };

    return memo.apply(n);
}

private Map<Integer, Integer> memo = new HashMap<>();

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!