Day13认识Java排序算法

排序

上午：

数组排序：把数组中的元素，通过比较移位替换，使之变成一个有序序列

排序方式：冒泡排序，选择排序，插入排序，希尔排序，快速排序，基数排序，堆排序，归并排序

冒泡排序：数组元素两两比较，大的往后放，经过一轮比较后，最大的元素出现在最后面，如此往复，那么整个数组就有序了

public class Demo1 {
    public static void main(String[] args) {
        int[] arr={24,69,80,57,13};
    for(int j=0;j<arr.length-1;j++){
        for (int i = 0; i < arr.length-1-j; i++) {
            if(arr[i]>arr[i+1]){
                int t=arr[i];
                arr[i]=arr[i+1];
                arr[i+1]=t;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

——tips:快速把一坨代码，抽到方法中Ctrl+alt+M

选择排序：每次拿一个元素和后面所有元素挨个比价，小的往前放，经过一轮比较，最小的元素会出现在最前面

public class Demo2 {
    public static void main(String[] args) {
        int[] arr= {24,69,80,57,13};
        for(int index=0;index<arr.length-1;index++){
        for (int i = 1+index; i < arr.length; i++) {
            if(arr[index]>arr[i]){
                int t=arr[index];
                arr[index]=arr[i];
                arr[i]=t;
            }
        }}
        System.out.println(Arrays.toString(arr));
    }
}

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

public class Demo3 {
    public static void main(String[] args) {
        int[] arr={49,38,65,97,76,13,27};

        for (int i = 0; i < arr.length; i++) {
            int j=i;
            while(j>0&&arr[j]<arr[j-1]){//j>0是不让它低过数组的索引
                int t=arr[j];          //交换位置
                arr[j]=arr[j-1];
                arr[j-1]=t;
                j--;            //将数组前面的元素也顺序排序
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

快速排序：比大小，再分区

public class QuickSort {
    //start 默认是0
    //end 是数组长度-1
    public 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);//右半部分
        }
    }

    private 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++;
                i++;

            }

            //从左往右找
            while (i < j && arr[i] < x) {
                i++;
            }
            // 找比基准数大的数，找到后填坑
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }
        //当上面的循环结束后把基准数填到最后一个坑位，也就一基准数为界，分成了左右两部分
        arr[i] = x; //把基准数填进去
        return i; //返回基准数所在位置的索引
    }
}

查找思想：二分查找；每次查找一半（**前提：**数组元素必须有序）

根据元素，查询该元素，第一次在数组中出现的索引

——基本查找：int index =getIndex（arr，2）

getIndex（int[] arr,int ele）{
	for(int j=0;j<arr.length;j++){
		if(arr[j]==ele){return j;
		}
	}
}

——二分查找：每次去找中间索引所对应的元素

中间索引centerIndex=(minIndex+maxIndex)/2

maxIndex=arr.length-1

1、找的元素正好等于中间索引对应的元素，就返回中间索引

2、找的元素比中间索引对应的元素大，minIndex=centerIndex+1；

3、找的元素比中间索引对应的元素小，

maxIndex=centerIndex-1；

public class Demo5 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90, 400, 500};
        int index = getIndex(arr, 70);
        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{
                maxIndex=centerIndex-1;
            }
            centerIndex=(minIndex+maxIndex)/2;//重新计算中间索引
        }
        return -1;
    }
}

下午：

Java针对数组的操作，给我们提供了一个工具类Arrays

此类包含用来操作数组（如排序、搜索）的各种方法

——打印数组元素:Arrays.toString(arr).sout

——判断2个数组是否相等 .equals（）

——复制指定数组，截取或用0补充，长度为指定长度：.copyOf(arr,arr.length)

——复制数组指定索引范围到新数组中:.copyOfRang(arr,0,3) tips:含头不含尾

包装类

int 4个字节 -2^31~231

Java为了方便去操作这些基本类型数据，那么针对每个基本数据类型都提供了它所对应的包装类（引用类型）

byte——Byte

short——Short

int——Integer

long——Long

float——Float

double——Double

char——Character

boolean——Boolean

基本类型——包装类型

Integer 构造方法：

Integer（int value）；把基本类型包装成所对应的包装类

‘Integer（String s）：只能给字面上是数字的字符串，如 ：“1234”

String类型与int类型相互转换：

int-----》String

方式1：拼接空串String str=num+"";

方式2：String中静态方法valueOf(num)可以把多种类型转换成字符串

String s=String.valueOf(num);

方式3：Integer Integer=new Integer(num);

string String=integer.toString();

String—》int

方式1：new Integer（StrNUm）；

int i = integer.inValue（）；

方式2：int num=Integer.parseInt（Strnum）;

自动装箱/开箱

自动装箱：将基本类型自动转换成它所对应的包装类型

自动拆箱：将包装类型自动转换成它所对应的基本类型

如：

Integer integer=new Integer（20）；

Integer integer2=new Integer（200）；

int num =integer+integer2；//自动拆箱

int a=200；

Integer integer1=a;//自动装箱

————补充：

知识点：

//超过1个字节的范围

Integer i5 = 128;
	Integer i6 = 128;
	System.out.println(i5 == i6);//false  原因就是128大于了1字节
	System.out.println(i5.equals(i6));//true
	System.out.println("-----------");
	
Integer i7 = 127;
Integer i8 = 127;
System.out.println(i7 == i8);//true
System.out.println(i7.equals(i8));//true

//Integer i7=127；自动装箱 底层要调用

维护了一个数组缓存，IntegerCache里面存储了new Integer（）对象，若取数组中的对象，地址值就是一样的