滚雪球学Java(33):数组算法大揭秘:应用案例实战分享

简介: 【5月更文挑战第8天】🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,希望能够助你一臂之力,帮你早日登顶实现财富自由🚀;同时,欢迎大家关注&&收藏&&订阅!持续更新中,up!up!up!!

🏆本文收录于「滚雪球学Java」专栏,专业攻坚指数级提升,助你一臂之力,带你早日登顶🚀,欢迎大家关注&&收藏!持续更新中,up!up!up!!


前言

数组是最常用的数据结构之一,在各种编程语言中都有广泛应用。在Java中,数组可以直接使用,也可以通过集合框架中的List、Set等数据结构来实现。但是,在实际开发中,我们常常需要对数组进行一些操作,比如排序、查找、过滤等。这些操作需要使用一些数组算法。

本文将介绍一些常用的数组算法,包括排序、查找、过滤等。我们将通过实际案例来展示这些算法的应用。我们将使用Java编程语言来实现这些算法,并且提供源代码、方法介绍、测试用例等详细信息。希望本文能够帮助您更好地理解数组算法。

摘要

本文将介绍以下几种数组算法:

  1. 冒泡排序算法
  2. 快速排序算法
  3. 二分查找算法
  4. 过滤算法

我们将通过实际案例来展示这些算法的应用,并提供源代码、方法介绍、测试用例等详细信息。

正文

1. 冒泡排序算法

冒泡排序是一种简单的排序算法,它的基本思想是比较相邻的元素。如果第一个比第二个大,就交换它们两个。对第一轮排序后,在剩下的元素中再进行第二轮排序,以此类推。这样每一轮排序结束后,都会将最大的元素排到最后面。

