day_08 排序、查找

1. 复习

数组的特点

1. 数组只能存储同类型的元素
2. 数组在初始化的时候 必须指定长度 而且长度 一旦指定 则不能更改
3. 对于数组 分配的内存空间是连续的
4. 数组中的 元素是通过索引（下标/角标）来进行引用。

jvm的内存结构

寄存器（程序计数器）
本地方法栈
虚拟机栈
方法区
堆区

数组的常见操作：

1. 取值赋值
2. 数组遍历
3. 获取最值

2. 算法：

递归算法：阶乘

数组的排序算法

冒泡排序
快速排序

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {21,35,12,20,65,5,56};
        quick(arr);
        for (int j : arr){
            System.out.println(j);
        }
    }
    public  static  void  quick(int[] arr){
        if(arr == null || arr.length== 0 || arr.length==1){
            return;
        }
       sort(arr,0,arr.length-1);
    }
    // 快速排序的核心算法

    /**
     *
     * @param arr 待排序的数组
     * @param left 数组排序时左标记位
     * @param right 数组排序时右标记位
     */
    public  static void sort(int[] arr , int left,int right){
        int i = left;
        int j = right;
        if(i > j ){
            return;
        }
        int base = arr[left];
        while(i != j){

            // 先从右边开始  找比基准元素小的元素
            while(arr[j] >= base && i < j){
                j--;
            }
            // 从左边开始  找比基准元素大的元素
            while (arr[i] <= base && i < j ){
                i++;
            }
            // 交换两个元素的 位置
            if(i < j ){
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
        // 基准元素归为 回到中间位置 i的位置
        arr[left] = arr[i];
        arr[i] = base;
        // 对一次之后的左边进行递归排序
        sort(arr,0,i -1);
        //对右边进行排序
        sort(arr,i+ 1,right);
    }
}

选择排序

选择排序是一种简单直观的排序算法
	工作原理为：在未排序的序列中找出最小(大)元素与第一个位置的元素交换位置
注意选择排序与冒泡排序的区别：
	冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；
	选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。
	然后在剩下的元素中再找最小(大)元素与第二个元素的位置交换，依此类推，直到所有元素排序排序完成。
	根据上述描述，一共进行n-1趟比较后，就能完成整个排队过程。
	我们可以知道，
		第k趟比较需要进行的数组元素的两两比较的次数为n-k次，所以共需要的比较次数为n*(n-1) / 2，
		因此选择排序算法的时间复杂度与冒泡排序一样，也为O(n^2)。
算法简介：
	1.初始状态：序列为无序状态。
	2.第1次排序：从n个元素中找出最小(大)元素与第1个记录交换
	3.第2次排序：从n-1个元素中找出最小(大)元素与第2个记录交换
	4.第i次排序：从n-i+1个元素中找出最小(大)元素与第i个记录交换
	5.以此类推直到排序完成

选择排序可以看作时冒泡排序的一个改进 减少了交换的 次数  而比较的 趟数时一样的

blic class SelectSort {
    public static void main(String[] args) {
        int[] arr =  {21,35,12,20,65,5,56};
       /* //第一趟选择 将最小的元素放在0号位置
        int min = 0; // min来记录当前最小的元素所在的位置
        for (int i = 0 ; i < arr.length;i++){
            if(arr[i] < arr[min]){
                min = i;
            }
        }
        // 比较结束之后  min记录的就是当前最小的
        // 元素所在的位置  将最小的元素和当前元素进行位置 的交换
        int temp = arr[0];
        arr[0] = arr[min];
        arr[min]= temp;

        //第二趟选择 将最小的元素放在0号位置
        min = 1; // min来记录当前最小的元素所在的位置
        for (int i = 1 ; i < arr.length;i++){
            if(arr[i] < arr[min]){
                min = i;
            }
        }
        // 比较结束之后  min记录的就是当前最小的
        // 元素所在的位置  将最小的元素和当前元素进行位置 的交换
        temp = arr[1];
        arr[1] = arr[min];
        arr[min]= temp;
        //第三趟选择 将最小的元素放在0号位置
        min = 2; // min来记录当前最小的元素所在的位置
        for (int i = 2 ; i < arr.length;i++){
            if(arr[i] < arr[min]){
                min = i;
            }
        }
        // 比较结束之后  min记录的就是当前最小的
        // 元素所在的位置  将最小的元素和当前元素进行位置 的交换
        temp = arr[2];
        arr[2] = arr[min];
        arr[min]= temp;*/
        for(int j = 0 ; j < arr.length -1;j++){
            int min = j; // min来记录当前最小的元素所在的位置
            for (int i = j ; i < arr.length;i++){
                if(arr[i] < arr[min]){
                    min = i;
                }
            }
            // 比较结束之后  min记录的就是当前最小的
            // 元素所在的位置  将最小的元素和当前元素进行位置 的交换
            int  temp = arr[j];
            arr[j] = arr[min];
            arr[min]= temp;

        }



        // 遍历数组
        for(int x : arr){
            System.out.println(x);
        }
    }

二分查找法

public  static  boolean  search(int[] arr , int key){
    int mid;
int start = 0;// 开始查找的位置
    int end = arr.length -1;// 查找的结束位置
    while( start  <=  end  ){
            mid = (start + end) / 2;
            if(key == arr[mid]){
                System.out.println("查找到了目标元素");
                return true;
            }else if (key < arr[mid] ){
                end = mid -1;
            }else if(key > arr[mid] ){//
                start = mid+1;
            }

    }
    return false;
}