数组以及常用的几种排序

一、使用数组的原因

当需要定义多个数据类型相同的变量，可以选择数组来定义

二、数组的定义方式

1.静态定义

int []x = {1,4,5};//下标为0.1.2   下标也叫（索引index）

2.动态定义

int []x =new  int [4];

三、数组的赋值和内存存储

单个元素 通过索引赋值
多个元素 通过循环赋值（有规律的单个元素）
堆 栈 方法区中数组的表现形式(如下图)

四、数组的工具类Arrays

父类是Object
主要是实现了搜索、转化成列表（list）、排序、equals()、以及数组以字符串的形式输出

五、数组的排序

Arrays.sort();

扩展：常见的几种排序方式

1.选择排序

原理：第一个元素与后面的所有元素比较，比较完最小的数就会出现在最左边，以此类推
代码如下：

public class SelectionSort {
    public static void sort(int[] data) {
        for (int x = 0; x < data.length - 1; x++) {
            for (int y = x + 1; y < data.length; y++) {
                if (data[y] < data[x]) {
                    SortTest.swap(data, x, y);
                }
            }
        }
    }
}

2.冒泡排序

原理：
先比较第一个数和第二个数的大小，大的就放在右边，然后继续让第二个和第三个比较，大的放在右边，依次到最后一个，最后一个一定是最大的，然后继续从第一个相邻的比较比到倒数第二个，直到比较完。
代码如下

14public class BubbleSort {
15    public static void sort(int[] data) {
16        for (int i = 0; i < data.length - 1; i++) {
17            for (int j = 0; j < data.length - 1 - i; j++) {
18                if (data[j] > data[j + 1]) {
19                    SortTest.swap(data, j, j + 1);
20                }
21            }
22        }
23    }
24}

3.插入排序

原理：
分为已有序和无序两个部分3， 每次处理就是将无序数列的第一个元素与有序数列的元素从后往前逐个进行比较， 找出插入位置，将该元素插入到有序数列的合适位置中

37public class InsertSort {
38    public static void sort(int[] data) {
39    	// i的初识值是1  a[0]  a[1]-a[n]
40    	//  i 用来控制 无序每个元素
41    	//  j 用来找位置 
42        for (int i = 1; i < data.length; i++) {
43            for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
44                SortTest.swap(data, j, j - 1);
45            }
46        }
47    }
48}

4.希尔排序

原理：
将数据插入到已有序的数列中
排序前：将每个元素看成有序的数列
第一趟排序后：得到一个有序数列，其大小为2
第二趟排序后：得到一个有序数列，其大小为3
第三趟排序后：得到一个有序数列，其大小为4
…每一趟插入排序，都可以将一个无序值插入一个有序数列，直至全部值有序

希尔排序的时间复杂度取决于步长的选择。 平均情况下，希尔排序的时间复杂度为O (Nlog 2 N)，最坏情况下为O (N 1.5)。

   public static void shellSort(int[] arrays) {


        //增量每次都/2
        for (int step = arrays.length / 2; step > 0; step /= 2) {

            //从增量那组开始进行插入排序，直至完毕
            for (int i = step; i < arrays.length; i++) {

                int j = i;
                int temp = arrays[j];

                // j - step 就是代表与它同组隔壁的元素
                while (j - step >= 0 && arrays[j - step] > temp) {
                    arrays[j] = arrays[j - step];
                    j = j - step;
                }
                arrays[j] = temp;
            }
        }


    }

六、数组的复制

System.arraycopy（原数组，原数组的起始位置，目标数组，目标数组的起始位置，被拷贝的数组的数量）；
代码如下：

package com.openlab.array;

import java.util.Arrays;

public class Test {
	
	public static void main(String[] args) {
		
		// AB123  A345E 2345E 1B3DE
        String [] key = new String[]{"1","2","3","4","5"};
        String [] result = new String[]{"A","B","C","D","E"};
        /**
         * 参数一:源数组
         * 参数二 源数组的起始位置
         * 参数三：目标数组
         * 参数四：目标数组的起始位置
         * 参数五：被拷贝的数组的数量
         */
        //System.arraycopy(key, 0, result, 2, key.length-2);
        //System.arraycopy(key,2 , result, 1, key.length-2);
        System.arraycopy(key, 0, result, 0, result.length-4);
        System.arraycopy(key, 2, result, 2, result.length-4);
        System.out.println(Arrays.toString(key));
        System.out.println(Arrays.toString(result));	
	}
}

七、多维数组

1.定义

静态：

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

动态：

int [][]a = new int[4][5];

int [][]a = new int [2][];
a[0] = new int[5];
a[1] = new int[3];