（java）求数组中的最大最小值、冒泡排序算法、选择排序法、直接插入排序算法、二分查找算法、Arrays工具类

求数组中的最大最小值

【代码】

package HeadFirst;
/*
求数组中的最大最小值
 */
public class Test8 {
    public static void main(String[] args) {
        int [] num={12,3,54,67,88,24};
        int max=max(num);
        int min=min(num);
        System.out.println("数列中的最大值是："+max);
        System.out.println("数列中的最小值是："+min);
    }
    //求数列中的最大值
    public static int max(int[] num){
        int max=num[0];
        int len=num.length;
        for(int i=1;i<len;i++){
            if(num[i]>max){
                //材料中的方法
                /*
                num[i]=num[i]+max;
                max=num[i]-max;
                num[i]=num[i]-max;
                 */
                max=num[i];
            }
        }
        return max;
    }
    //求数列中的最小值
    public static int min(int[] num){
        int min=num[0];
        int len=num.length;
        for(int i=1;i<len;i++){
            if(num[i]<min){
                min=num[i];
            }
        }
        return min;
    }
}

#冒泡排序算法
冒泡排序算法运作如下：（从后往前）
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
相同的元素前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
【代码】

package HeadFirst;
/*
冒泡排序算法运作如下：（从后往前）
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
相同的元素前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
34 4 56 17 90 65
4 34 17 56 65 90  //第一轮 5次
4 17 34 56 65     //第二轮 4次
4 17 34 56       //第三轮 3次
4 17 34          //第四轮 2次
4 17            //第五轮 1次
 */
public class Test9 {
    public static void main(String[] args) {
    int [] nums={34,4,56,17,90,65};//待排序的数列
        //外循环控制轮数
        for (int i=0;i<nums.length-1;i++){//比较的轮数等于数列的长度-1
            for (int j=0;j<nums.length-1-i;j++){
                if(nums[j]>nums[j+1]){
                    nums[j]=nums[j]+nums[j+1];
                    nums[j+1]=nums[j]-nums[j+1];
                    nums[j]=nums[j]-nums[j+1];
                }
            }
        }
        //输出结果
        for (int n:nums){
            System.out.println(n);
        }
    }
}

选择排序法

每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。选择排序是不稳定的额排序方法。
【代码】

package HeadFirst;
/*
选择排序法,每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。选择排序是不稳定的额排序方法。
 34 4 56 17 90 65
 4 34 56 17 90 65 第一轮 5次
 4 17 34 56 90 65 第二轮 4次
 4 17 34 56 90 65 第三轮 3次
 4 17 34 56 90 65 第四轮 2次
 4 17 34 56 65 90 第五轮 1次
 */
public class Test10 {
    public static void main(String[] args) {
    int[] nums={34,4,56,17,90,65};
    int minIndex=0;//用于记录每次比较的最小值下标
        //控制轮数
        for(int i=0;i<nums.length-1;i++){
            minIndex=i;//每轮假设一个最小值下标
            for(int j=i+1;j<nums.length;j++){
                if(nums[minIndex]>nums[j]){
                    minIndex=j;
                }
            }
            //判断需要交换的数下标是否为自己
            if(minIndex!=i){
                nums[minIndex]=nums[minIndex]+nums[i];
                nums[i]=nums[minIndex]-nums[i];
                nums[minIndex]=nums[minIndex]-nums[i];
            }
        }
        //输出结果
        for(int n:nums){
            System.out.println(n);
        }
    }
}

直接插入排序算法

直接插入排序算法
（从后向前找到合适的位置后插入）
基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排好序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。

package HeadFirst;
/*
直接插入排序算法
（从后向前找到合适的位置后插入）
基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排好序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。
        34 4 56 17 90 65
第一轮：i=1 34 34 56 17 90 65
            4 34 56 17 90 65
第二轮：i=2 4 34 56 17 90 65
           4 34 56 56 90 65
第三轮：i=3 4 34 34 56 90 65
           4 17 34 56 90 65
第四轮：i=4 4 17 34 56 90 65
           4 17 34 56 90 90
第五轮：i=5 4 17 34 56 65 90

 */
