重生之封装数据类型中的遍历

一个蒜头

已于 2023-12-01 20:45:32 修改

阅读量935

点赞数 25

分类专栏：数据结构题目文章标签： java 算法数据结构

于 2023-12-01 20:39:01 首次发布

本文链接：https://blog.csdn.net/a2610033/article/details/134740523

版权

数据结构题目专栏收录该内容

3 篇文章 0 订阅

订阅专栏

I. 简介
 II. 封装VS不封装
 III. 封装遍历的函数设计
        A. 未封装
        B.封装
            （1）封装需要考虑什么
                （2）代码实现
 Iterator
                  例1（链表）
                  例2（二叉树）
        Comsumer
IV. 封装遍历的性能优化
 V. 总结

I. 简介

封装遍历的优势包括提高代码的可重用性、可测试性和可维护性。它使得功能可以独立于具体的应用场景进行开发和调试，并且可以在不同的项目和模块中共享和重用。

下文我们将针对遍历函数loop（）进行封装方法的探究和比较

II. 封装VS不封装

优点：

封装性强：将遍历和查找功能封装在同一个类中，可以将相关的方法和数据组织在一起，提高代码的可读性和维护性。
代码复用性高：将遍历和查找功能放在同一个类中，可以在不同的场景下复用这些功能，减少代码的重复编写。
内聚性增强：将相关的功能放在同一个类中，可以增强类的内聚性，使得类的设计更加一致和清晰。

缺点：

类的职责不清晰：将遍历和查找功能放在同一个类中，可能导致类的职责不够单一，造成类的设计模糊和复杂化。
类的大小增加：将多个功能放在同一个类中，会增加类的大小和复杂性，使得类的维护和测试变得更加困难。
可扩展性受限：如果以后需要添加其他类型的功能，可能会导致类的功能越来越臃肿，增加代码的复杂性。

III. 封装遍历的函数设计

A. 未封装

如果不进行封装，我们进行遍历查找一般通过index或者手动输入node进行访问，如下面的例子

//二叉树的遍历 
public void preOrder(BinNodePtr node) {
        if (node != null) {
            System.out.println(node);
            preOrder(node.getLeft());
            preOrder(node.getRight());
        } else return;
 }
//链表的遍历
public static void traverseLinkedList(ListNode head) {
        ListNode current = head;
        while (current != null) {
            System.out.println(current.val);
            current = current.next;
        }
 }
//数组的遍历
public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};

        // 使用普通for循环遍历数组
        System.out.println("使用普通for循环遍历数组:");
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        // 使用增强for循环遍历数组
        System.out.println("使用增强for循环遍历数组:");
        for (int num : arr) {
            System.out.println(num);
        }

        // 使用流式操作遍历数组
        System.out.println("使用流式操作遍历数组:");
        Arrays.stream(arr).forEach(System.out::println);
        //System.out::println可以替换为Lambda表达式
    }

B.封装

（1）封装需要考虑什么

创建迭代器（Iterator）将数据集合的遍历和访问操作进行了抽象和封装，提供了一种统一的方式来访问集合中的元素。以下是一些迭代器的好处：

统一的访问接口：迭代器提供了一个统一的访问接口，无论数据集合的内部结构如何，都可以通过迭代器来访问其中的元素。使用者不需要了解或关心具体的数据结构实现细节，只需使用迭代器提供的方法进行遍历和访问操作。

隐藏底层实现：迭代器将底层数据结构的实现细节隐藏起来，使得使用者无需关心数据集合的内部结构是数组、链表还是其他形式

安全性和一致性：迭代器提供了一种安全的方式来遍历和访问集合中的元素。它们通常会维护自己的状态，确保在遍历过程中不会造成数据的损坏或遗漏。此外，迭代器的使用方式在不同的数据集合之间是一致的，使得代码更加易读和易维护。

支持并发操作：某些迭代器实现还支持并发操作，允许在多线程环境下安全地遍历和访问集合中的元素。这些迭代器会处理并发访问的同步问题，确保线程安全性。

