JAVA常用的算法来了

1、简述

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

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

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)

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

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

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)

深度优先搜索是一种用于遍历或搜索图的算法。它从图的某个起始节点开始,沿着一条路径走到底,然后回溯,继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)

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

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

 

原创文章,作者:guozi,如若转载,请注明出处:https://www.sudun.com/ask/78248.html

(0)
guozi的头像guozi
上一篇 2024年5月29日
下一篇 2024年5月29日

相关推荐

  • cdn服务商,cdn服务公司

    CDN服务商:加速网站,提升用户体验 在当今数字化时代,网站的性能和速度对于用户体验至关重要。CDN(内容分发网络)服务商在这一领域发挥着关键作用,通过将内容分发到全球各地的服务器…

    2024年5月11日
    0
  • 探索网络架构的关键角色:六种常用的服务器类型

    在今天的数字时代,服务器是支撑各种在线服务和应用的基石。不同类型的服务器在网络架构中扮演着不同的角色,从网页传输到电子邮件交换,再到文件传输和内容分发。本文将深入探讨六种最常用的服…

    CDN资讯 2024年4月14日
    0
  • 如何承担责任?

    优秀的领导与其他人的区别在于,他们对自己的言行和结果负责。而且,这在好的时候或坏的时候都是如此。责任推动信任,促使更好的决策,并改善团队合作和协作。一个负责任的领导对其言行和决策负…

    CDN资讯 2024年4月6日
    0
  • API网关的工作原理与实战案例

    API网关的工作原理与实战案例API网关是一个在微服务架构中起到重要作用的组件。它可以处理所有客户端请求并对它们进行统一的管理和路由。本文将介绍API网关的工作原理,并给出一个基于…

    CDN资讯 2024年4月20日
    0

发表回复

您的电子邮箱地址不会被公开。 必填项已用 * 标注