public class Test11 {
    public static void main(String[] args) {
    int [] nums={34,4,56,17,90,65};
    //控制比较的轮数
        for(int i=1;i<nums.length;i++){
            int temp=nums[i];//记录操作数
            int j=0;
            for(j=i-1;j>=0;j--){
                if(nums[j]>temp){
                    nums[j+1]=nums[j];
                }else {
                    break;
                }
            }
            if(nums[j+1]!=temp){
                nums[j+1]=temp;
            }
        }
        //输出结果
        for(int n:nums){
            System.out.println(n);
        }
    }
}

二分查找算法

二分查找（折半查找）：前提是在已经排好序的数组中，通过将待查找的元素与中间索引值对应的元素进行比较，若大于中间索引值对应的元素，去右半部分查找，否则，去左半部分查找。依此类推，直到找到为止；找不到返回一个负数。

package HeadFirst;
/*
二分查找（折半查找）：前提是在已经排好序的数组中，通过将待查找的元素与中间索引值对应的元素进行比较，若大于中间索引值对应的元素，去右半部分查找，否则，去左半部分查找。依此类推，直到找到为止；找不到返回一个负数。
 */
public class Test12 {
    public static void main(String[] args) {
//必须保证数列是有序的
        int []num={10,20,50,65,88,90};
        int index=binarySearch(num,88);
        System.out.println(index);
    }
    //二分查找算法
    public static int binarySearch(int[]num,int key){
        int start=0;//开始下标
        int end=num.length-1;
        while (start<=end){
            int middle=(start+end)/2;//>>>1
            if(num[middle]>key){
                end=middle-1;
            }else if(num[middle]<key){
                start=middle+1;
            }else{
                return middle;
            }
        }
        return -1;

    }
}

Arrays工具类

Arrays工具类：用来操作数组（比如排序和搜索）的各种方法
常用方法：
使用二分法查找：
Arrays.binarySearch(int [] array,int value);
数组内容转成字符串的形式输出：
Arrays.toString(int [] array);
数组排序：
Arrays.sort(int [] array);
复制指定的数组：
Arrays.copyOf(int[] array,int length);
Arrays.copyOf(int[] array,int from,int to);
System.arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
判断两个数组是否相等
Arrays.equals();
使用指定元素填充数组：
Arrays.fill();
【代码】

package HeadFirst;
/*
Arrays工具类使用
 */
import java.util.Scanner;
import java.util.Arrays;
public class Test13 {
    public static void main(String[] args) {
        int []num={10,20,50,65,88,90};
        //二分查找
        int index=Arrays.binarySearch(num,88);
        System.out.println("找到的下标是："+index);
        //输出数组,可使用前面的foreach方法
        for(int n:num){
            System.out.println(n);
        }
        //在测试输出数据时，可以使用，更加方便
        System.out.println(Arrays.toString(num));
        //排序
        int[] num2={10,32,11,44,543,22,12};
        Arrays.sort(num2);//快速排序
        System.out.println(Arrays.toString(num2));
        //数组的复制
        int[] num3=Arrays.copyOf(num2,10);
        System.out.println(Arrays.toString(num3));
        //
        int[] newNum=new int[num2.length];
        System.arraycopy(num2,0,newNum,0,num2.length);//将数组num2从起始位置0开始复制给新数组newNum，起始位置为0，复制的长度为num2.length
        System.out.println(Arrays.toString(newNum));
        //小结，数组的复制：
        /*
        效率从高到低排序是：System.arraycopy -> Arrays.copyOf -> for
         */
        //判断两个数组的值是否相等
        System.out.println(Arrays.equals(num2,newNum));
        //填充数组
        Arrays.fill(newNum,0);
        System.out.println(Arrays.toString(newNum));
    }
}