使用Comsumer在安全性的基础上更好的实现

支持函数式编程：Consumer 是函数式编程的重要组成部分，它支持将方法作为参数传递和返回，可以与其他函数式接口（如 Predicate、Function 等）配合使用，实现函数的组合和链式调用，提高代码的可读性和可维护性。

集合操作：Consumer 在集合操作中发挥重要作用。例如，在 Java 8 的 Stream API 中，可以使用 Consumer 对象来定义流的终端操作，如 forEach 方法。通过传递一个 Consumer 对象，可以对流中的每个元素执行自定义的操作，实现集合的遍历和处理。

（2）代码实现

Iterator

例1（链表）

首先我们需要了解迭代器iterator在类中是构造怎么构造的，我们单向链表为例

迭代器作为一个接口，需要在定义类的时候进行声明，且需要区分迭代的数据类型
public class Singlelinkedlist implements Iterable<Integer>{}
于此同时，我们需要对next()和hasnext()两个函数进行重写，这里采取一种封装的更彻底的方法实现（别急常规法也会写）
public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            node cur = head.next;

            @Override
            public boolean hasNext() {
                return cur != null;
            }

            @Override
            public Integer next() {
                int value = cur.value;
                cur = cur.next;
                return value;
            }
        };
    }
上面的函数相当于重构了生成迭代器的函数，next的逻辑比较简单。

在写完构造函数后，我们需要对于迭代器进行使用，本文主要提及在遍历中的使用,比如
Iterator<Integer> iterator = iterator();

 while (iterator.hasNext()) {
     Integer value = iterator.next();
     System.out.print(value);
 }
next()会将当前位置的数字返回并且自动移到下一个位置

例2（二叉树）

链表在数据结构里面难度较低，如果我们遇到二叉树这种递归遍历法则比较奇怪的数据类型，我们要如何编写next()呢

这次我们用比较普遍的写法，我们直接实现next()和hasnext()

next()会将当前位置的数字返回并且自动移到下一个位置，
public class BinaryTreeIterator<T> implements Iterator<T> {
    private TreeNode<T> currentNode;
    private Stack<TreeNode<T>> stack;

    public BinaryTreeIterator(TreeNode<T> root) {
        currentNode = root;
        stack = new Stack<>();
        populateStack(root);
    }

    private void populateStack(TreeNode<T> node) {
        while (node != null) {
            stack.push(node);
            node = node.getLeft(); // 遍历左子树
        }
    }

    @Override
    public boolean hasNext() {
        return !stack.isEmpty();
    }

    @Override
    public T next() {
        if (!hasNext()) {
            throw new NoSuchElementException("No more elements in the binary tree.");
        }

        TreeNode<T> node = stack.pop();
        T value = node.getValue();
        if (node.getRight() != null) {
            populateStack(node.getRight()); // 遍历右子树
        }

        return value;
    }
}
BinaryTreeIterator 类实现了 Iterator 接口，并使用一个栈来辅助实现二叉树的遍历。在构造方法中，根据二叉树的根节点将左子树依次入栈。hasNext() 方法检查栈是否为空，如果栈不为空，则表示还有元素可供遍历。next() 方法从栈中弹出一个节点，并返回其值。如果弹出的节点存在右子树，则将右子树的节点按照遍历顺序入栈。

于是我们可以像下方这样遍历树了！
// 创建一个二叉树
TreeNode<Integer> root = new TreeNode<>(1);
root.setLeft(new TreeNode<>(2));
root.setRight(new TreeNode<>(3));

// 创建迭代器
BinaryTreeIterator<Integer> iterator = new BinaryTreeIterator<>(root);

// 遍历二叉树
while (iterator.hasNext()) {
    Integer value = iterator.next();
    // 处理节点的值
    System.out.println(value);
}
这种方法不好，这里是为了举例子而已，遍历树的更好方法是递归！！！

Comsumer

