Java数据结构——自定义数组（内部实现冒泡、选择、插入排序）

最近在系统地看数据结构相关的知识，发现数据结构还是比较有意思的，参考网上的一些博客，我也花了一点时间，写了一个demo，主要是实现了通过数组实现了一个“变长数组”（当然不支持扩容，只支持缩容 0.0），里面定义了一些增删改查的方法，主要是练手，对于一些排序，突然写一下顿觉手生，所以记录一下 ， 代码如下：

package test.TestDataStructure.Array;

public class MyIntegerArray {

    private final int arrSize;

    private final int[] arr;

    private int exactSize;

    public MyIntegerArray(int arrSize){
        if(arrSize <=0){
            this.arrSize = 5;
        }else{
            this.arrSize = arrSize;
        }
        exactSize = 0;
        arr = new int[this.arrSize];
    }

    /*增加一个值*/
    public boolean add(int value){
        if(exactSize >= arrSize){
            return false;
        }else{
            arr[exactSize] = value;
            exactSize++;
            System.out.println("添加值: "+value+" 成功，目前数组中有 "+exactSize+" 个元素");
            return true;
        }
    }

    public boolean add(int... intList){
        if(intList.length+exactSize > arrSize){
            System.out.println("超出数组范围不能添加，数组最多容纳 "+arrSize+" 个元素，目前元素个数 : "+exactSize+" , 您添加了 "+intList.length+"个");
            return false;
        }
        for (int i : intList){
            add(i);
        }
        return true;
    }

    /*删除一个值，返回成功或者失败*/
    public boolean delete(int value){
        if(exactSize == 0){
            System.out.println("删除失败，数组为空");
            return false;
        }else{
            int index = -1;
            for (int i = 0; i < exactSize; i++) {
                if(arr[i] == value){
                    index = i;
                    break;
                }
            }

            if(index == -1){
                System.out.println("删除失败，不存在给定的值: "+value);
                return false;
            }

            for (int i = index; i < exactSize; i++) {
                if(i == (exactSize-1)){
                    arr[i] = 0;
                }else{
                    arr[i] = arr[i+1];
                }
            }
            exactSize--;
            System.out.println("值: "+value+" 删除成功");
            return true;
        }

    }

    /*返回某个值的标*/
    public int find(int value){
        int result = -1;
        if(exactSize >0){
            for (int i = 0; i < exactSize; i++) {
                if(arr[i] == value){
                    result = i;
                    System.out.println("值: "+value+" 的下标是: "+result);
                    break;
                }
            }
        }
        if(result == -1){
            System.out.println("不存在值: "+value);
        }
        return result;


    }

    /*获取对应下标的值*/
    public int get(int index){
        if(index >=exactSize || index<0){
            System.out.println("超出数组范围");
        }
        return arr[index];

    }

    public int getSize(){
        return exactSize;
    }


    public boolean modify(int oldVal,int newVal){
        int index = find(oldVal);
        if(index == -1){
            return false;
        }else{
            arr[index] = newVal;
            return true;
        }
    }

    public void display(){
        if(exactSize <= 0){
            System.out.print("数组为空");
        }else{
            System.out.print("数组展示 : [ ");
            for (int i = 0; i < exactSize; i++) {
                System.out.print(arr[i]+" ");
            }
            System.out.print("]");
        }
        System.out.println();
    }

    /*冒泡排序性能分析：

　　假设参与比较的数组元素个数为 N，则第一轮排序有 N-1 次比较，第二轮有 N-2 次，如此类推，这种序列的求和公式为：

　　（N-1）+（N-2）+...+1 = N*（N-1）/2

　　当 N 的值很大时，算法比较次数约为 N2/2次比较，忽略减1。

　　假设数据是随机的，那么每次比较可能要交换位置，可能不会交换，假设概率为50%，那么交换次数为 N2/4。不过如果是最坏的情况，初始数据是逆序的，那么每次比较都要交换位置。

　　交换和比较次数都和N2 成正比。由于常数不算大 O 表示法中，忽略 2 和 4，那么冒泡排序运行都需要 O(N2) 时间级别。

　　其实无论何时，只要看见一个循环嵌套在另一个循环中，我们都可以怀疑这个算法的运行时间为 O(N2)级，外层循环执行 N 次，内层循环对每一次外层循环都执行N次（或者几分之N次）。这就意味着大约需要执行N2次某个基本操作。*/

    /*冒泡1*/
    /*从小到大*/
    public void bubbleSortUp1(){
        /*当前拿第i下标的值和其他的比较 ， 将最大的数字放在第一个*/
        for (int i = 0; i < exactSize-1; i++) {
            for (int j = i+1; j < exactSize; j++) {
                if(arr[i] > arr[j]){
                    int tmp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = tmp;
                }
            }
        }
        display();
    }

