【Java开发实训】day05——数组常见算法

news2025/4/7 4:42:14

目录

一、数组翻转

1.1示例代码

1.2适用场景

二、冒泡排序

2.1示例代码

2.2适用场景

三、二分查找

3.1示例代码

3.2适用场景

🌈嗨！我是Filotimo__🌈。很高兴与大家相识，希望我的博客能对你有所帮助。

💡本文由Filotimo__✍️原创，首发于CSDN📚。

📣如需转载，请事先与我联系以获得授权⚠️。

🎁欢迎大家给我点赞👍、收藏⭐️，并在留言区📝与我互动，这些都是我前进的动力！

🌟我的格言：森林草木都有自己认为对的角度🌟。

一、数组翻转

数组翻转是指将数组中的元素按照对称索引位置互相交换。例如，如果有一个数组 {1, 2, 3, 4, 5}，翻转后变成 {5, 4, 3, 2, 1}。

1.1示例代码

数组翻转的示例代码：

public class ArrayReverseExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        
        System.out.println("原始数组:");
        printArray(array);
        
        reverseArray(array);
        
        System.out.println("\n翻转后的数组:");
        printArray(array);
    }
    
    public static void reverseArray(int[] array) {
        int start = 0;
        int end = array.length - 1;
        while (start < end) {
            int temp = array[start];
            array[start] = array[end];
            array[end] = temp;
            start++;
            end--;
        }
    }
    
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

运行截图：

在上面代码中，reverseArray 方法实现了数组翻转的逻辑：使用两个指针 start 和 end，分别指向数组的起始和末尾元素。在循环中，将 start 和 end 指向的元素互换，然后将 start 向右移动一位，end 向左移动一位，直到 start 不小于 end。

1.2适用场景

数组翻转的适用场景：

① 倒序输出：当需要将数组中的元素按照相反的顺序输出时，可以先对数组进行翻转，然后再遍历输出元素。

② 字符串反转：在字符串处理中，有时需要将字符串进行反转操作，此时可以将字符串转换为字符数组，对字符数组进行翻转操作，然后再将字符数组转换回字符串。

③ 实现栈和队列：在实现栈（后进先出）或队列（先进先出）这样的数据结构时，可以使用数组进行存储，并通过翻转数组来实现不同的操作顺序。

二、冒泡排序

冒泡排序是一种简单的排序算法，它重复地遍历要排序的数组，比较每对相邻的元素，并依次交换顺序错误的元素，直到没有需要交换的元素为止。这个过程类似于水泡在水中上浮的过程，故名冒泡排序。

2.1示例代码

冒泡排序的示例代码：

public class BubbleSortExample {
    public static void main(String[] args) {
        int[] array = {5, 1, 12, -5, 16};
        
        System.out.println("原始数组:");
        printArray(array);
        
        bubbleSort(array);
        
        System.out.println("\n排序后的数组:");
        printArray(array);
    }
    
    public static void bubbleSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    // 交换 array[j] 和 array[j + 1]
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
        }
    }
    
    public static void printArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }
}

运行截图：

在上面代码中，bubbleSort 方法实现了冒泡排序算法：外层循环 for (int i = 0; i < n - 1; i++) 控制排序的轮数，其中 n 是数组的长度。内层循环 for (int j = 0; j < n - 1 - i; j++) 在每一轮中遍历数组，并比较相邻元素。如果前一个元素比后一个元素大，则交换它们的位置，确保较大的元素向右移动。

2.2适用场景

冒泡排序的适用场景：

① 小规模数据排序：冒泡排序算法简单易懂，适合处理小规模的数据（一般小于100个元素），在小数据量下性能良好。

② 几乎已排序的数组：如果数组的元素大部分已经处于正确位置，冒泡排序的性能会相对较好，因为它的优化版本可以提前结束排序过程。

③ 实时数据流排序：在某些实时系统中，如果数据流入非常缓慢且对排序的实时性要求不高，可以用冒泡排序进行简单的处理。

三、二分查找

二分查找是一种高效的查找算法，适用于已排序的数组或列表。它通过反复将查找范围减半来定位目标值，直到找到目标或确定目标不存在为止。（前提：数组中的数据必须是有序的）

3.1示例代码

二分查找的示例代码：

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

  int index = binarySearch(array, target);

  if (index != -1) {
   System.out.println("找到目标 " + target + " ，索引位置为：" + index);
  } else {
   System.out.println("目标 " + target + " 未找到。");
  }
 }

 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;
   }

   // 如果目标值比中间值小，向左侧继续查找
   if (array[mid] > target) {
    right = mid - 1;
   }

   // 如果目标值比中间值大，向右侧继续查找
   if (array[mid] < target) {
    left = mid + 1;
   }
  }

  // 如果没有找到目标值，返回 -1
  return -1;
 }
}

运行截图：

在上面代码中，binarySearch 方法实现了二分查找的算法：使用 left 和 right 分别表示当前查找范围的左右边界。在每一轮循环中，计算中间位置 mid。如果目标值等于 array[mid]，则找到目标值，返回 mid。如果目标值小于 array[mid]，则更新 right，缩小查找范围到左半部分。如果目标值大于 array[mid]，则更新 left，缩小查找范围到右半部分。若最终 left > right，表示未找到目标值，返回 -1。