数组介绍及常用算法的 java 实现

数组是多个相同类型数据的组合，实现对这些数据的统一管理 。

数组的初始化：
一维数组： int[] a = new int[10];
二维数组： int[][] b = new int[3][4]; 或 int[][] b = new int[3][];

其中每个一维数组的长度是可变的
b[0] = new int[3];
b[1] = new int[4];
b[2] = new int[5];

数组一旦初始化，长度不可变 。

数组元素的默认初始化：
对于基本数据类型而言，默认初始化各有不同 。
对于引用类型而言，默认初始化为 null 。

注意特殊写法：int[]x,y[]; x 是一维数组 y 是二维数组 。

数组的介绍比较简单，主要看一下，对数组的增删改查和排序 。

在为数组添加数据时，我们可以实现有序数组 。
实现：

/**
     * 添加数据 (实现有序排列 从小到大)
     *
     * 原理：来一个数据，去找到比它大的，记录位置 index，然后将index 及其后面的所有元素后移一位
     * @param value
     * @return
     */
    public void insert(int value){
        int i;
        for(i = 0; i < elements;i ++){
            if(arr[i] > value){
                break;
            }
        }
        for(int j = elements ;j > i; j --){
            arr[j] = arr[j - 1];
        }
        arr[i] = value;
        elements ++;
    }
//elements 为数组的有效长度

所以说，有序数组的插入是比较慢的，因为要进行比较 。

在删除数组元素的时候，其实是从删除位置的后一位开始依次向前覆盖 。 这样最终的效果就是指定位置的元素被删除了 。

// index 为要删除的数据的索引
 for (int i = index ; i < arr.length; i ++){
            arr[index] = arr[index + 1];
        }

数组的修改直接把指定位置的数据修改即可 。

数组的查找直接给定索引值即可查找 。或是给定元素，遍历数组查找（较慢） 。有没有什么提高效率的算法呢 ？

我们可以使用二分法查找 。
具体实现：

/**
     * 使用二分法查找
     *
     * 原理：前提是有序数组。每次都是和中间的数据做比较。
     * 若大于中间的数，则与四分之三处的元素比较。
     * 若小于中间的数，则与四分之一处的元素比较。
     * 以此类推
     * @param vlaue
     * @return
     */
    public int binarySearch(int vlaue){
        int middle = 0;
        int low = 0;
        int pow = arr.length;

        while (true){
            middle = (low + pow) / 2 ;
            if(arr[middle] == vlaue){
                return middle;
            }else if (low > pow){
                return -1;
            }else{
                if(arr[middle] > vlaue){
                    pow = middle - 1;
                }else{
                    low = middle + 1;
                }
            }
        }
    }

数组的简单排序算法原理及实现 。

1 冒泡排序

 /**
     * 简单排序之 冒泡排序
     *
     * 原理：用最后一个和前一个进行比较，
     * 若是小于 则进行交换，依次进行，这样经过一轮，最小的数就在最上面了。
     * @param arr 需要排序的数组
     */
    public static void bubbleSort(int[] arr){
        int temp = 0;
        for (int i = 0;i < arr.length - 1; i++ ){
            for (int j = arr.length - 1;j > i; j --){
                if(arr[j] < arr[j -1]){
                    temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }
            }
        }
    }

2 选择排序

/**
     * 简单排序之 选择排序
     *
     * 原理：用一个指针 k 索引，和k之后的数据进行比较，若是小于k的话，就将K指向它，
     * 最后用 i 记录最小的那个数。
     *
     * @param arr
     */
    public static void selectionSort(int[] arr){
        int temp = 0;
        for (int i = 0;i < arr.length - 1;i ++){
            int k = i;
            for (int j = i;j < arr.length;j ++){
                if(arr[j] < arr[k]){
                    k = j;
                }
            }
            if( i != k){
                temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }
        }
    }

3 插入排序

/**
     * 简单排序之 插入排序
     *
     * 原理：使用 i 遍历数组，从第二个数开始，将 i 指向的值放入temp中，使用 j 去遍历，i 前面的数，
     * 判断，当 j 指向的值大于temp时，也就是 i 时，要将j的值赋给 i ,依次向左，
     * 最终将将 temp 的值放入不满足条件的地方（即左边的值小于temp时）。
     *
     * @param arr
     */
    public static void insertSort(int[] arr){
        for (int i = 1;i < arr.length; i++){
            int temp = arr[i];
            int j = i -1;
            while (j >= 0 && arr[j] >= temp){
                arr[j+1] = arr[j];
                j --;
            }
            arr[j+1] = temp;
        }
    }

---

java 能动态分配数组吗？
答：可以 。int i = 12;int[] myInt = new int[i];

---

我怎么知道数组的长度？
.length 属性获取

---

数组有没有 length() 这个方法 ? String 有没有 length() 这个方法
答：数组没有 length() 这个方法，有 length 的属性。String 有 length() 这个方法

---

Java 中的任何数据类型都可以使用 System.out.pritln 方法显示。
对基本数据类型而言，输出的往往是变量的值；
对于像数组这一类复杂的数据类型，输出的是引用，有些不是引用，那是因为重新了 toString( ) 方法 。

---

String[] stringArray = new String[3]; // 各元素的值默认为null
for (int i = 0; i < stringArray.length; i++) { // 对各元素进行初始化，但没有赋值。
stringArray[i] = new String();
System.out.println(stringArray[i]);
}
空 （有别于 null）

---

操作二维数组不应使用常数来控制维数 。具体方法是 array.length 表示行数，array[row].length 来表示 row 行的列数 。这样当数组行数和列数不相等时，代码可以自动调整为正确的值 。

---

下面数组定义正确的有_
A.String strs[] = { ‘a’ ‘b’ ‘c’};
B.String[] strs = {“a”, “b”, “c”};
C.String[] strs = new String{“a” ”b” ”c”};
D.String strs[] = new String[]{“a”, “b”, “c”};
E.String[] strs = new String[3]{“a”, “b”, “c”};

B、D

---

//输入任意一个人的年龄，就可以判断出他是哪个年龄段的人？

/*
0-9 儿童
10-19 少年
20-29 青少年
30-39 青年
40-49 壮年
50-59 中年
60-69 中老年
70-79 老年
80-89 老老年
90-99 老老老年
*/
应用数据结构的思想
int age = 22;
String[] arr = {“儿童”,”少年”,”青少年”,”青年”,”壮年”,”中年”,”“,”“,”“,”“};
int idx = age/10;
System.out.println(arr[idx])

---