java学习笔记06-数组排序

数组排序，把数组中的元素通过比较替换 使其变成一个有序的序列
排序方式：冒泡排序，选择排序，插入排序，希尔排序，快速排序，基数排序，堆排序
冒泡排序
数组元素两两排序 大的往后放，进过易迅比较之后最大的出现在最后
实例

int[] arr = {2,5,7,89,565,33,45,67,22,44,55,66,7,8,45,32,11,22,};
        int zj = 0;
        for (int j = 0; j < arr.length; j++) {
            for (int i = 0; i < arr.length-1-j; i++) {
                if (arr[i]>arr[i+1]){
                    zj=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=zj;
                }
            }
        }

选择排序
每次拿一个元素和后面所有的元素挨个进行比较小的朝前放。

int[] arr = {80,5,7,89,565,33,45,67,22,44,55,66,7,8,45,32,11,22,};
        int zj = 0;
        for (int j = 0; j < arr.length-1; j++) {
            for (int i = j; i < arr.length; i++) {
                if (arr[j]>arr[i]){
                    zj=arr[i];
                    arr[i]=arr[j];
                    arr[j]=zj;
                }
            }
        }

插入排序
每次将后面一个元素插入到之前的一个有序序列中，是之仍保持有序

快速排序 挖坑填数

public class MyTest {
    public static void main(String[] args) {
        int[] arr = {20, 40, 2, 3, 7, 8, 1, 0, 9, 45, 30, 100, 200, 30, 50};

        QuickSortUtils.quickSort(arr, 0, arr.length - 1);

        System.out.println(Arrays.toString(arr));
    }
}

public class QuickSortUtils {
    public static void quickSort(int[] arr, int start, int end) {
        //得对左右两区进行递归调用
        //为了分成左右两区那个索引位置
        if (start < end) {
            int index = getIndex(arr, start, end); //
            //对左区进行递归
            quickSort(arr, start, index - 1);
            //对右区进行递归
            quickSort(arr, index + 1, end);
        }
    }
    //1.将基准数挖出形成第一个坑。
    //2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。
    //3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
    //再重复执行2，3两步骤。
    private static int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //定义一个基准数
        int x = arr[i];
        while (i < j) {
            //由后向前找比他小的数，找到后挖出此数填到前一个坑中。
            while (i < j && arr[j] >= x) {//找
                j--;
            }
            //填坑
            if (i < j) {
                arr[i] = arr[j];
                i++;
            }
            //3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
            while (i < j && arr[i] < x) {//找
                i++;
            }
            //填坑
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }
        //将基准数填到最后一个坑中
        arr[i] = x;
        return i;
    }
}

查找
查找思想;前提是数组必须有序，二分查找：每次查找一半
基本查找

 public static void main(String[] args) {
      
        int[] arr = {20, 40, 2, 3, 7, 8, 1, 0, 9, 45, 30, 2,100, 200, 30, 50};

        //根据元素，查询该元素，第一次在数组中出现的索引
        //基本查找
       int index= getIndex(arr,500);
        System.out.println("索引是"+index);
    }
   
    private static int getIndex(int[] arr, int ele) {
        int index=-1;
        for (int j = 0; j < arr.length; j++) {
            if(arr[j]==ele){
               // return j;
                index=j;
                break;
            }
        }
        return index; // -1 表示没找到
    }

二分查找

public static void main(String[] args) {
        //查找思想：前提条件：数组元素必须有序，二分查找：每次查找一半
        int[] arr = {10, 20, 30, 50, 90, 100, 101, 300, 400};
        int index = getIndex(arr, 90);
        System.out.println("索引是" + index);
    }

    //二分查找
    private static int getIndex(int[] arr, int ele) {
        //定义三个索引
        int minIndex = 0;
        int maxIndex = arr.length - 1;
        int centerIndex = (minIndex + maxIndex) / 2;
        while (minIndex <= maxIndex) {
            if (ele == arr[centerIndex]) {
                return centerIndex;
            } else if (ele > arr[centerIndex]) {
                minIndex = centerIndex + 1;
            } else if (ele < arr[centerIndex]) {
                maxIndex = centerIndex - 1;
            }
            //重新计算中间索引
            centerIndex = (minIndex + maxIndex) / 2;
        }
        return -1;
    }