【JAVASE系列】12_Array工具类与排序算法

一、Arrays工具类

1、Arrays.sort

使用java.util.Arrays中的排序方法：

    public static void main(String[] args) {
        //工具类当中的方法大部分是静态的
        int[] arr={11,33,44,55,1};
        Arrays.sort(arr);
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }

2、Arrays.search

import java.util.Arrays;
public class ArraySearch {
    public static void main(String[] args) {
        int[] arr={1,3,87,9,2};
        //找出87的下标，如果没有则返回-1
        //方法一：一个个找，效率低


        //方法二：使用工具类的方法
        //第一个参数是数组，第二个参数是被查找的元素
        int index=arraySearch(arr,87);
        System.out.println(index==-1 ? "该元素不存在":"该元素的下标是："+index);
    }

    /**
     * 从数组中检索某个元素的下标
     * @param arr 被检索的某个数组
     * @param i 被检索的元素
     * @return 返回找到的下标 -1表示不存在
     */
    private static int arraySearch(int[] arr, int i) {
        for(int t=0;t<arr.length;t++){
                if(i==arr[t]){
                    System.out.println("87的下标是："+t);
                    return t;
                }
            }
            System.out.println("不存在该元素");
            return -1;
    }
}

3、Arrays.binarySearch

import java.util.Arrays;
public class Test01 {
    public static void main(String[] args) {
        int[] a={4,5,2,3,6,8};
        Arrays.sort(a)
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
        int index=Arrays.binarySearch(a,5);
        System.out.println(index==-1 ? "该元素不存在":"该元素下标是："+index);
    }
}

二、算法

1、冒泡排序算法

public class Bubble {
    public static void main(String[] args) {
        int[] arr={3,1,2,4,5,0};
        //经过冒泡排序对以上算法排序
        int count=0,count2=0;
        for(int i= arr.length-1;i>0;i--){
            for(int j=0;j<i;j++){
                count++;
                if(arr[j]>arr[j+1]){//这里把》改成《就是降序
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    count2++;
                }
            }
        }
        //打印排序之后的结果
        for(int i=0;i< arr.length;i++){
            System.out.println(arr[i]);
        }
        System.out.println("冒泡排序的比较次数："+count);
        System.out.println("冒泡排序的交换次数："+count2);
    }
}

2、选择排序

• 选择排序的效率高于冒泡排序，因为选择排序的交换位置更有意义。
• 思路：每次循环，找到这堆数据当中最小的，然后将找到的最小值与 “ 最前面的交换 ” 。

public class SelectSort {
    public static void main(String[] args) {
        int[] arr={3,1,2,4,5,0};
        int count=0,count2=0;
        for(int i=0;i<arr.length-1;i++){
            int min=i;
            for(int j=i+1;j<arr.length;j++){
                count++;
                if(arr[j]<arr[min]){
                    min=j;
                }
            }
            if(min!=i){
                count2++;
                int temp=arr[min];
                arr[min]=arr[i];
                arr[i]=temp;
            }
        }
        //排序之后打印结果
        for(int i=0;i< arr.length;i++){
            System.out.println(arr[i]);
        }
        System.out.println("选择排序的比较次数："+count);
        System.out.println("选择排序的交换次数："+count2);
    }
}

3、二分法查找

public class ArrayUtil {
    public static void main(String[] args) {
        int[] arr={10,20,23,25,60,100,999};
        //需求：找出arr这个数组所在的下标
        //调用方法
        int index=binarySearch1(arr,60);
        System.out.println(index==-1 ? "该元素不存在":"该元素的下标是："+index);
    }

    /**
     * 从数组当中查找目标元素的下标。
     * @param arr 被查找的数组（必须是已经排序的）
     * @param dest 目标元素
     * @return 返回目标元素的下标,-1表示该元素不存在
     */
    private static int binarySearch1(int[] arr, int dest) {
        int begin=0;
        int end=arr.length-1;
        while (begin <= end) {
            int mid=(begin+end)/2;
            if(arr[mid]==dest){
                return mid;
            }else if(arr[mid] <dest){
                begin=mid+1;
            }else{
                end=mid-1;
            }
        }
        return -1;
    }
}