Java学习笔记day4--数组算法（赋值，复制，反转，排序，查找）

package day4_array;

public class AlgorithmArray {
    public static void main(String[] args) {
        
        //数组赋值问题======================================================================
        /*
         *第1题好题
         创建一个长度为6的int型数组，要求数组元素值都在1-30之间，且是随机附赠，要求元素各个值不相等
         */
        int [] number=new int[30];//为了测试代码准确性，使得数组长度为30，检测是否每个数组元素值都在1-30之间且无重复
        for(int i=0;i<number.length;i++) {
            number[i]=(int)(Math.random()*30+1);
            for(int j=0;j<i;j++) {
                if(number[i]==number[j]) {
                    i--;//****************神了！****************************
                    break;
                }
            }    
        }
        for(int i=0;i<number.length;i++) {
            System.out.print(number[i]+"\t");
            for(int j=0;j<i;j++) {            //输出检测有无重复元素
                if(number[i]==number[j]) {
                    System.out.print("false");
                    break;
                }
            }
        }
        
        
        /*
         * 第三题：
         定义一个int类型的一维数组，包含十个元素，分别赋一些随机整数
         然后求出所有元素的最大值，最小值，和值，平均值并输出出来
         要求：所有的随机数都是两位数
         */
        System.out.println();
        int[] arr=new int[10];
        int sum,max,min;
        double average;
        sum=max=0;
        min=99;//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        for(int i=0;i<arr.length;i++) {
            arr[i]=(int)(Math.random()*90+10);//random随机生成[0.0,1.0)的浮点数
            sum+=arr[i];
            if(arr[i]>max) {
                max=arr[i];
            }
            if(arr[i]<min) {
                min=arr[i];
            }System.out.print(arr[i]+" ");
        }System.out.println();
        average=sum/10.0;
        System.out.println("最大值是："+max+"，最小值是："+min+"，和值是："+sum+"，平均值是："+average);
        
        //数组的复制、反转、查找问题======================================================================
        /*
         第4题：不能称作数组的复制！！！！！！！堆空间中只有一个数组的内存空间
         声明array1和array2两个变量，它们是int类型的数组
         使用大括号把array1初始化为8个常数：2，3，5，7，11，13，17，19
         赋值array2变量等于array1，修改array2中的偶索引值，使其等于索引值，如按array2[0]=0
         显示array1的内容
         思考：array1和array2什么关系？
         */
        int[] array1=new int[] {2,3,5,7,11,13,17,19};
        int []array2;
        array2=array1;//数组变量array1和array2相等，指向同一片内存空间
        for(int i=0;i<array1.length;i++) {
            if(i%2==0) {
                array2[i]=i;//修改array2后，array1也随之改变
            }
            System.out.print(array1[i]+" ");
        }
        
        //数组复制======================================================================
        int[] array3=new int[array1.length];
        for(int i=0;i<array1.length;i++) {
            array3[i]=array1[i];
        }
        
        //数组反转====================================================================
        System.out.println();
        String[] array4=new String[] {"java","爱","我","hhh","不会吧","不会吧"};
        for(int i=0;i<array4.length/2;i++) {
            String temp=array4[i];
            array4[i]=array4[array4.length-1-i];
            array4[array4.length-1-i]=temp;
        }
        for(int i=0;i<array4.length;i++) {
            System.out.print(array4[i]+" ");
        }
        
        //数组元素的查找================================================================
        //1.线性查找（从前往后一个个查，地毯式搜索）
        String dest="我";
        int index=0;
        boolean isExit=false;
        System.out.println();
        for(int i=0;i<array4.length;i++) {
            if(array4[i]==dest) {
                index=i;
                isExit=true;
                break;
            }
        }if(isExit) {
            System.out.println("找到了指定的元素，位置为："+index);
        }else {
            System.out.println("没有找到这个元素");
        }
        //2.二分法查找(适用于有序数组)***************************************
        int[] number0=new int[] {2,5,7,8,10,15,18,20,22,25,28};
        int dest1=21;//查找元素
        int head=0;//初始首索引
        int end=number0.length-1;//初始末索引
        boolean isExit0=false;
        while(head<=end) {
            int middle=(head+end)/2;
            if(dest1<number0[middle]) {
                end=middle-1;
            }else if(dest1>number0[middle]) {
                head=middle+1;
            }else {
                isExit0=true;
                System.out.println("找到了目标元素，他的位置在："+middle);
                break;
            }
        }if(isExit0==false) {
            System.out.println("没有找到这个元素");
        }
        
        //排序算法=============================================================================
        /*
        时间复杂度&空间复杂度;
        稳定性：如果AB相等，排序后AB次序不变，则称这个排序算法为稳定的
        十大内部排序算法（内部是指不涉及存储器）：
            选择排序：直接选择，堆排序
            交换排序：冒泡排序，快速排序
            插入排序：直接插入，折半插入，shell排序
            归并排序
            桶式排序
            基数排序
         */
        //1.普通排序
        int[] number1=new int[] {34,12,54,2,6,45,88,6,89,9,4,36,55,78};
        for(int i=0;i<number1.length-1;i++) {
            for(int j=i+1;j<number1.length;j++) {
                if(number1[i]>number1[j]) {
                    int temp=number1[i];
                    number1[i]=number1[j];
                    number1[j]=temp;
                }
            }
        }for(int i=0;i<number1.length;i++) {
            System.out.print(number1[i]+" ");
        }
        //冒泡排序******************************************
        System.out.println();
        for(int i=0;i<number1.length-1;i++) {
            for(int j=0;j<number1.length-i-1;j++) {
                if(number1[j]>number1[j+1]) {
                    int tmep=number1[j];
                    number1[j]=number1[j+1];
                    number1[j+1]=tmep;
                }
            }
        }for(int i=0;i<number1.length;i++) {
            System.out.print(number1[i]+" ");
        }//***********************************************
        //快速排序：最快的内部排序法之一！(堆排序，归并排序)
        
    }
}