• 作者:老汪软件技巧
  • 发表时间:2024-12-01 17:03
  • 浏览量:

《Java零基础教学》是一套深入浅出的 Java 编程入门教程。全套教程从Java基础语法开始,适合初学者快速入门,同时也从实例的角度进行了深入浅出的讲解,让初学者能够更好地理解Java编程思想和应用。

本教程内容包括数据类型与运算、流程控制、数组、函数、面向对象基础、字符串、集合、异常处理、IO 流及多线程等 Java 编程基础知识,并提供丰富的实例和练习,帮助读者巩固所学知识。本教程不仅适合初学者学习,也适合已经掌握一定 Java 基础的读者进行查漏补缺。

上期回顾

在上一期中,我们讨论了数组的高级操作,深入探讨了多维数组的处理、数组与指针的关系,以及如何使用这些高级操作来提高程序性能。我们学习了如何优化内存使用、如何在多维数组中快速查找元素,以及如何在复杂的数据结构中使用数组作为基础数据单元。这些技巧在大规模数据处理、科学计算和性能要求较高的应用程序中非常有用。

理解了这些高级操作后,本期我们将继续向前迈进,探索数组在实际应用中的具体场景和它在常见算法中的重要性。这将帮助我们更好地理解如何将数组的基本和高级操作应用于实际问题中,为未来的编程工作奠定坚实的基础。

正文

数组作为一种最基础的数据结构之一,具有连续存储、快速随机访问等特性,因此在算法和数据处理的诸多场景中被广泛使用。接下来,我们将深入探讨几种常见的数组应用场景及其对应的算法,以帮助大家更好地理解和运用数组。

排序算法

排序算法是算法设计中最基础也是最常用的一类算法。排序的目标是将一个数组中的元素按照某种特定的顺序(例如从小到大或从大到小)重新排列。以下是几种常用的排序算法及其特点:

冒泡排序(Bubble Sort): 冒泡排序是一种基于比较的排序算法。它的工作原理是反复扫描数组,从第一个元素开始,逐对比较相邻元素。如果前一个元素大于后一个元素,则交换它们的位置。这样,最大的元素会“冒泡”到数组的末尾。冒泡排序的时间复杂度为 (O(n^2)),在数据量较大时效率较低,因此通常只在小规模数据或教学示例中使用。

选择排序(Selection Sort): 选择排序每次都会从未排序部分中选出最小的元素,并将其与未排序部分的第一个元素交换位置。选择排序的主要优点是它只进行 (n - 1) 次交换(其中 (n) 是数组的长度),这使得它比冒泡排序在数据量较小时稍微高效一些。然而,选择排序的时间复杂度同样是 (O(n^2)),不适用于大规模数据集。

插入排序(Insertion Sort): 插入排序通过构建有序序列来进行排序。它逐个将未排序的元素插入到已排序部分的适当位置。对于几乎有序的数据集,插入排序的效率很高,时间复杂度为 (O(n))。在其他情况下,插入排序的时间复杂度为 (O(n^2))。由于其实现简单且对小型数据集表现良好,插入排序常被用作更复杂排序算法(如快速排序、归并排序)中的一种优化手段。

快速排序(Quick Sort): 快速排序是一种分治算法。它通过选择一个“基准”元素,将数组划分为两部分:一部分小于基准,另一部分大于基准。然后,分别对这两部分递归地应用快速排序。快速排序的平均时间复杂度为 (O(n \log n)),在大多数情况下表现优越,但在极端不平衡的情况下,其最坏时间复杂度为 (O(n^2))。

归并排序(Merge Sort): 归并排序同样是一种分治算法。它将数组递归地分成两半,直到每个子数组只有一个元素,然后逐步将这些子数组合并成有序的数组。归并排序的时间复杂度为 (O(n \log n)),且它是一种稳定的排序算法,适合用于大型数据集的外部排序。

这些排序算法各有优劣,不同的应用场景和数据特点决定了选择哪种算法。例如,在处理几乎有序的数据集时,插入排序可能是最好的选择;而对于大规模数据集,快速排序和归并排序通常能提供更好的性能。

