JAVA:常用的算法指南

请关注微信公众号:拾荒的小海螺

博客地址:http://lsk-ww.cn/

1、简述

在软件开发过程中,算法扮演着关键的角色。它们用于解决各种问题,从数据处理到搜索、排序等。本文将介绍几种常见的算法及其 Java 实现,包括排序算法、搜索算法以及图算法。

2、排序算法

2.1 冒泡排序(Bubble Sort)

冒泡排序是一种简单的排序算法。它重复地遍历待排序的数列,依次比较两个相邻的元素,如果它们的顺序错误就交换它们的位置。遍历数列的工作重复进行直到没有相邻元素需要交换为止。

bash 复制代码
public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    // 交换 arr[j] 和 arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {64, 34, 25, 12, 22, 11, 90};
        bubbleSort(arr);
        System.out.println("排序后的数组:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}
2.1 快速排序(Quick Sort)

快速排序是分治法的一种,它通过选择一个基准元素,将数组分为两部分,比基准小的元素放在左边,比基准大的元素放在右边,然后对这两部分分别进行递归排序。

bash 复制代码
public class QuickSort {
    public static void quickSort(int[] arr, int low, int high) {
        if (low < high) {
            int pi = partition(arr, low, high);
            quickSort(arr, low, pi - 1);
            quickSort(arr, pi + 1, high);
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = (low - 1);
        for (int j = low; j < high; j++) {
            if (arr[j] <= pivot) {
                i++;
                // 交换 arr[i] 和 arr[j]
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        // 交换 arr[i+1] 和 arr[high]
        int temp = arr[i + 1];
        arr[i + 1] = arr[high];
        arr[high] = temp;

        return i + 1;
    }

    public static void main(String[] args) {
        int[] arr = {10, 7, 8, 9, 1, 5};
        quickSort(arr, 0, arr.length - 1);
        System.out.println("排序后的数组:");
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

3、搜索算法(二分查找(Binary Search))

二分查找是一种高效的查找算法,适用于已经排序的数组。它通过将数组一分为二,反复缩小查找范围来找到目标值。

bash 复制代码
public class BinarySearch {
    public static int binarySearch(int[] arr, int x) {
        int low = 0, high = arr.length - 1;
        while (low <= high) {
            int mid = low + (high - low) / 2;

            if (arr[mid] == x)
                return mid;

            if (arr[mid] < x)
                low = mid + 1;
            else
                high = mid - 1;
        }

        return -1; // 未找到返回 -1
    }

    public static void main(String[] args) {
        int[] arr = {2, 3, 4, 10, 40};
        int x = 10;
        int result = binarySearch(arr, x);
        if (result == -1)
            System.out.println("元素未找到");
        else
            System.out.println("元素在索引 " + result);
    }
}

4、 图算法

4.1 深度优先搜索(Depth-First Search, DFS)

深度优先搜索是一种用于遍历或搜索图的算法。它从图的某个起始节点开始,沿着一条路径走到底,然后回溯,继续探索新的路径。

bash 复制代码
import java.util.*;

public class GraphDFS {
    private int V; // 顶点个数
    private LinkedList<Integer> adj[]; // 邻接表

    GraphDFS(int v) {
        V = v;
        adj = new LinkedList[v];
        for (int i = 0; i < v; ++i)
            adj[i] = new LinkedList();
    }

    void addEdge(int v, int w) {
        adj[v].add(w); // 添加边
    }

    void DFSUtil(int v, boolean visited[]) {
        visited[v] = true;
        System.out.print(v + " ");

        Iterator<Integer> i = adj[v].listIterator();
        while (i.hasNext()) {
            int n = i.next();
            if (!visited[n])
                DFSUtil(n, visited);
        }
    }

    void DFS(int v) {
        boolean visited[] = new boolean[V];
        DFSUtil(v, visited);
    }

    public static void main(String args[]) {
        GraphDFS g = new GraphDFS(4);

        g.addEdge(0, 1);
        g.addEdge(0, 2);
        g.addEdge(1, 2);
        g.addEdge(2, 0);
        g.addEdge(2, 3);
        g.addEdge(3, 3);

        System.out.println("从顶点 2 开始的深度优先搜索:");
        g.DFS(2);
    }
}
4.2 广度优先搜索(Breadth-First Search, BFS)

广度优先搜索是一种用于遍历或搜索图的算法。它从图的某个起始节点开始,首先访问距离最近的节点,然后逐层向外扩展。

bash 复制代码
import java.util.*;

public class GraphBFS {
    private int V; // 顶点个数
    private LinkedList<Integer> adj[]; // 邻接表

    GraphBFS(int v) {
        V = v;
        adj = new LinkedList[v];
        for (int i = 0; i < v; ++i)
            adj[i] = new LinkedList();
    }

    void addEdge(int v, int w) {
        adj[v].add(w); // 添加边
    }

    void BFS(int s) {
        boolean visited[] = new boolean[V];

        LinkedList<Integer> queue = new LinkedList<>();

        visited[s] = true;
        queue.add(s);

        while (queue.size() != 0) {
            s = queue.poll();
            System.out.print(s + " ");

            Iterator<Integer> i = adj[s].listIterator();
            while (i.hasNext()) {
                int n = i.next();
                if (!visited[n]) {
                    visited[n] = true;
                    queue.add(n);
                }
            }
        }
    }

    public static void main(String args[]) {
        GraphBFS g = new GraphBFS(4);

        g.addEdge(0, 1);
        g.addEdge(0, 2);
        g.addEdge(1, 2);
        g.addEdge(2, 0);
        g.addEdge(2, 3);
        g.addEdge(3, 3);

        System.out.println("从顶点 2 开始的广度优先搜索:");
        g.BFS(2);
    }
}

5、总结

本文介绍了几种常见的算法及其 Java 实现,包括冒泡排序、快速排序、二分查找、深度优先搜索和广度优先搜索。这些算法在实际开发中非常有用,通过掌握它们,可以解决许多常见的编程问题。希望这篇文章能帮助你更好地理解和使用这些算法。

相关推荐
浮生如梦_1 小时前
Halcon基于laws纹理特征的SVM分类
图像处理·人工智能·算法·支持向量机·计算机视觉·分类·视觉检测
XiaoLeisj2 小时前
【JavaEE初阶 — 多线程】单例模式 & 指令重排序问题
java·开发语言·java-ee
paopaokaka_luck2 小时前
【360】基于springboot的志愿服务管理系统
java·spring boot·后端·spring·毕业设计
dayouziei2 小时前
java的类加载机制的学习
java·学习
励志成为嵌入式工程师3 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim
捕鲸叉3 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer3 小时前
【C++】vector 类深度解析:探索动态数组的奥秘
开发语言·c++·算法
Peter_chq3 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
Yaml44 小时前
Spring Boot 与 Vue 共筑二手书籍交易卓越平台
java·spring boot·后端·mysql·spring·vue·二手书籍
小小小妮子~4 小时前
Spring Boot详解:从入门到精通
java·spring boot·后端