[19/03/13-星期三] 数组_二维数组&冒泡排序&二分查找

一、二维数组

多维数组可以看成以数组为元素的数组。可以有二维、三维、甚至更多维数组，但是实际开发中用的非常少。最多到二维数组(我们一般使用容器代替，二维数组用的都很少)。

【代码示例】

 import java.util.*;
 public class Test_0313_01
 {
     public static void main(String[] args)
     {
         //1、 Java中多维数组的声明和初始化应按从低维到高维的顺序进行 int a1[][]=new int[][4];//非法
         //int a[][]=new int[2][3];//二维数组声明 2行(下标0-2) 3列(下标0-3)
         int b[][]={ { 1, 2, 3 }, { 3, 4 }, { 3, 5, 6, 7 } };// 二维数组的静态初始化
         System.out.println(b[2][3]);    

         int a[][] = new int[3][]; //动态初始化
         // a[0] = {1,2,5}; //错误，没有声明类型就初始化
         a[0] = new int[] { 1, 2 };
         a[1] = new int[] { 2, 2 };
         a[2] = new int[] { 2, 2, 3, 4 };
         System.out.println(a[2][3]);
         System.out.println(Arrays.toString(a[0]));
         System.out.println(Arrays.toString(a[1]));
         System.out.println(Arrays.toString(a[2]));
         int c[][]=new int[][] {{2,3,5},{34,7},{4,5,6}};
         System.out.println(Arrays.toString(c[0]));//注意：ArrayIndexOutBoundsException 数组下标越界
         System.out.println(c[1][1]);//c[1][1]代表先找第2行即{34,7}，然后从中第2列即数字7。

     }
 }

【内存分析】

【示例】

 import java.util.*;

 public class  Test_0313_02
 {
     public static void main(String[] args)
     {
         Object[] emp1={101,"小白",29,"讲师","2016.2.9"};//每一行可以使用一个一维数组存储：
         Object[] emp2={102,"老李",39,"教授","2006.4.9"};
         Object[] emp3={103,"老王",35,"高工","2017.4.9"};

         Object table[][]=new Object[3][];
         table[0]=emp1;
         table[1]=emp2;
         table[2]=emp3;

         for(Object[] temp:table){
             System.out.println(Arrays.toString(temp));
         }

     }
 }

二、冒泡排序

思想：算法重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来，这样越大的元素会经由交换慢慢“浮”到数列的顶端。

【代码示例】

 import java.util.*;
 public class Test_0313_03  {
     public static void main(String[] args) {
       int a[]={3, 1, 6, 2, 9, 0, 7, 4, 5, 8};

       //外层核心，控制轮数。即当j=0时为第1轮会把最大的数9放在最后。当j=1为第2轮会把次大的数字8放在倒数第2位，依次类推
       for(int j=0;j<a.length-1;j++ ){

           boolean flag=true;//此处是为了优化算法

          //内层核心，可以实现的某轮最大的值移动到后面
         for(int i=0;i<a.length-1-j;i++){// 1、注意是a.length-1=9(其中a.length=10),i可以实现从0变化到8
                       //2、-j是为了提升效率,j代表轮数,即后边的数字已经排序好了,不用在此遍历排序了,j越增大代表又排好一轮
             if(a[i]>a[i+1]){//i在数组中的最大值为9,若上步是i<a.length(=10,即i可以取到9),则在此步中会异常,因为i+1可以=10,但数组中没有
                 int temp=a[i];//先把a[i]的值存起来
                 a[i]=a[i+1];//然后把a[i+1]的值覆盖a[i]，此时a[i]的值已经发生变化
                 a[i+1]=temp;//把原来存在temp中的a[i]值给a[i+1]，此时完成交换

                 flag=false;//即若发生过交换(即执行完上边3行,否则也不会到这里来),把flag置为false,若没有发生过交换,还是默认为true
                            //没发生过交换代表a[i]<a[i+1]符合要求
             }
         }

         if(flag==true)//第6轮循环(即j=5)后，没有发生过交换即flag不可能为false,代表第5轮完成后已经排好序,否则肯定有交换
             break;//从而可以直接结束全部循环，不会执行下边的代码。
         System.out.println(Arrays.toString(a));//输出的最后一行为第5轮排好序的结果

       }
     }
 }

三、二分查找

二分法检索(binary search)又称折半检索，二分法检索的基本思想是设数组中的元素从小到大有序地存放在数组(array)中，首先将给定值key与数组中间位置上元素的关键码(key)

比较，如果相等，则检索成功;  否则，若key小，则在数组前半部分中继续进行二分法检索；若key大，则在数组后半部分中继续进行二分法检索。这样，经过一次比较就缩小一半的

检索区间，如此进行下去，直到检索成功或检索失败。

【代码示例】

 import java.util.*;

 //二分查找 方法BinarySearch

 public class Test_0313_04 {    

     public static int binarySearch(int arr[], int value){

         int low=0, high=arr.length-1;//low和high为数组的下标

         while(low<=high){
             int mid=(low+high)/2; //mid是写在这里是动态变化的，写在外边mid是恒定的是不会返回-1的
             if(value==arr[mid])//恰好为中间数
                  return mid;
             if(value>arr[mid])//比中间数大
                  low=mid+1;
             if(value<arr[mid])//比中间数小
                  high=mid-1;
             }

            return -1;
      }
    public static void main(String[] args) {
         int a[]={2,5,1,4,6,7,12,8,3};

         System.out.println(Arrays.toString(a));

         Arrays.sort(a);

         System.out.println(Arrays.toString(a));

         System.out.println(binarySearch(a,5));

         System.out.println(binarySearch(a,17));

     }

 }