前面遍历操作我们简单的用print表示了我们对遍历结果的处理，但是在解决实际问题的时候，我们对遍历结果的处理会更加复杂，我们将会更多见到这样的形式
public void loop3(Consumer<Integer> consumer) {
        Iterator<Integer> iterator = iterator();

        while (iterator.hasNext()) {
            Integer value = iterator.next();
            consumer.accept(value);
        }
    }
accept接收到的就是遍历出来的值。comsumer是一个函数接口，我们可以将我们编写的方法输入进去，这给了我们很大的操作空间。

面对一些简单的操作我们会用lambda 表达式操作，代码可读性比较高
public class ConsumerExample {
    public static void main(String[] args) {
        // 定义一个 Consumer 对象
        Consumer<String> printUpperCase = str -> System.out.println(str.toUpperCase());

        // 使用 Consumer 对象
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
        names.forEach(printUpperCase);
    }
}


//accept出来的东西就是这里的value
Consumer<Integer> consumer = value -> {
    // 在这里定义你要执行的逻辑，这里简单打印整数值
    System.out.println("Processing value: " + value);
};
但是我们使用comsumer肯定是因为对于遍历结果的处理比较复杂，那么下面我们就给出更加复杂的情况，我们得以将accept的结果完全作为一个数组
public class Main {
    public static void main(String[] args) {
        Singlelinkedlist Slt = new Singlelinkedlist();
        Consumer<Integer> myConsumer= new MyConsumer();
        Slt.loop3(myConsumer);
    }
    
    static class MyConsumer implements Consumer<Integer> {

        @Override
        public void accept(Integer integer) {
            luanlai666(integer);
        }
        public void luanlai666(int temp){

        }
    }
}
loop3就是我们在前面展示的那段代码，可以看到，现在我们就可以对lunalai666()函数为所欲为了，我们可以很简单的操作遍历的结果。Comsumer作为一个接口可以将一个功能箱类写出来，面对不同的accpet结果我们可以通过重构进行不同处理。

正文结束，可以跑路！！

IV. 封装遍历的性能优化

纸上谈兵的写点

提前终止：在遍历过程中，如果满足了提前终止的条件，可以使用 break 或 return 关键字来退出循环，避免继续遍历剩余的元素。

剪枝操作：在某些情况下，我们可能知道在某个节点的子树中不会存在你需要的元素，因此可以跳过该子树的遍历。这可以通过在遍历过程中添加条件判断来实现，以减少不必要的遍历操作。

迭代代替递归：递归算法在某些情况下可能导致栈溢出或性能不佳。在这种情况下，可以尝试改用迭代算法来替代递归，使用循环和栈或队列来模拟递归的效果。这通常能够提高遍历的性能。

遍历顺序优化：根据具体的需求，选择合适的遍历顺序可以提高算法的效率。例如，在二叉树的遍历中，前序遍历和后序遍历通常比中序遍历更适合某些场景。因此，根据具体的应用场景选择最合适的遍历顺序可以提升性能。

并行遍历：如果你的数据结构支持并发操作，并且遍历操作之间没有依赖关系，可以考虑使用并行遍历来加速遍历过程。通过将数据分割成多个部分，每个部分使用一个线程进行遍历，最后将结果合并，可以利用多核处理器的优势提高遍历效率。

V. 总结

我们今天讨论的只是一小部分情况，比如在Comparable类中我们也会看见comsumer的使用，迭代器的运用也远远比这里介绍的广泛，慢慢学咯！

一个蒜头

关注

25
点赞
踩
20

收藏

觉得还不错? 一键收藏
1
评论
重生之封装数据类型中的遍历

封装遍历的优势包括提高代码的可重用性、可测试性和可维护性。它使得功能可以独立于具体的应用场景进行开发和调试，并且可以在不同的项目和模块中共享和重用。下文我们将针对遍历函数loop（）进行封装方法的探究和比较我们今天讨论的只是一小部分情况，比如在Comparable类中我们也会看见comsumer的使用，迭代器的运用也远远比这里介绍的广泛，慢慢学咯！
复制链接

扫一扫