一天一个Java基础——数组

一天一个变成了几天一个，最近接受的新东西太多、太快，有好多需要blog的但没有时间，这些基础知识应该是要深挖并好好研究的，不应该每次都草草了事，只看个皮毛。

数组：

　　JVM将数组存储在一个称为堆（heap）的内存区域中，堆用于动态内存分配，在堆中内存块可以按随意的顺序分配和释放
　　1.int[] a; ——表示声明一个数组（也可写为 int a[];）
　　　　声明一个数组变量时并不在内存中给数组分配任何空间，只是创建一个对数组的引用的存储位置
　　　　如果变量不包含对数组的引用，那么这个变量的值为null
　　　　通过new操作符创建数组
　　　　使用数组初始化语法时，必须将声明、创建和初始化数组都放在一条语句中，如下面代码是错误的：
　　　　　　

double[] myList;
myList = {1, 2, 3};

　　2.数组在方法中的传递

public static void main(String[] args) {
　　int x = 1;
　　int[] y = new int[10];
　　m(x,y);
　　syso("x is " + x);
　　syso("y[0] is" + y[0]);
}
public void m(int number, int[] numbers) {
　　number = 10;
　　numbers[0] = 10;
}

//output:
x is 1
y[0] is 10

　　　　这是因为：
　　　　　　对于基本数据类型参数，传递的是实参的值
　　　　　　对于数组类型参数，参数值是数组的引用，给方法传递的是这个引用

　　3.查询
　　　　线性查询与二分查询

package Test;

public class Test2 {
    /**
     * 二分查找：
     *     使用二分查找法的前提条件是数组中的元素必须已经排好序
     *  二分查找法首先将关键字与数组的中间元素进行比较，有下面3种情况
         *  1.如果关键字小于中间元素，只需要在数组的前一半元素中继续查找
         *  2.如果关键字大于中间元素，只需要在数组的后一半元素中继续查找
         *  3.如果关键字与中间元素相等，那么就找到了，查找结束
     *  如一个有1024（2^10）个元素的数组，最好情况下只需要比较11次，最坏情况下要比较1023次
     */
    
    public static void main(String[] args) {
        int[] list = {1, 4, 4, 2, 5, -3, 6, 2};
        int i = lineraSearch(list, 4);
        System.out.println(i);
        int j = lineraSearch(list, -4);
        System.out.println(j);
        int k = lineraSearch(list, -3);
        System.out.println(k);
        
        int[] list1 = {2, 4, 7, 10, 11, 45, 50, 59, 60, 66, 69, 70, 79};
        int i1 = binarySearch(list1, 2);
        System.out.println(i1);
        int j1 = binarySearch(list1, 11);
        System.out.println(j1);
        int k1 = binarySearch(list1, 79);
        System.out.println(k1);
        
        //output:
        /*
           1
          -1
           5
           0
           4
          12
         */
    }
    
    /**
     * 线性查找法——最简单、最low
     * @param list
     * @param key
     * @return
     */
    public static int lineraSearch(int[] list, int key) {
        for (int i = 0; i < list.length; i++) {
            if (key == list[i]){
                return i;
            }
        }
        return -1;
    }
    
    /**
     * 二分查找法
     * @param list
     * @param key
     * @return
     */
    public static int binarySearch(int[] list, int key) {
        int low = 0;
        int high = list.length - 1;
        while (high >= low) {
            int mid = (high + low) / 2;
            if (key < list[mid]) {
                high = mid - 1;
            } else if (key == list[mid]) {
                return mid;
            } else {
                low = mid + 1;
            }
        }
        return -1;
    }

}

　　4.排序
　　　　选择排序

/*
     * 选择排序
     *     1.选择排序法先找到数列中最小的数
     *     2.然后将它放在数列的最前面
     *     3.在剩下的数中，循环1、2操作
     */
    public static void selectionSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            int minValue = array[i];
            int minIndex = i;
            for (int j = i + 1;j < array.length;j++) {
                if (array[j] < minValue) {
                    minValue = array[j];
                    minIndex = j;
                }
            }
            if (minIndex != i) {
                array[minIndex] = array[i];
                array[i] = minValue;
            }
        }
    }

　　　　插入排序

/*
     * 插入排序
     *     1.外层循环（循环控制变量i）的迭代是为了获取已排好序的子数列
     *     2.内层循环（循环控制变量k）将list[i]插入到从list[0]到list[i-1]的子数列中
     */
    public static void insertionSort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            int minValue = array[i];
            int k;
            for (k = i - 1;k >= 0 && minValue < array[k]; k--) {
                array[k + 1] = array[k];
            }
            array[k + 1] = minValue;
        }
    }

　　　　冒泡排序
　　　　快速排序