以下是冒泡排序算法的Java实现:

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]) {
   
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

上面的代码中,我们使用了两个嵌套循环来实现冒泡排序。外层循环控制排序轮数,内层循环控制比较的次数。在内层循环中,我们比较相邻的元素,如果前面的元素比后面的大,就交换它们两个。

2. 快速排序算法

快速排序是一种常用的排序算法,它的基本思想是挖坑填数。具体来说,我们先从数列中取出一个数作为基准数,然后将比它小的数放在左边,比它大的数放在右边。接着,我们再对左右两边的子数列进行递归处理,直到整个序列有序为止。

以下是快速排序算法的Java实现:

public static void quickSort(int[] arr, int left, int right) {
   
    if (left < right) {
   
        int i = left;
        int j = right;
        int pivot = arr[left];
        while (i < j) {
   
            while (i < j && arr[j] >= pivot) {
   
                j--;
            }
            if (i < j) {
   
                arr[i] = arr[j];
                i++;
            }
            while (i < j && arr[i] < pivot) {
   
                i++;
            }
            if (i < j) {
   
                arr[j] = arr[i];
                j--;
            }
        }
        arr[i] = pivot;
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }
}

上面的代码中,我们使用了递归来实现快速排序。在每一轮排序中,我们首先选取一个基准数,然后从序列的两端开始比较,将比基准数小的数放在左边,比基准数大的数放在右边。在比较过程中,我们使用两个指针i和j来记录左右两边位置,最后将基准数插入到i的位置。

3. 二分查找算法

二分查找是一种常用的查找算法,它的基本思想是将查找区间不断缩小,直到找到目标元素或者查找区间为空。具体来说,我们先将查找区间定为整个序列,然后取中间位置的元素与目标元素比较。如果中间位置的元素等于目标元素,则直接返回该位置。如果中间位置的元素小于目标元素,则查找区间缩小到右半部分。否则查找区间缩小到左半部分。重复上述过程,直到找到目标元素或者查找区间为空。

以下是二分查找算法的Java实现:

public static int binarySearch(int[] arr, int target) {
   
    int left = 0;
    int right = arr.length - 1;
    while (left <= right) {
   
        int mid = (left + right) / 2;
        if (arr[mid] == target) {
   
            return mid;
        } else if (arr[mid] < target) {
   
            left = mid + 1;
        } else {
   
            right = mid - 1;
        }
    }
    return -1;
}

上面的代码中,我们使用了循环来实现二分查找。在每一轮查找中,我们首先计算中间位置mid,然后将中间位置的元素与目标元素比较。如果相等,则直接返回中间位置。如果目标元素小于中间元素,则将查找区间缩小到左半部分。如果目标元素大于中间元素,则将查找区间缩小到右半部分。重复上述过程,直到找到目标元素或者查找区间为空。

4. 过滤算法

过滤算法是一种常用的数组处理算法,它的基本思想是筛选符合要求的元素,并将它们存放在一个新的数组中。具体来说,我们首先遍历原数组中的每一个元素,然后判断它是否符合某个条件。如果符合条件,则将它存放在新数组中。最后返回新数组。

以下是过滤算法的Java实现:

public static int[] filter(int[] arr, Filter filter) {
   
    int[] result = new int[arr.length];
    int count = 0;
    for (int i = 0; i < arr.length; i++) {
   
        if (filter.filter(arr[i])) {
   
            result[count++] = arr[i];
        }
    }
    return Arrays.copyOf(result, count);
}

public interface Filter {
   
    boolean filter(int value);
}

上面的代码中,我们为过滤算法定义了一个Filter接口,用于表示过滤条件。在filter方法中,我们首先创建一个新数组result,并定义一个count变量计数符合条件的元素个数。然后遍历原数组中的每一个元素,如果符合条件,则将它存放在新数组中,并将count加1。最后,我们使用Arrays.copyOf方法将新数组缩小到count大小,并返回新数组。

测试用例

1. 冒泡排序算法

public class BubbleSort {
   
    public static void bubbleSort(int[] arr) {
   
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) {
   
            for (int j = 0; j < len - 1 - i; j++) {
   
                if (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 = {
   5, 3, 8, 6, 4};
        bubbleSort(arr);
        for (int i : arr) {
   
            System.out.print(i + " ");
        }
    }
}

输出结果:

3 4 5 6 8

2. 快速排序算法

public class QuickSort {
   
    public static void quickSort(int[] arr, int left, int right) {
   
        if (left < right) {
   
            int i = left;
            int j = right;
            int pivot = arr[left];
            while (i < j) {
   
                while (i < j && arr[j] >= pivot) {
   
                    j--;
                }
                if (i < j) {
   
                    arr[i++] = arr[j];
                }
                while (i < j && arr[i] <= pivot) {
   
                    i++;
                }
                if (i < j) {
   
                    arr[j--] = arr[i];
                }
            }
            arr[i] = pivot;
            quickSort(arr, left, i - 1);
            quickSort(arr, i + 1, right);
        }
    }

    public static void main(String[] args) {
   
        int[] arr = {
   5, 3, 8, 6, 4};
        quickSort(arr, 0, arr.length - 1);
        for (int i : arr) {
   
            System.out.print(i + " ");
        }
    }
}

输出结果:

3 4 5 6 8

3. 二分查找算法

public class BinarySearch {
   
    public static int binarySearch(int[] arr, int target) {
   
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
   
            int mid = left + (right - left) / 2;
            if (arr[mid] == target) {
   
                return mid;
            } else if (arr[mid] > target) {
   
                right = mid - 1;
            } else {
   
                left = mid + 1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
   
        int[] arr = {
   1, 2, 3, 4, 5};
        int target = 4;
        int index = binarySearch(arr, target);
        System.out.println(index);
    }
}

输出结果:

3

4. 过滤算法

import java.util.ArrayList;
import java.util.List;

public class FilterAlgorithm {
   
    public static List<Integer> filter(List<Integer> list) {
   
        List<Integer> result = new ArrayList<>();
        for (int i : list) {
   
            if (i % 2 == 0) {
   
                result.add(i);
            }
        }
        return result;
    }

    public static void main(String[] args) {
   
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        List<Integer> result = filter(list);
        for (int i : result) {
   
            System.out.print(i + " ");
        }
    }
}

输出结果:

2 4

附录源码

  如上涉及所有源码均已上传同步在 Gitee,提供给同学们一对一参考学习,辅助你更迅速的掌握。

☀️建议/推荐你


  无论你是计算机专业的学生,还是对编程有兴趣的小伙伴,都建议直接毫无顾忌的学习此专栏「滚雪球学Java」,bug菌郑重承诺,凡是学习此专栏的同学,均能获取到所需的知识和技能,全网最快速入门Java编程,就像滚雪球一样,越滚越大,指数级提升。

目录
相关文章
|
19小时前
|
算法 Java
java算法_输出只有235组成的数字
java算法_输出只有235组成的数字
10 5
|
15小时前
|
人工智能 算法 Java
java中经典算法代码整理
java中经典算法代码整理
13 0
|
16小时前
|
Java
java将字符串按照指定长度分割成字符串数组
java将字符串按照指定长度分割成字符串数组
5 0
|
16小时前
|
Java
java代码块和具体的代码应用
java代码块和具体的代码应用
|
22小时前
|
人工智能 算法 搜索推荐
Java算法编程详解和程序实例
Java算法编程详解和程序实例
|
23小时前
|
Java
java中将集合数组转换为Stream流
java中将集合数组转换为Stream流
6 0
|
23小时前
|
Java
java的lambda延时执行特性案例
java的lambda延时执行特性案例
6 0
|
23小时前
|
SQL 监控 Java
技术前沿:Java连接池技术的最新发展与应用
【6月更文挑战第24天】Java连接池技术持续演进,提升高性能和低延迟,如HikariCP因卓越性能受青睐。现代连接池实现智能管理与监控,增强扩展性和兼容性。最佳实践包括选择适合的连接池(如HikariCP)、优化配置参数、利用监控工具及优化DB操作。示例展示了使用HikariCP配置连接池的基本步骤。
|
1天前
|
算法 Java 数据库连接
从连接到效率:Java连接池技术详解与应用
【6月更文挑战第24天】Java连接池优化数据库访问,减少连接创建/关闭开销,提升性能和稳定性。它包括连接池管理器、连接池和连接工厂组件。
|
1天前
|
缓存 Java API
使用GraphQL优化Java应用的API性能
使用GraphQL优化Java应用的API性能