理论再多都不如亲自上手实践一下。以下是几种排序算法的简单案例,展示了它们在不同情况下的应用:

实战演练1. 冒泡排序(Bubble Sort)

假设我们有一个数组 [5, 2, 9, 1, 5, 6],我们要将其按从小到大的顺序排序。

代码示例:

public class BubbleSort {
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - i - 1; 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, 2, 9, 1, 5, 6};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr)); // 输出:[1, 2, 5, 5, 6, 9]
    }
}

预期输出结果:[1, 2, 5, 5, 6, 9]

本地实际运行结果展示:

image.png

2. 选择排序(Selection Sort)

选择排序每次选出未排序部分中的最小值,并与当前遍历位置交换。

代码示例:

public class SelectionSort {
    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 交换
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 5, 6};
        selectionSort(arr);
        System.out.println(Arrays.toString(arr)); // 输出:[1, 2, 5, 5, 6, 9]
    }
}

预期输出结果:[1, 2, 5, 5, 6, 9]

本地实际运行结果展示:

image.png

3. 插入排序(Insertion Sort)

插入排序通过将每个元素插入到已排序部分的合适位置来实现排序。

代码示例:

public class InsertionSort {
    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];
            int j = i - 1;
            // 向右移动大于 key 的元素
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
    }
    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 5, 6};
        insertionSort(arr);
        System.out.println(Arrays.toString(arr)); // 输出:[1, 2, 5, 5, 6, 9]
    }
}

预期输出结果:[1, 2, 5, 5, 6, 9]

本地实际运行结果展示:

image.png

4. 快速排序(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++; // 交换 int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } // 交换基准元素 int temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp; return i + 1; } public static void main(String[] args) { int[] arr = {5, 2, 9, 1, 5, 6}; quickSort(arr, 0, arr.length - 1); System.out.println(Arrays.toString(arr)); // 输出:[1, 2, 5, 5, 6, 9] } }

预期输出结果:[1, 2, 5, 5, 6, 9]

本地实际运行结果展示:

image.png

5. 归并排序(Merge Sort)

归并排序通过递归地将数组分成两部分并合并成有序数组来进行排序。

代码示例:

public class MergeSort {
    public static void mergeSort(int[] arr, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(arr, left, mid); // 左部分排序
            mergeSort(arr, mid + 1, right); // 右部分排序
            merge(arr, left, mid, right); // 合并
        }
    }
    private static void merge(int[] arr, int left, int mid, int right) {
        int n1 = mid - left + 1;
        int n2 = right - mid;
        int[] L = new int[n1];
        int[] R = new int[n2];
        
        System.arraycopy(arr, left, L, 0, n1);
        System.arraycopy(arr, mid + 1, R, 0, n2);
        
        int i = 0, j = 0, k = left;
        while (i < n1 && j < n2) {
            if (L[i] <= R[j]) {
                arr[k] = L[i];
                i++;
            } else {
                arr[k] = R[j];
                j++;
            }
            k++;
        }
        
        while (i < n1) {
            arr[k] = L[i];
            i++;
            k++;
        }
        
        while (j < n2) {
            arr[k] = R[j];
            j++;
            k++;
        }
    }
    public static void main(String[] args) {
        int[] arr = {5, 2, 9, 1, 5, 6};
        mergeSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr)); // 输出:[1, 2, 5, 5, 6, 9]
    }
}

预期输出结果:[1, 2, 5, 5, 6, 9]

本地实际运行结果展示:

image.png

如上我这些案例展示了五种常见排序算法的简单实现,分别适用于不同的数据量和场景。大家在选择排序算法时,可以根据数据的规模和具体需求来决定使用哪种算法。

查找算法

查找算法用于在数据集中找到一个特定的元素或满足条件的元素。常见的查找算法包括:

线性查找(Linear Search): 线性查找是一种简单但效率不高的查找算法。它从数组的第一个元素开始,逐一检查每个元素,直到找到目标元素或遍历完数组。线性查找的时间复杂度为 (O(n)),适用于数据规模较小或者无序的数组。

