01选择排序、冒泡排序、插入排序、二分查找

算法复杂度

时间复杂度：算法中基本操作重复执行的次数N，一般使用O(N)来表示。时间复杂度一般表示最简化，比如一个基本操作的重复次数为（aN^{2+bN+c），则时间复杂度为O(N}2)。这为时间复杂度的指标。

评价一个算法流程的好坏，一般先看时间复杂度的指标，然后在分析不同数据样本下的实际运行时间，也就是“常数项时间”。

时间复杂度一般为最坏的时间的复杂度

---

选择排序 O(N^2)

**原理：**第一次从待排序的元素中选择最小的，存放在序列的起始位置，然后再从剩余的数据元素中找出最小的元素，存放到已排序的序列的末尾。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-itXOW8BB-1617700315019)(F:\2笔记整理\images\image-20210404172339910.png)]

	/*
    简单选择排序
     */
    public int[] selectSort(int arr[]){
        if(arr==null){//判断为空
            return null;
        }else if (arr.length==1){//判断数组长度为1
            return arr;
        }
        for (int i=0;i<arr.length-1;i++){
            int minIndex = i; //开始的数标
            for (int j=i+1;j<arr.length;j++){
                minIndex = arr[j]<arr[minIndex] ? j :minIndex;
            }
            swap(arr,i,minIndex); //数组元素进行交换
        }
        return arr;
    }

---

冒泡排序 O(N^2)

**原理：**依次比较两个相邻的元素，若前面的元素比后面的元素大，则会及进行交换，走访元素的工作是重复地进行直到没有相邻元素需要交换，每次排序都会确定一个最终的位置。

	//冒泡排序
    public int[] bubbleSort(int arr[]){
        if(arr==null){//判断为空
            return null;
        }else if (arr.length==1){//判断数组长度为1
            return arr;
        }
        for (int i = arr.length - 1; i > 0; i--){
            for (int j = 0; j < i; j++){
                if (arr[j] > arr[j+1]){
                    Utils.swap(arr,j,j+1);
                }
            }
        }

        return arr;
    }

插入排序 O(N^2)

**原理：**将一个记录插入到已经排序好的有序表中。一般称为直接插入排序，对于少量元素的排序，是一个有效的算法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uphxkmKG-1617700315024)(F:\2笔记整理\images\8d5494eef01f3a294cf1c6979625bc315c607ca9.png)]

//插入排序
public int[] insertSort(int arr[]){

    if(arr==null){//判断为空
        return null;
    }else if (arr.length==1){//判断数组长度为1
        return arr;
    }
    for (int i = 1; i<arr.length; i++){
        for (int j = i-1 ; j >= 0 && arr[j] > arr[j+1]; j--) {
            Utils.swap(arr,j,j+1);
        }
    }

    return arr;
}

---

二分查找

二分查找也叫折半查找，要求查找的数据元素必须是有序排列的

**原理：**假设当前数据元素升序排列，将我们要查找的元素与中间位置的元素进行比较，若相等则返回，若不相等，则有两种情况，若要查找的数据大于中间的数据，那么将要查找的数据与中间数据的右侧再次进行二分查找；若要查找的数据小于中间的数据，那么将要查找的数据与中间数据的左侧再次进行二分查找。重复以上过程，直到查找成功，或者查找的子表不存在为止。

public  boolean exit(int arr[],int num){
        if (arr == null || arr.length == 0){
            return false;
        }
        int left = 0;
        int right = arr.length - 1;
        int mid = 0;
        while (left < right){
            mid=left + ((left + right) >> 1);   //获取中间位置
            if(arr[mid] == num){
                return true;
            }else if (arr[mid] < num){
                right = mid -1;
            }else if (arr[mid] > num){
                left = mid + 1;
            }
        }
        return arr[right] == num;
}

扩展问题

在某个有序数组中，找>=某个数最左侧的位置

原理：使用二分查找的思想，中间位置与这个数进行比较，若>=这个数，则标记此位置，并在中间位置的左边再次进行查找，若不>=则在中间位置的右边进行查找，重复此过程。

public int nearLeftArr(int arr[],int num){         
    int left = 0;
    int right = arr.length - 1;
    int index = -1;
    while (left < right){
        int mid = left + ((left + right) >> 1);
        if (arr[mid] >= num){
            index = mid;
            right = mid - 1;
        }else {
            left = mid + 1;
        }
    }
    return index;
}
            index = mid;
            right = mid - 1;
        }else {
            left = mid + 1;
        }
    }
    return index;
}

一起加油，奥利给！！！