Java基础04：选择排序；冒泡排序；折半查找；二位数组

关键字：选择排序；冒泡排序；折半查找；二位数组

一、操作集合

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

public static void selectSort(int a[]){
        int minIndex = 0;
        int temp = 0;
        if((a==null)||(a.length==0))
            return;
        for(int i=0; i<a.length; i++){
            minIndex = i;                        //无序区的最小数据数组下标
            for(int j=i+1; j<a.length; j++){    //在无序区中找到最小数据并保存其数组下标
                if(a[j]<a[minIndex]){            
                    minIndex = j;
                }
            }
            if(minIndex!=i){                    //如果不是无序区的最小值位置不是默认的第一个数据，则交换之。
                temp = a[i];
                a[i] = a[minIndex];
                a[minIndex] = temp;
            }
        }
    }

    冒泡排序：相临的两个元素进行比较，如果符合条件则换位。

public class BubbleSort{
    public void sort(int[] a) {
        int temp = 0;
        for (int i = a.length - 1; i > 0; --i) {
            boolean isSort=false;
            for (int j = 0; j < i; ++j) {
                if (a[j + 1] < a[j]) {
                    temp = a[j];
                    a[j] = a[j + 1];
                    a[j + 1] = temp;
                    isSort=true;
                }
            }
            if(!isSort)break;
        }
    }
}

    折半查找：二分查找又称折半查找，优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

public class BinarySearch {
/**
* 二分查找算法
*
* @param srcArray 有序数组
* @param des 查找元素
* @return des的数组下标，没找到返回-1
*/
    public static int binarySearch(int[] srcArray, int des)
    {
        int low = 0;
        int high = srcArray.length-1;
        while(low <= high) 
        {
            int middle = (low + high)/2;
            if(des == srcArray[middle]) 
            {
                return middle;
            }
            else if(des <srcArray[middle]) 
            {
                high = middle - 1;
            }
            else
            {
                low = middle + 1;
            }
        }
        return -1;
    }
    public static void main(String[] args)
    {
        int[] src = new int[] {1, 3, 5, 7, 8, 9};
        System.out.println(binarySearch(src, 3));
    }
}

二、二维数组

    二维数组，即数组中的数组，数组中的元素是数组。格式：int[][] arr=new int[3][2];

    定义一个二维数组，由3个一维数组构成，每个数组有2个元素。3即是二维数组的长度，从上到下的长度；2是每个一维数组的长度。此时，一维数组中的元素默认为0。一维数组的长度是从左到右，有区别。

    Int[][] arr=new int[3][];数组的长度必须给出。此时，一维数组的默认值是null，即没有任何指向，引用数据类型。每个实体都有地址值，二维数组和其中的一维数组都有地址。二维数组获得的是每个一维数组的地址值。

    其他格式：

    int[] x; int x[];

    int[][] y; int[] y[]; int y[][];

     注意：

   二维数组和一维数组的比较：

/*
 *  题目：int[] x,y[];
 *  理解：
 *  int[] x;int x[];
 *  int[][] y;int y[][];int[] y[]
 * 
 *  问题：
 *  a.
 *  x[0] = y;//error
 *  
 *  b.
 *  y[0] = x;//yes
 *  
 *  c.
 *  y[0][0] = x;//error
 *  
 *  d.
 *  x[0][0] = y;//error
 *  
 *  e.
 *  y[0][0] = x[0];//yes
 *  
 *  f.
 *  x= y;//error
 */

    理解：把x[0]理解为一个一维数组。x[0]存的是一个具体的值。

                y[0]理解为一个引用。它与x相同，因为都是一个引用地址。