【小白学java】D07》》》数组的应用＜ 冒泡排序 &二分查找 & 插入删除元素＞

一、冒泡排序

思考：

1. 首先比较第一和第二个数，将小数放在前面，将大数 放在后面
2. 比较第2和第3个数，将小数 放在前面，大数放在后面。
3. 如此继续，直到比较到最后的两个数，将小数放在前 面，大数放在后面，重复步骤，直至全部排序完成
4. 在上面一趟比较完成后，最后一个数一定是数组中最 大的一个数，所以在比较第二趟的时候，最后一个数是 不参加比较的。
5. 在第二趟比较完成后，倒数第二个数也一定是数组中 倒数第二大数，所以在第三趟的比较中，最后两个数 是不参与比较的。
6. 依次类推，每一趟比较次数减少依次类推

        int[] ints={1,2,9,8,7,5,6,4,3,10,48,90,52,60};
        //遍历排序前数组元素
        System.out.println("排序前");
        for (int i = 0; i <ints.length ; i++) {
            System.out.print(ints[i]+"\t");
        }
        System.out.println("\n");
        //冒泡排序，将下标为i的元素依次与后面的元素（下标为j）比较，将大的放后面
        for (int i = 0; i <ints.length-1 ; i++) {
            for (int j = i+1; j < ints.length; j++) {
                if(ints[i] > ints[j]){
//                        //交换两个元素
//                        int tmp=0;
//                        tmp=ints[i];
//                        ints[i]=ints[deleteIndex];
//                        ints[deleteIndex]=tmp;
                    //不用第三方变量，直接替换两个元素（int）-加减法
                    ints[i]=ints[i]+ints[j];
                    ints[j]=ints[i]-ints[j];
                    ints[i]=ints[i]-ints[j];
                }
            }
        }
        System.out.println("排序后");
        //遍历排序后数组元素
        for (int i = 0; i <ints.length ; i++) {
            System.out.print(ints[i]+"\t");
        }

二、二分查找

二分查找思想：二分查找思想应用于对有序的数组进行查找操作。
1：从有序数组的中间元素开始查找，如果该元素正好是要查找的值，则查找结束，否则进行下一步；
2：如果指定要查找的元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半查找，然后重复第一步；
3：重复以上的过程，直到找到目标元素的索引，查找成功，或直到查到子数组为空，查找失败。

//二分查找，前提数组中的元素已排好序
int[] ints={1,2,3,4,5,6,7,8,9};
//打印数组元素
for (int i = 0; i <ints.length ; i++) {
    System.out.print(ints[i]+"\t");
}
System.out.println("\n");
int target;//用于接受要查找的元素
boolean flag = false;//判断有无查找到元素，true——找到
int startIndex=0;//用于接收数组头部下标
int endIndex=ints.length-1;//用于接收数组尾部下标
int index = 0;//接收查询到的元素的下标

//获取键入的要查找的元素赋值给target
System.out.println("请输入要查找的元素（1-9）：");
Scanner scanner=new Scanner(System.in);
target = scanner.nextInt();
//执行循环判断元素是否存在
while (startIndex <= endIndex){//循环判定条件：当startIndex大于等于endIndex时退出循环
    int midIndex = ( startIndex + endIndex ) / 2; //用于接收数组中间元素的下标
    int  midVar = ints[midIndex];  //用于接收数组ints[]中下标midIndex的元素值
    if(target == midVar){//判断是否查到
        flag = true; //查到元素，改变flag，赋值true
        index=midIndex;//将midIndex给index打印输出
        break;//退出循环，否则继续循环
    }else if (target > midVar){//target 在下标midIndex和下标endIndex之间
        startIndex = midIndex+1 ;//将midindex的下一个元素的下标给startindex继续循环
    }else {  //target 在下标start和mid之间
        endIndex =  midIndex-1 ;//将midindex的上一个元素的下标给endindex继续循环
    }
}
//输出查找的结果
if(flag == true){
    System.out.println("存在，元素下标为："+index);
}else {
    System.out.println("不存在");
}