二分查找(Binary Search): 二分查找是一种在有序数组中查找元素的高效算法。它每次将查找范围缩小一半,从而大大减少了查找时间。二分查找的时间复杂度为 (O(\log n)),适用于数据规模较大且已经排序的数组。然而,二分查找的前提条件是数据必须有序,这通常意味着需要在查找之前先进行排序。

跳跃查找(Jump Search): 跳跃查找是对线性查找和二分查找的一种折中。它在一个有序数组中分块查找,通过跳跃一定步长来定位大致范围,然后在小范围内进行线性查找。跳跃查找的时间复杂度为 (O(\sqrt{n})),适用于数据规模适中且不经常变化的有序数组。

数组去重

在实际编程中,数组去重是一个常见的任务。去重的目标是删除数组中的重复元素,通常需要保持元素的相对顺序不变。常见的去重方法包括:

利用哈希表(Hash Table): 使用哈希表来存储已经遇到的元素。遍历数组时,如果当前元素未在哈希表中出现过,则将其添加到结果数组和哈希表中。该方法的时间复杂度为 (O(n)),但需要额外的 O(n) 空间用于哈希表。

双指针法(Two-pointer Technique): 这种方法适用于有序数组。通过使用两个指针,一个指向当前不重复元素的位置,另一个遍历数组找到下一个不同的元素。该方法的时间复杂度为 (O(n)),空间复杂度为 O(1)。

排序后去重: 将数组先进行排序,然后在遍历数组时跳过重复的元素。虽然排序的时间复杂度为 Olog n,但去重操作本身只需 O(n) 的时间。这种方法适用于可以改变数组顺序的场景。

数组元素统计

统计数组中元素的频率也是一个常见任务。例如,我们可能需要找出数组中出现次数最多的元素,或者统计每个元素出现的次数。常见的实现方法包括:

哈希表计数法: 使用哈希表(或字典)来记录每个元素出现的次数。遍历数组,更新哈希表中的计数,最终得到每个元素的频率。该方法的时间复杂度为 O(n),但需要额外的 O(n)空间。

排序后统计法: 先对数组进行排序,然后遍历已排序的数组统计每个元素的频率。这种方法的时间复杂度为 (Olog n),适用于数据集较小或者不能使用额外空间的情况。

摩尔投票算法(Boyer-Moore Voting Algorithm): 特别适用于“多数元素”问题,即找到数组中出现次数超过一半的元素。摩尔投票算法的时间复杂度为 O(n),空间复杂度为 O(1)。

数组在动态编程中的应用

数组在动态编程中也有着广泛的应用,尤其是在存储中间结果(即“子问题的解”)时发挥了关键作用。例如,在解决背包问题、最长公共子序列问题、最小路径和问题等典型动态规划问题时,数组被用于存储每个子问题的解,从而避免重复计算,极大地提高了算法效率。

7. 数组与集合的区别与转换

在理解了数组在各种算法中的应用之后,我们将进入下一期的内容,深入探讨数组和集合(Set)之间的区别及其相互转换。

数组和集合是两种常用的数据结构,尽管它们在许多编程任务中有着类似的作用,但它们之间有着明显的区别。例如,数组是有序的、可重复的,而集合是无序的、不允许重复。我们将分析这些差异,以及如何在实际应用中根据需要进行数组和集合之间的相互转换,帮助大家在编程中做出最佳的数据结构选择。

预告:

数组与集合的区别与转换在下一期中,我们将详细介绍:

数组与集合的基础特性和区别适合使用数组和集合的场景分析数组和集合之间的转换方法及其效率比较如何在实际项目中选择合适的数据结构

敬请期待,这将帮助你在编写代码时做出更明智的选择!

最后

大家如果觉得看了本文有帮助的话,麻烦给不熬夜崽崽点个三连(点赞、收藏、关注)支持一下哈,大家的支持就是我写作的无限动力。