算法初探——排序和查找

排序

排序是程序，最多一种算法

• 冒泡排序
• 选择排序
• 插入排序

冒泡排序：

两两比较，找到最大值或者最小值的方式

public class Bubblesortmax {
    public static void main(String[] args) {
        int[] arr={1,2,9,-100,-55,23,-99,0,3,4,8};
        bubblesort(arr);
        for (int i:arr){
            System.out.print(i+", ");
        }
    }

    //冒泡排序 基于大数上浮法
    public static void bubblesort(int[] arr){
        //控制的每一次找到一个最大的数
        for (int i=0;i<arr.length-1;i++){
            for (int j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        arr[i]=arr[i]+arr[j];
        arr[j]=arr[i]-arr[j];
        arr[i]=arr[i]-arr[j];
    }


}

选择排序：

每次找到最小值，将它交换到对应的位置（第一位）

public class Selectsort {
    public static void main(String[] args) {
        int[] arr={1,2,9,-100,-55,23,-99,0,3,4,8};
//        selectsort(arr);
        selectsort02(arr);
        for (int i:arr){
            System.out.print(i+", ");
        }
    }
    //选择排序变种
    private static void selectsort02(int[] arr) {
        for (int i=0;i<arr.length-1;i++) {
            for (int j = i; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    swap(arr,i,j);
                }
            }
        }
    }
    //选择排序
    public static void selectsort(int[] arr) {
        for (int i=0;i<arr.length-1;i++){
            int min =i;
            for (int j=i;j<arr.length;j++){
                if (arr[min]>arr[j]){
                    min =j;
                }
            }
            //默认min=i; 改动过后min=j 就不等于i 就执行if语句！
            if (min!=i){
                swap(arr,i,min);
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        arr[i]=arr[i]+arr[j];
        arr[j]=arr[i]-arr[j];
        arr[i]=arr[i]-arr[j];

    }
}

插入排序：

默认第一个是有序的，第二个开始，向有序进行插入

public class Insertsort {
    public static void main(String[] args) {
        int[] arr={1,2,9,-100,-55,23,-99,0,3,4,8};
        insertsort(arr);
        for (int i:arr){
            System.out.print(i+", ");
        }
    }

    public static void insertsort(int[] arr) {
        for (int i=1;i<arr.length;i++){
            for (int j=i;j>0 && arr[j]<arr[j-1];j--){
                swap(arr,j,j-1);
            }
        }
    }

    public static void swap(int[] arr, int i, int j) {
        arr[i]=arr[i]+arr[j];
        arr[j]=arr[i]-arr[j];
        arr[i]=arr[i]-arr[j];

    }
}

查找：

如果查询是无序数据，效率非常低，只能遍历查询所有值

查询算法：

二分查找（折半查找）

如果查询数据是无序的，那就找线性（遍历）查找

public class Search {
    public static void main(String[] args) {
        int[] arr={1,2,9,-100,-55,23,-99,0,3,4,8};
        Bubblesortmax.bubblesort(arr);

//        int index =linearSearch(arr,8);
        int index =binarySearch(arr,23);
        System.out.println(index);
    }

    //线性查找： 可以查询，但是效率较低，数据多时间长
    public static int linearSearch(int[] arr, int key) {
        for (int i=0;i<arr.length;i++){
            if(key==arr[i]){
                return i;
            }
        }
        return -1;
    }


    //
    public static int binarySearch(int[] arr,int key){
        int start=0;
        int end = arr.length-1;

        while (start<=end){
            int middl = (start+end)/2;

            if(arr[middl]>key){
                end = middl-1;
            }else if(arr[middl]<key){
                start = middl+1;
            }else {
                return middl;
            }
        }
        return -1;
    }
}