Java动态数组及数组排序的三种常用方法

一、动态数组

1、数组的定义：

​ 用于存储相同数据类型的一组连续的存储空间

2、数组的特点：

​ 数组的长度一旦定义，则不可改变

​ 访问数组的元素需要通过下标（索引）访问，下标从0开始

​ 数组是引用数据内存，内存分布在堆内存中，数组的变量存储的内存地址

3、动态数组：

​ 由于数组的长度定义后不能改变，所谓“动态数组”是可以增加数组的长度，所以Java实现动态数组是改变数组变量指向不同的内存地址。 本质并没有将数组的长度改变。

​ 动态数组的本质：将内存空间的改变，以及指向数组内存的地址改变

​ 操作1：给数组添加新元素，可添加在最后面，也可添加到指定位置

/**
*添加元素（添加到末尾）
*/
public static int [] addEle(int [] array,int num){
    //目标数组	添加的原始
    //int [] array={10,9,3,2,1};

    //1、创建临时数组的变量
    int [] tempArray =new int[array.length+1];
    //2、将目标数组的元素copy到临时数组的内存中
    for(int i=0;i<array.length;i++){
        tempArray[i]=array[i];
    }
    //3、将添加的元素放入临时数组中
    tempArray[tempArray.length-1]=num;
    //4、将目标数组的地址指向临时数组的地址
    array=tempArray;//由于tempArray是局部变量，方法执行完内存自动回收，如果不返回 没有地址指向tempArray的内存，如果返回并接收，说明这块内存仍然有用。
    return array;
}

/**
     * 将元素num 添加到指定index的位置
     * @param arr
     * @param num
     * @param index
     * @return
     */
    public static int [] addEle(int [] arr , int num ,int index){
          // 1、创建临时数组的大小
           int [] tempArray = new int[arr.length+1];
           //2、遍历arr
           for(int i = 0 ; i<=arr.length;i++){
               //  如果i<index
               if(i<index){
                   tempArray[i] = arr[i];
               }else if(i==index){ // 2
                   tempArray[i] = num;
               }else{ // i > index
                   //  i=3   arr[i-1]   10  9  3  2  1     -> 10  9  5  3  0  0
                   // i =4   array[i-1]  2->    10  9  5 3  2 0
                   // i=5     array[4]   1  ->   10 9  5  3  2 1
                    tempArray[i] = arr[i-1];
               }
           }
           // 赋值
           arr = tempArray;
           return arr;

    }

操作2： 删除元素 ，删除指定下标的元素

/**
     *  删除指定下标的元素
     * @param arr 目标数组
     * @param index  删除的下标
     * @return 删除之后的数组
     */
    public static int [] removeEle(int [] arr, int index){

         // 1、创建一个临时数组 用于存放删除后的元素
        int [] tempArray = new int [arr.length-1];
        //  2、遍历目标数组
        for(int i = 0 ;i<arr.length;i++){
            if(i<index){
                tempArray[i] = arr[i];
            }else if(i==index){
                continue;
            }else {//i>index
                tempArray[i-1] = arr[i];
            }
        }
        // 3 将目标数组的地址变换成 新数组的地址
        arr=tempArray;
        return arr;

    }

二、数组的排序

排序：将一组数列（无序的）按照从小到大或者从大到小的顺序排列。

1、冒泡排序

​ 从第一个数开始，与它相邻的数比较，较大（或较小）的数放在后面，最终比较一轮之后，得出最大（或最小）的数放在最后

​ 比较思路：

冒泡排序的规则
*    1、从第一个数开始，将这个数 与它相邻的数比较 ，如果 这个数大于它相邻的数
*      则两个数交换位置
*       i=0   相邻i=1
*    2、依次 从第二个数开始，再将这个数与它相邻的数比较，如果第二个数大于相邻的数
*       则继续交换
*       依次类推， 到倒数第二个截止 ，直到将最大的数放在最后面
*     3、重复以上1,2步骤
/
 public static void main(String[] args) {
    int [] array = {5,4,3,2,1};

        //用于交换的临时变量
        int temp=0;

        for(int j =0;j<array.length-1;j++) {
            for (int i = 0; i < array.length -j-1; i++) {
                // 相邻的数比较
                if (array[i] > array[i + 1]) {
                    temp = array[i];
                    array[i] = array[i + 1];
                    array[i + 1] = temp;
                }
            }
            System.out.println("比较一轮之后：" + Arrays.toString(array));
        }
}

2、选择排序

/**
     *  选择排序： 从一堆数中选择一个最小数 放在第一个位置，再从一堆数中选择一个
     *          最小数放在第二个位置， 依次 将一堆数的最小数按顺序排放。
     *    步骤： 1、假设第一个数是最小数，需要定义最小数的下标minIndex=0
     *             将这个数与后面的每一个数比较，找到最小数的下标即可
     *          2、将第一个数与最小数的下标交换 ，得出最小数在第一位。
     *          3、 依次类推， 将已比较的数 忽略，继续从剩下的元素中找足最小数，放入已比较的数的下一位
     *              直到整个数列比较结束
     * @param args
     */
  public static void main(String[] args) {
            int [] array = {3,2,1,5,7,4};
            for(int j=0;j<array.length-1;j++) {
                // 假设第一个数是最小数
                int minIndex = j;
                // 为什么i =j+1  因为初始值要略过已比较的下标
                for (int i = 1+j; i < array.length; i++) {
                    if (array[minIndex] > array[i]) {
                        minIndex = i;
                    }
                }

                // 将这个最小数放在 第一位
                int temp = 0;
                temp = array[j];
                array[j] = array[minIndex];
                array[minIndex] = temp;

                System.out.println("----第一次完成后：" + Arrays.toString(array));
            }

        System.out.println("最后的排序："+Arrays.toString(array));
    }
}

3、插入排序

/**
     * 插入排序
     *    1、从第一个元素开始，假设第一个元素是已排好序的
     *    2、从下一个元素开始，依次比较它前面的所有元素（从后向前扫描）
     *    3、 如果这个元素 小于它前面的元素 则两两交换 ，
     *         如果这个元素 大于它前面的元素，则不交换
     *    4、依次重复2,3步骤  ，直到将所有数 比较完成
     *   5,4,3,2,1
     *
     *   4 5 3  2  1   i从1开始
     *
     *   4 3  5 2  1    i从2开始
     *   3 4  5 2 1
     *
     *   3 4 2 5 1    i从3开始
     *   3 2 4 5 1
     *   2 3 4 5 1
     *
     *   2 3 4 1 5   i从4开始
     *   2 3 1 4 5
     *   2 1 3 4 5
     *   1 2 3 4 5
     * @param args
     */
    public static void main(String[] args) {
        int [] array = {5,4,3,2,1};
        // 外层循环循环  每一个数的比较次数
        for(int j=0;j<array.length-1;j++) {
            int temp = 0;
            for (int i = 1+j; i > 0; i--) {
                if (array[i] < array[i - 1]) {
                    temp = array[i];
                    array[i] = array[i - 1];
                    array[i - 1] = temp;
                }
            }
            System.out.println("每一次完成后的结果："+ Arrays.toString(array));
        }
        System.out.println("最后一次完成后的结果："+Arrays.toString(array));

    }