三、insert往数组插入元素

        int[] ints={1,2,3,4,6,7,8,9};
        //遍历数组元素
        for (int i = 0; i <ints.length ; i++) {
            System.out.print(ints[i]+"\t");
        }
        System.out.println("\n");
        //定义一个新的数组来存放插入之后的元素列表
        int[] intsNew=new int[ints.length+1];
        int insertIndex=0;//接收要插入的元素的位置
        int insertVar=0;//接收要插入的元素的值
        System.out.print("请输入要插入的元素的位置(从1开始)：\t");
        Scanner sc=new Scanner(System.in);
        insertIndex=sc.nextInt();
        System.out.print("请输入要插入的元素的值：\t");
        insertVar=sc.nextInt();
        if(insertIndex<=0 ||insertIndex>ints.length-1 ){
            System.out.println("插入位置不存在！");
        }else{        
//***********************************************************************************
            //方法一：用两个循环分别处理，下标j前面部分和后面部分分别赋值给intsNew
//            int j=insertIndex-1;
//            for(int i=0;i<j;i++){//处理i<insertIndex-1前部
//                intsNew[i] = ints[i];
//            }
//            intsNew[j]=insertVar;
//            for (int i = j ; i <intsNew.length-1 ; i++) {//处理i>insertIndex-1后部
//                intsNew[i+1]=ints[i];
//            }
//***********************************************************************************
            //方法二：将ints中的元素全部赋值给intsNew,然后将要插入的元素位置之后的元素后移
//            for (int i = 0; i < ints.length; i++) {
//                intsNew[i]=ints[i];
//            }
//            for (int i = intsNew.length-1 ; i >= insertIndex-1 ; i--) {
//                //intsNew元素后移,注意后移方式是从后往前逐个移动，否则会全被intsNew[insertIndex-1]元素覆盖
//                 intsNew[i]= intsNew[i-1];
//            }
//            intsNew[insertIndex-1]=insertVar;//插入元素
//***********************************************************************************
            //方法三：将要插入的元素直接添加到intsNew[intsNew.length-1]中后在对数组排序（冒泡）
            for (int i = 0; i < ints.length; i++) {
                intsNew[i]=ints[i];
            }
            intsNew[intsNew.length-1]=insertVar;
            //冒泡排序
            for (int i = 0; i <intsNew.length-1 ; i++) {
                for (int j = i+1; j <=intsNew.length-1 ; j++) {
                    if(intsNew[i] > intsNew[j]){
//                        //交换两个元素
//                        int tmp=0;
//                        tmp=intsNew[i];
//                        intsNew[i]=intsNew[j];
//                        intsNew[j]=tmp;
                    //不用第三方变量，直接替换两个元素（int）-加减法
                    intsNew[i]=intsNew[i]+intsNew[j];
                    intsNew[j]=intsNew[i]-intsNew[j];
                    intsNew[i]=intsNew[i]-intsNew[j];

                    }
                }
            }
//***********************************************************************************            
        }
        //遍历插入后的数组元素
        for (int i = 0; i <intsNew.length ; i++) {
            System.out.print(intsNew[i]+"\t");
        }
        System.out.println("\n");

四、delete删除数组中元素

        int[] ints={1,2,3,4,5,6,7,8,9};
        //遍历数组元素
        for (int i = 0; i <ints.length ; i++) {
            System.out.print(ints[i]+"\t");
        }
        System.out.println("\n");

        //定义一个新的数组来存放删除之后的元素列表
        int[] intsNew=new int[ints.length-1];
        int deleteIndex=0;//接收要删除的元素的位置
        int deleteVar= 0;//接收要删除的元素的值

        Scanner sc=new Scanner(System.in);
        System.out.print("请输入要删除的元素的值：\t");
        deleteVar=sc.nextInt();

        for (int i = 0; i < ints.length ; i++) {
            if(ints[i]== deleteVar){
                deleteIndex = i;
                break;
            }
        }
//***********************************************************************************
// //方法一：用两个循环分别处理，下标deleteIndex前面部分和后面部分分别赋值给intsNew
//        for(int i=0;i<deleteIndex;i++){//处理deleteIndex前部
//            intsNew[i] = ints[i];
//        }
//        for (int i = deleteIndex; i <intsNew.length ; i++) {//处理deleteIndex后部
//            intsNew[i]=ints[i+1];
//        }
//***********************************************************************************       
//  //方法二：将ints中的要删除的元素之后的元素向前移动
//        for (int i = deleteIndex; i < ints.length-1 ; i++) {//前移，覆盖要删除的元素
//                ints[i]=ints[i+1];
//        }
//        for (int i = 0; i < intsNew.length ; i++) {//复制到新数组
//             intsNew[i]=ints[i];
//        }
//***********************************************************************************
//方法三：将ints中要删除的元素赋值为0，然后后在对数组排序（冒泡），5就去除了，而0为第一个元素，再复制ints[]到intsNew[]
            for (int i = 0; i <ints.length ; i++) {
                if( ints[i]==deleteVar ){
                  ints[i]=0;//数组中0表示空
                }
            }
            //冒泡排序
            for (int i = 0; i <ints.length-1 ; i++) {
                for (int j = i+1; j < ints.length; j++) {
                    if(ints[i] > ints[j]){
//                        //交换两个元素
//                        int tmp=0;
//                        tmp=ints[i];
//                        ints[i]=ints[deleteIndex];
//                        ints[deleteIndex]=tmp;
                        //不用第三方变量，直接替换两个元素（int）-加减法
                        ints[i]=ints[i]+ints[j];
                        ints[j]=ints[i]-ints[j];
                        ints[i]=ints[i]-ints[j];
                    }
                }
            }
        for(int i=0;i<intsNew.length;i++){//处理deleteIndex前部
            intsNew[i] = ints[i+1];
        }
//***********************************************************************************
      //  遍历插入后的数组元素
        for (int i = 0; i <intsNew.length ; i++) {
            System.out.print(intsNew[i]+"\t");
        }
        System.out.println("\n");