数组相关二(复制，查找，排序算法)

数组的复制，反转，查找

String[] arr = new String[]{"AA","BB","CC","DD","FF"};

//数组的复制
String[] arr1 = new String[arr.length];
for(int i = 0; i < arr1.length; i++){
    arr1[i] = arr[i];
}
//注意，数组变量的赋值  arr1 = arr;  同一个地址值，指向同一个数组实体；

//数组的反转
1.for(int  i = 0; i < arr.length / 2; i++){
    String temp = arr[i];
    arr[i] = arr[arr.length - 1 - i];
    arr[arr.length - 1 - i] = temp;
}
2.for(int i = 0,j = arr.length - 1; i < j; i++, j-- ){
    String temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}

数组的查找

线性查找

又称顺序查找，效率低，数据特多的情况不建议使用。从数组第一个元素开始一一遍历数组，找到当前被遍历的值与所查找的值相同的过程。

String dest = "BB";
boolean isFlag = true;
for(int i = 0; i < arr.length; i++){
    if(dest.equals(arr[i])){
        System.out.println("找到了指定的元素，位置为： " + i);
        isFlag = false;
        break;
    }
    
}
if(isFlag){
 System.out.println("没找到指定的元素");
}

二分法查找

二分法查找，也称为折半法，是一种在有序数组中查找特定元素的搜索算法。

思路如下：

1：首先，从数组的中间元素开始搜索，如果该元素正好是目标元素，则搜索过程结束，否则执行下一步。

2：如果目标元素大于/小于中间元素，则在数组大于/小于中间元素的那一半区域查找，然后重复步骤1的操作。

3：如果某一步数组为空，则表示找不到目标元素。

//前提：所要查找的数组必须有序
int[] arr = new int[]{2,7, 18,36, 45,67,89};
int dest = 45;
int head = 0;  //初始的首索引
int end  = arr.length - 1; //初始的末索引
boolean isFlag = true;

while(head <= end){
    int middle = (head + end) / 2;
    if(dest == arr[middle]){
 		System.out.println("找到了指定的元素，位置为： " + middle);
        isFlag = false;
        break;
    }else if(arr[middle] > dest){
        end = middle - 1;
    }else{
        head = middle + 1;
    }
}
if(isFlag){
 System.out.println("没找到指定的元素");
}

数组元素的排序算法

冒泡排序

35 28 77 5 16

第1趟：

0 第1次 28 35 77 5 16

1 2 28 35 77 5 16

2 3 28 35 5 77 16

3 4 28 35 5 16 77

第2趟：

0 第1次 28 35 5 16 77

1 2 28 5 35 16 77

2 3 28 5 16 35 77

第3趟：

0 第1次 5 28 16 35 77

1 2 5 16 28 35 77

第4趟：

0 第1次 5 16 28 35 77

5个元素比较4趟，n个元素比较n - 1趟。

​ 趟数 次数

0 1 4

1 2 3

2 3 2

3 4 1

N个元素要排序完成，总共进行N-1趟排序，每i趟的排序次数为N-i.

外层循环控制趟数，内层循环控制每趟比较次数。

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]){
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
}

快速排序

快速排序是对冒泡排序的一种改进。

基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

对数组中的数进行排序，随机找个基准数(用来参照的数)，为了方便，可以拿第一个数作为基准数。接下来，需要将序列中所有比基准数大的放在其右边，比基准数小的放在其左边。定义两个指针。

基准数后的元素定义为指针low,末尾的定义为high。low不断向右走，high向左走，要求low指向的元素值要比基准值小，high指向元素值比基准值要大，满足的话，接着下一步。直到当low出现比基准数大，high出现比基准数小的情况，将两者元素对调。接 着进行，若还出现这情况的话，接着进行对调

若high< low,结束查找。若high对应元素比基准数小，则与基准数进行对调。

经过一轮排序后，将数组分成两部分，接着分别在这两块进行上述操作，设置基准数，low,high等。

各种内部排序算法，从平均时间而言， 快序最佳。

Arrays工具类使用

java.util.Arrays:操作数组的工具类，内部定义了很多操作数组的方法

将指定值填充到数组当中，是将每个元素替换成指定元素。
二分查找元素位置，没找到的话，索引值为负数。

另外，还有数组元素的赋值
数值型数组中元素的最大值，最小值，平均数等