数组和冒泡、选择排序

数组

一个容器，是存放相同类型数据的集合

​ 长度一旦确定，不可变

​ 数组扩容：新建个大数组，小数组数据拷入大数组【效率低】

优点：

• 可以存基本类型的数据，也可以存引用类型的数据
• 内存地址是连续的；检索，查找某个下标的元素效率高

缺点：

• 随机删除，增加元素效率低
• 不能存大容量数据，很难在内存上找到特别大的连续的内存空间

//基本数据类型

//静态初始化
int[] array = {1,2,3};
// 动态初始化
int[] array1 = new int[5];

//引用数据类型
String[] array2 = xxx;
Person[] array3 = xxx;

所有的数组都有length属性

//length是属性，不是方法
int a = array1.length;

数组扩容

System.arroycopy(拷贝源，拷贝源的起始下标，目标数组，目标起始下标，拷贝长度);

二维数组

一维数组中的每个元素都是一维数组

int[][] a = {
    			{1,2,3},
             	{4,5,6,0},
             	{7,8,9}
            }

常用算法

数组工具类 ：java.util.Arrays

静态方法sort排序

Arrays.sort(int数组);

排序

冒泡排序：比较(n^2-n)/2次

比较的数据：9 7 5 8 10
    第一次循环：冒出最大的10
    7 9 5 8 10 （9和7比较，交换位置）
    7 5 9 8 10 （9和5比较，交换位置）
    7 5 8 9 10 （9和8比较，交换位置）
    7 5 8 9 10 （9和10比较，不交换位置）
    第二次循环：冒出9
    5 7 8 9   10 （7和5比较，交换位置）
    5 7 8 9   10 （7和8比较，不交换位置）
    5 7 8 9   10 （8和9比较，不交换位置）
    第三次循环：冒出8
    5 7 8   9 10 （5和7比较，不交换位置）
    5 7 8   9 10 （7和8比较，不交换位置）
    第四次循环：冒泡7
    5 7   8 9 10 （5和7比较，不交换位置）

public static int[] arraySort(int[] array){
        int temp = 0;
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1-i; j++) {
                if (array[j]>array[j+1]) {
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        return array;
}

选择排序 ：比较(n^2-n)/2次，但交换次数少

• 原理：找出最小的，和第一个交换位置
• 实现：比较数据，找出最小的数据的下标，然后使用这个下标的数据和第一个数据交换位置

比较的数据：9 7 5 8 10
    第一次循环结果：5和9交换位置
    5 7 9 8 10
    第二次循环结果：7不交换
    5   7 9 8 10
    第三次循环结果：8和9交换位置
    5 7   8 9 10
    第四次循环结果：不交换
    5 7 8   9 10

比冒泡排序效率高

查找

一个一个找

二分法查找：在已经排序的基础上实现

Arrays.binarySearch(数组对象，要查找的元素);//返回下标或者索引

稀疏数组

对数组压缩节省空间

n行三列:

第一行【数组行数，数组列数，有效数据个数】

第二行【第几行，第几列，数据】

…