    /*冒泡2*/
    /*从大到小*/
    public void bubbleSortDown1(){
        /*当前拿第i下标的值和其他的比较 ， 将最大的数字放在第一个*/
        for (int i = 0; i < exactSize-1; i++) {
            for (int j = i+1; j < exactSize; j++) {
                if(arr[i] < arr[j]){
                    int tmp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = tmp;
                }
            }
        }
        display();
    }

    /*冒泡3*/
    /*从小到大*/
    public void bubbleSortUp2(){
        /*总共几轮*/
        for (int i = 1; i < exactSize; i++) {
            /*每轮相邻的作比较，将最大的冒泡到最后一个位置上*/
            for (int j = 0; j < exactSize-i; j++) {
                if(arr[j] > arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        display();
    }

    /*冒泡4*/
    /*从大到小*/
    public void bubbleSortDown2(){
        /*总共几轮*/
        for (int i = 1; i < exactSize; i++) {
            /*每轮相邻的作比较，将最大的冒泡到最后一个位置上*/
            for (int j = 0; j < exactSize-i; j++) {
                if(arr[j] < arr[j+1]){
                    int tmp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = tmp;
                }
            }
        }
        display();
    }

    /*选择排序性能分析：

　　选择排序和冒泡排序执行了相同次数的比较：N*（N-1）/2，但是至多只进行了N次交换。

　　当 N 值很大时，比较次数是主要的，所以和冒泡排序一样，用大O表示是O(N2) 时间级别。但是由于选择排序交换的次数少，所以选择排序无疑是比冒泡排序快的。当 N 值较小时，如果交换时间比选择时间大的多，那么选择排序是相当快的。*/
    /*选择排序*/
    public void chooseSort(){
        for (int i = 0; i < exactSize; i++) {
            int minIndex = i;
            for (int j = i+1; j < exactSize; j++) {
                if(arr[minIndex] > arr[j]){
                    minIndex = j;
                }
            }

            if(minIndex != i){
                int tmp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = tmp;
            }
        }
        display();
    }

    /*插入排序性能分析：

　　在第一轮排序中，它最多比较一次，第二轮最多比较两次，一次类推，第N轮，最多比较N-1次。因此有 1+2+3+...+N-1 = N*（N-1）/2。

　　假设在每一轮排序发现插入点时，平均只有全体数据项的一半真的进行了比较，我们除以2得到：N*（N-1）/4。用大O表示法大致需要需要 O(N2) 时间级别。

　　复制的次数大致等于比较的次数，但是一次复制与一次交换的时间耗时不同，所以相对于随机数据，插入排序比冒泡快一倍，比选择排序略快。

　　这里需要注意的是，如果要进行逆序排列，那么每次比较和移动都会进行，这时候并不会比冒泡排序快。*/

    /*插入排序 ： 直接插入排序*/

    /*例如3 1 2 1 4*/
    /* 第一次  3 \\ 1 2 1 4
    *  第二次  1 3 \\ 2 1 4
    * */
    public void insertSort(){
        /*从下标是1的元素开始，一个一个选择出来插入左边的“子数组”，开始“子数组”就有一个元素，然后每次都会将当前的这个值和“子数组”中的每一个依次比较（从左往右比，比较之后，当前的值小，就交换，当前值大就往后比。）*/
        for (int i = 1; i < exactSize; i++) {
            for (int j = 0; j < i; j++) {
                if(arr[j]>arr[i]){
                    int tmp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = tmp;
                }
            }
        }
        display();
    }



    public static void main(String[] args) {
        MyIntegerArray myIntegerArray = new MyIntegerArray(5);
        myIntegerArray.add(11,3,12,12,1);
        System.out.println("------------------------------------------");


        System.out.println("-----------------插入排序-----------------");
        MyIntegerArray insertTest = new MyIntegerArray(5);
        insertTest.add(3,1,2,1,4);
        insertTest.insertSort();
        System.out.println("------------------------------------------");
    }
    
    /*总结：
    * 上面讲的三种排序，冒泡、选择、插入用大 O 表示法都需要 O(N2) 时间级别。一般不会选择冒泡排序，虽然冒泡排序书写是最简单的，但是平均性能是没有选择排序和插入排序好的。

　　选择排序把交换次数降低到最低，但是比较次数还是挺大的。当数据量小，并且交换数据相对于比较数据更加耗时的情况下，可以应用选择排序。

　　在大多数情况下，假设数据量比较小或基本有序时，插入排序是三种算法中最好的选择。

　　后面我们会讲解高级排序，大O表示法的时间级别将比O(N2)小。　*/



}