Java中的搜索算法：从二分搜索到深度优先搜索的应用-CSDN博客

本文链接：https://blog.csdn.net/weixin_44409190/article/details/141108963

Java中的搜索算法：从二分搜索到深度优先搜索的应用

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！今天我们将深入探讨Java中的搜索算法，从经典的二分搜索到图算法中的深度优先搜索，了解它们的应用场景及实现方法。

一、搜索算法概述

搜索算法用于在数据集合中查找特定的元素或信息。在计算机科学中，搜索算法广泛应用于各种场景，如数据库查询、图形处理和游戏开发等。常见的搜索算法包括二分搜索、深度优先搜索（DFS）和广度优先搜索（BFS）。我们将重点讨论二分搜索和深度优先搜索。

二、二分搜索

二分搜索是一种高效的搜索算法，适用于在有序数组中查找元素。它通过将搜索范围不断缩小一半，从而达到快速查找的目的。二分搜索的时间复杂度为O(log n)，其中n是数组的长度。

示例代码：

import cn.juwatech.search.BinarySearchExample;

public class BinarySearchExample {
    
    public static int binarySearch(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (array[mid] == target) {
                return mid;
            } else if (array[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        
        return -1; // 未找到目标元素
    }

    public static void main(String[] args) {
        int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
        int target = 7;
        int index = binarySearch(array, target);

        if (index != -1) {
            System.out.println("元素 " + target + " 在索引 " + index + " 处");
        } else {
            System.out.println("元素 " + target + " 不存在于数组中");
        }
    }
}

在上述代码中，我们实现了一个基本的二分搜索算法。该算法通过不断调整搜索范围，快速定位目标元素的位置。

三、深度优先搜索（DFS）

深度优先搜索是一种用于遍历或搜索树或图的算法。它通过尽可能深入每一个分支，直到遇到终点或无法继续为止。DFS常用于图的遍历、路径查找等场景。DFS的时间复杂度为O(V + E)，其中V是顶点数，E是边数。

示例代码：

import cn.juwatech.search.DepthFirstSearchExample;
import java.util.*;

public class DepthFirstSearchExample {

    private static class Graph {
        private final Map<Integer, List<Integer>> adjList = new HashMap<>();

        public void addEdge(int src, int dest) {
            adjList.computeIfAbsent(src, k -> new ArrayList<>()).add(dest);
            adjList.computeIfAbsent(dest, k -> new ArrayList<>()).add(src);
        }

        public List<Integer> getAdjVertices(int vertex) {
            return adjList.getOrDefault(vertex, new ArrayList<>());
        }
    }

    public static void depthFirstSearch(Graph graph, int start) {
        Set<Integer> visited = new HashSet<>();
        Stack<Integer> stack = new Stack<>();
        stack.push(start);

        while (!stack.isEmpty()) {
            int vertex = stack.pop();

            if (!visited.contains(vertex)) {
                System.out.print(vertex + " ");
                visited.add(vertex);

                for (int neighbor : graph.getAdjVertices(vertex)) {
                    if (!visited.contains(neighbor)) {
                        stack.push(neighbor);
                    }
                }
            }
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Graph graph = new Graph();
        graph.addEdge(0, 1);
        graph.addEdge(0, 2);
        graph.addEdge(1, 3);
        graph.addEdge(1, 4);
        graph.addEdge(2, 5);
        graph.addEdge(2, 6);

        System.out.println("深度优先搜索从顶点 0 开始：");
        depthFirstSearch(graph, 0);
    }
}