java_学习5 二维数组，冒泡排序，二分查找

package com.qianfeng.test;

/*
 * 一维数组：内部直接存储的是数据
 * 二维数组：内部存储的是多个一维数组的地址（二维数组中就是多个一维数组）
 * 
 * 
 */
public class Demo01 {
    public static void main(String[] args) {
        // 创建一维数组
        //int[] arr = new int[] { 3, 4, 5 };
        
 
        // 创建二维数组--空的二维数组
        /*
         * 二维数组与一维数组一样都是数据类型 二维数组类型的构成：数据类型+[][] 等号后面的构成：new+[一维数组的个数)+[一维数组中元素的个数]
         * 
         * 注意：第一个[]中必须填，第二个[]中的值可以省略，如果写了，代表一个建议的值
         * 
         */
        //int[][] arr1 = new int[2][2];
        
        // 其他的创建二维数组的方法
        // int [][] arr2 = {{4,5},{6,7,8}};
        
        //二维数组存值--根据下标
        //arr1[0] = new int [] {3,4,5};
        //arr1[1] = new int [] {3,4};
        
        //取值 --构成：数组的名字+[一维数组的下标]+[一维数组中元素的下标]；
        
        //int value = arr1[0][0];
        //System.out.println(value);
        
        //二维数组的遍历
        /*for (int i = 0; i < arr1.length; i++) {//控制一维数组的个数
            for (int j = 0; j < arr1[i].length; j++) {//控制一维数组的元素
                System.out.print(arr1[i][j]);
            }
            System.out.println();
        }
        //增强for循环，开始循环后先从 数组中取出第一个元素，放入冒号前面的变量中，当次循环在使用变量时，使用的就是这个值
        //第一次循环结束会自动从数组中取出第二个元素，再次放入冒号前面的变量中，依次进行，直到所有的元素便利玩，停止循环
        for (int[] i : arr1) {
            for (int j : i) {
                System.out.print(j);
            }
            System.out.println();
        }*/
        
        
        /*
         * 查找排序：（默认都是升序）
         * 1.冒泡排序
         * 2.选择排序
         */
        //int [] arr1 = new int [] {3,1,5,2};
        //bubbleSort(arr1);
        
        //int [] arr2 = new int [] {3,1,5,2};
        //selectSort(arr2);
        
        //查找
        /*
         * 注意：       1.查到值时，返回下标。2.查不到值时，返回-1。3.有相同的值时，返回查到的第一个值得下标，停止查找
         * 
         * 普通查找：
         * 二分查找：
         */
        //int [] arr = {2,5,1,7,9};
        //int n = search(arr,9);
        
        //int [] arr1 = {3,5,7,9,19};
        //int n = erFenSearch(arr1,19);
        //System.out.println(n);
        
        /*
         * 考试成绩：20,15,100,80,59,79
         * 要求：找出成绩为80的人
         */
        //int [] a = {20,15,100,80,59,79};
        //maopao(a);
        /*for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }*/
        //int n = getMax(a,80);
        //System.out.println(n);
        
    }
    
    /*public static void maopao(int []a) {
        for (int i = 0; i < a.length-1; i++) {
            for (int j = 0; j < a.length-1-i; j++) {
                if(a[j]>a[j+1]) {
                    a[j]=a[j]^a[j+1];
                    a[j+1]=a[j]^a[j+1];
                    a[j]=a[j]^a[j+1];
                }
            }
        }
    }
    public static int getMax(int [] a,int key) {
        int score = 0;
        int l = 0;
        int h = a.length-1;
        while(l<=h) {
            int m = (h+l)>>1;
            if(a[m]==key) {
                return m;
            }else if (a[m]>key) {
                h= h-1;
            }else if (a[m]<key) {
                l = m+1;
            }
        }
        return -1;
        
    }*/
    
    
    //冒泡排序
    /*public static void bubbleSort(int [] arr) {
        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]) {
                    //当前面的数大，则交换
                    arr[j] = arr[j]^arr[j+1];
                    arr[j+1] = arr[j]^arr[j+1];
                    arr[j] = arr[j]^arr[j+1];
                }
                
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }*/
    
    //选择排序
    /*public static void selectSort(int [] arr) {
        for (int i = 0; i < arr.length-1; i++) {//确定整体循环的次数，比元素的个数少一次
            for (int j = i; j < arr.length-1; j++) {//确定一个元素的时候需要比较的次数
                if(arr[i]>arr[j+1]) {
                    //当前面的数大，则交换
                    arr[i] = arr[i]^arr[j+1];
                    arr[j+1] = arr[i]^arr[j+1];
                    arr[i] = arr[i]^arr[j+1];
                }
                
            }
        }
    }*/
    
    //普通查找
    /*public  static int search(int[] arr,int key) {
        for (int i = 0; i < arr.length; i++) {
            if(key==arr[i]) {
                return i;
            }
        }
        return -1;        
    }*/
    
    //二分查找
    /*public static int erFenSearch(int[] arr,int key) {
        int low = 0;
        int high = arr.length-1;
        
        while(low<=high) {
            int mid = (low + high)>>1;//移位运算符，意味着除以二
            
            if(key == arr[mid]) {
                return mid;
            }else if (key>arr[mid]) {
                low = mid +1;
            }else if (key<arr[mid]) {
                high = high -1;
            }
        }
        return -1;  //没有查到值
    }*/
    
    
}