数组详解

数组的定义：

数组是用来存储相同数据类型的有序数据结构；

数组的创建：

第一种形式：数据类型[] 名称

第二种形式：数据类型名称[]

数组的初始化：

第一种形式：声明创建，并分配存储空间赋值

int[] a = {1,2,3,4,5};

第二种形式：显式初始化

int[] a = new int[]{1,2,3,4,5};

第三种形式：显式初始化

int[] a = new int[5]

创建形式的区别：

第一种形式直接声明，进行空间分配，赋值，但是不能够分开，即不能先声明创建，之后赋值，必须一起；

第二种形式和第三种形式可以分开，第二种形式可以直接赋值，第三种形式可以指定数组长度；

数组创建首先分配内存，内存不能够改变，所以数组一经创建不能够修改数组长度；

数组的存储：

创建一个数组：int[] a = new int[](10);

首先我们需要jvm的存储结构，基本类型以及引用类型存放于栈内存中，其生命周期由作用域直接确定，new创建的对象以及数组存放于堆内存中，由jvm的垃圾回收机制进行处理；明白了这一点之后，我们对上面的数组创建进行剖析：

a：引用类型，存放于栈

new：创建出来的对象存放于堆

a其实就是指向new创建出来的数组对象在内存中的地址，或者叫做对象句柄；

数组的排序：

第一种形式：冒泡排序

排序思想：重复进行排序，每次排序依次比较相邻的两个元素，每次排序都将得到本轮的最大值；

排序轮数：arr.length

排序比较次数：arr.length * arr.length

时间复杂度：O（n*n）

核心代码：

int arr[] = new int[]{8,5,12,4,9,7,10,0,6};
for(int i = 0; i < arr.length - 1; i ++){
    for( int j = 1; j < arr.length; j ++){
        if (arr[j] < arr[j - 1]) {//每一次比较相邻的两个元素
            int temp = arr[j];
            arr[j] = arr[j - 1];
            arr[j - 1] = temp;
        }
    }
    System.out.println(Arrays.toString(arr));
}

第二种形式：快速排序

排序思想：每一趟排序都把数组分成两部分，一侧的数据都要比另一侧的数据大

核心代码：

public static void sort(int[] a,int low,int high){
    int start = low;
    int end = high;
    int key = a[low];
    while(end>start){//从后往前比较
        while(end>start&&a[end]>=key) end--;//如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
        if(a[end]<=key){
            int temp = a[end];
            a[end] = a[start];
            a[start] = temp;
        }
        while(end>start&&a[start]<=key){//从前往后比较
            start++;//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
        }
        if(a[start]>=key){
            int temp = a[start];
            a[start] = a[end];
            a[end] = temp;
        }//此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
    }
    //递归
    if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
    if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1到最后一个
}

第三种形式：插入排序

排序思想：将数组分成有序部分和无序部分，每次将无序部分的第一个元素插入到有序部分并排序；

排序轮数：arr.length - 1

排序比较次数：(arr.length - 1 ) + ... + 1 = arr.length * (arr.length - 1)/2

时间复杂度：理想情况O（n）,最坏情况O（n*n）

核心代码：

int[] arr = new int[]{8,5,12,4,9,7,10,0,6};
for (int i = 1; i < arr.length; i++){
    int j = i;
    int target = arr[i];
    while (j > 0 && target < arr[j - 1]) {
        //已经排序元素arr[j]和待排序元素进行比较，如果待排序小于已排序。进行交换
        //交换后，继续重复上面的比较；
        arr[j] = arr[j - 1];
        j--;
    }
    arr[j] = target;
    System.out.println(arr[j]);
    System.out.println(Arrays.toString(arr));
}

第四种形式：选择排序

排序思想：每一轮都从数组中取出本次最小的值，然后放入一个本次排序的起始位置

排序轮数：arr.length

排序比较次数：arr.length*(arr.length+1)/2

时间复杂度：O(n*n)

核心代码：

int arr[] = new int[]{8,5,12,4,9,7,10,0,6};
for (int i = 0; i < arr.length - 1; i ++){
    for(int j = i + 1; j < arr.length; j ++){
        if(arr[j] < arr[i]){
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    System.out.println(Arrays.toString(arr));
}

猜你喜欢