Java 数组常见的排序和查找算法

2、数组
2.1、常见的算法：
排序算法：
冒泡排序算法
选择排序算法

查找算法：
二分法查找

2.2、算法实际上在 java 中已经封装好了。
排序可以调用方法。例如：java 中提供了一个数组工具类：
java.util.Arrays
Arrays 是一个工具类。
其中有一个 sort() 方法，可以排序。静态方法，直接使用类名调用就行。
工具类当中的方法大部分都是静态的。
java 有一套庞大的类库。

冒泡排序算法：
1、每一次循环结束之后，都要找出最大的数据，放到参与比较的这堆数据的最右边。（冒出最大的那个气泡。）
2、核心：拿着左边的数字和右边的数字比对，当左边＞右边的时候，交换位置。
例：
原始数据：
3，2，7，6，8
第1次循环：（最大的数跑到最右边。）
2，3，7，6，8（3和2比较，2<3，所以2和3交换位置）
2，3，7，6，8（虽然不需要交换位置：但是3 和7 还需要比较一次。）
2，3，6，7，8（7和6交换位置）
2，3，6，7，8（虽然不需要交换位置：但是7 和8 还需要比较一次。）
经过第1次循环，此时剩下参与比较的数据：2,3,6,7
第2次循环：
2，3，6，7（2和3比较，不需要交换位置）
2，3，6，7（3和6比较，不需要交换位置）
2，3，6，7（6和7比较，不需要交换位置）
经过第2次循环，此时剩下参与比较的数据：2,3,6
第3次循环：
2，3，6（2和3比较，不需要交换位置）
2，3，6（3和6比较，不需要交换位置）
经过第3次循环，此时剩下参与比较的数据：2,3
第4次循环：
2，3（2和3比较，不需要交换位置）

选择排序：
每一次从这堆“参与比较的数据当中”找出最小值，
拿着这个最小值和“参与比较的的这堆最前面的元素”交换位置。

选择排序比冒泡排序好在：每一次的交换位置都是有意义的。

选择排序比冒泡排序的效率高。高在交换位置的次数上。
循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和最前面的数据交换位置。

原始数据：3 1 6 2 5
参与比较的数据：3 1 6 2 5
第1次循环之后的结果是：
1 3 6 2 5

参与比较的数据：3 6 2 5
第2次循环之后的结果是：
2 6 3 5

参与比较的数据：6 3 5
第三次循环之后的结果是：
3 6 5

参与比较的数据：6 5
第四次循环之后的结果是：
5 6

注意：5条数据，循环4次。
例：
冒泡排序：
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
bubbleSort(arr);
System.out.println(“排序后的数组：”);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}

public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换两个相邻的元素
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

}
输出结果为：
排序后的数组：
11 12 22 25 34 64 90

选择排序：
public class SelectionSort {
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
selectionSort(arr);
System.out.println(“排序后的数组：”);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}

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[minIndex];
        arr[minIndex] = arr[i];
        arr[i] = temp;
    }
}

}
输出结果为：
排序后的数组：
11 12 22 25 34 64 90

快速排序：
import java.util.Arrays;

public class QuickSort {
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
quickSort(arr, 0, arr.length - 1);
System.out.println(“排序后的数组：”);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}

public static void quickSort(int[] arr, int low, int high) {
    if (low < high) {
        int pivotIndex = partition(arr, low, high);
        quickSort(arr, low, pivotIndex - 1);
        quickSort(arr, pivotIndex + 1, high);
    }
}

private static int partition(int[] arr, int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为枢轴
    int i = low - 1; // 索引 i 表示小于枢轴的元素的分界点

    for (int j = low; j <= high - 1; 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;
}

}
输出结果为：
排序后的数组：
11 12 22 25 34 64 90

归并排序：
public class MergeSort {
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
mergeSort(arr, 0, arr.length - 1);
System.out.println(“排序后的数组：”);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}

public static void mergeSort(int[] arr, int low, int high) {
    if (low < high) {
        int middle = (low + high) / 2;
        mergeSort(arr, low, middle);
        mergeSort(arr, middle + 1, high);
        merge(arr, low, middle, high);
    }
}

private static void merge(int[] arr, int low, int middle, int high) {
    int[] temp = new int[high - low + 1];
    int i = low;
    int j = middle + 1;
    int k = 0;

    while (i <= middle && j <= high) {
        if (arr[i] <= arr[j]) {
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }

    while (i <= middle) {
        temp[k++] = arr[i++];
    }

    while (j <= high) {
        temp[k++] = arr[j++];
    }

    for (int p = 0; p < temp.length; p++) {
        arr[low + p] = temp[p];
    }
}

}
输出结果为：
排序后的数组：
11 12 22 25 34 64 90

数组的元素查找
数组元素查找有两种方式：
第一种方式：一个一个挨着找，直到找到为止。
第二种方式：二分法查找（算法），这个效率较高。

二分法查找（折半查找）：
第一：二分法查找建立在排序的基础之上。
第二：二分法查找效率要高于“一个挨着一个”的这种查找方式。
第三：二分法查找原理？
10（0下标） 23 56 89 100 111 222 235 600(下标9) arr数组
目标：找出600的下标
(0 + 9) / 2 --> 4（中间元素的下标）
arr[4]这个元素就是中间元素：arr[4]是100
100 < 600
说明被查找的元素在100的右边。
那么此时开始下标变成：4+1
(5 + 9) / 2 --> 7（中间元素的下标）
arr[7] 对应的是：235
235 < 600
说明被查找的元素在235的右边。
开始下标又进行了转变：7 + 1
(8 + 9)/2 --> 8
arr[8] --> 500
500 < 600
开始元素的下标又发生了变化：8 + 1
(9 + 9) / 2 --> 9
arr[9]是600，正好和600相等，此时找到了。
二分法查找的终止条件：一直折半，直到中间的那个元素恰好是被查找的元素。
3、二分法查找算法是基于排序的基础之上。（没有排序的数据是无法查找的。）
例：
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1, 2, 5, 67, 8, 29, 100, 300};
int target = 5;

    int index = binarySearch(arr, target);
    if (index != -1) {
        System.out.println("找到目标值，下标为：" + index);
    } else {
        System.out.println("未找到目标值");
    }
}

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) {
            left = mid + 1; // 目标元素在右半部分，更新left
        } else {
            right = mid - 1; // 目标元素在左半部分，更新right
        }
    }

    return -1; // 查找失败，返回-1
}

}
输出结果为：
找到目标值，下标为：3
因此，值为5的下标为3。

介绍一下java.util.Arrays工具类
所有方法都是静态的，直接用类名调用
主要使用的是两个方法：
二分法查找，排序
以后要看文档，不要死记硬背。