第一天学习笔记之数组（冒泡排序+二分查找）

为了更深理解ArrayList实现原理，从今天开始学习算法和数据结构，更好的掌握底层原理。

在实际的项目工作过程中，数组已经很少用到，被各种封装的第三方类占据我们的程序中

但是要想写出优雅的代码，第三方类库中提供的函数我们应该了解其实现规则，后续我们也可以写出同样的代码。

下面开始第一个最简单的数组学习

public class BatArray {
    private long[] arr ;
    private int elements = 0;

    public BatArray(int arraylength){
        if (arraylength > 0){
            arr = new long[arraylength];
        }else{
            arr = new long[100];
        }
    }

    public void insert(long value){
        arr[elements] = value;
        elements++;
    }

    //常规查询
    public int search(Long value){
        for (int i=0;i<elements;i++){
            if(arr[i] == value){
                return i;
            }
        }
        return -1;
    }
    //二分查找算法  针对有序数组
    public int binarySearch(long vaue){
        int middle = 0;
        int low = 0;
        int pow = elements;
        while(true){
            middle = (low + pow) / 2;
            if(arr[middle] == vaue){
                return middle;
            }else if(low > pow){
                return -1;
            }else{
                //比如 1 2 3 4 5  vlaue=2
                //第一次  middle = 2  arr[2]等于3大于value 去数组前半部分查找
                //第二次 pow等于1 middle等于0 arr[0]等于1小于value 去数组前半分部分的分半的后半部分 即2 和 3
                //第三次 low等于1 middle等于1 arr[1]等于2等于value 查找成功
                if(arr[middle] > vaue){
                    pow = middle - 1;
                }else{
                    low = middle + 1;
                }
            }
        }
    }

    /*冒泡排序思想  把最小的数据依次冒泡最前面 举例 5 2 4 1 3
     * 第一次排序 1和3做比较不变
     * 第二次排序 4和1做比较 变成 5 2 1 4 3
     * 第三次排序 2和1做比较 变成 5 1 2 4 3
     * 第四次排序 5和1做比较 变成 1 5 2 4
     * 范围循环排序依次类推
     */
    public void bubbleSort(){
        long temp = 0;
        for(int i=0;i<elements;i++){
            for(int j=arr.length -1;j>i;j--){
                if(arr[j] < arr[j-1]){
                    temp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=temp;
                }
            }
            System.out.println("打印第"+ (i+1)+ "次排序后的效果");
            display();
        }
    }

    public void delete(Long value){
        for(int i=0;i<elements;i++){
            if (arr[i] == value){
                for(int j=i;j<elements-1;j++){
                    arr[j] = arr[j+1];
                }
                elements--;
                break;
            }
        }
    }

    public void update(int index,long value){
        if(index < elements){
            arr[index] = value;
        }
    }

    public void display(){
        for(int i=0;i<elements;i++){
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

测试类更好的让我们理解写的代码是否正确

public class demo {
    public static void main(String[] args){
        //数组长度 方便集成测试
        int length = 10;
        //生成随机数long测试 边界1--1000
        long min = 1;
        long max = 1000;

        BatArray batArray = new BatArray(length);
        for(int i=0;i<length;i++){
            batArray.insert(min+(long)(new Random().nextDouble()*(max - min)));
        }
        batArray.display();

       // long lvalue=80;
       // batArray.update(1,lvalue);
       // batArray.display();

       // System.out.println("查找元素的下标为:"+batArray.search(lvalue));

      //  batArray.delete(lvalue);
      //  batArray.display();
        batArray.bubbleSort();
        batArray.display();

        List<Long> list = new ArrayList<Long>();
    }
}

打印测试的效果

374 659 47 45 309 125 989 4 246 517 
打印第1次排序后的效果
4 374 659 47 45 309 125 989 246 517 
打印第2次排序后的效果
4 45 374 659 47 125 309 246 989 517 
打印第3次排序后的效果
4 45 47 374 659 125 246 309 517 989 
打印第4次排序后的效果
4 45 47 125 374 659 246 309 517 989 
打印第5次排序后的效果
4 45 47 125 246 374 659 309 517 989 
打印第6次排序后的效果
4 45 47 125 246 309 374 659 517 989 
打印第7次排序后的效果
4 45 47 125 246 309 374 517 659 989 
打印第8次排序后的效果
4 45 47 125 246 309 374 517 659 989 
打印第9次排序后的效果
4 45 47 125 246 309 374 517 659 989 
打印第10次排序后的效果
4 45 47 125 246 309 374 517 659 989 

实际操作一遍，看起来是不是很简单。下一篇学习将着重查找算法的分析。冒泡排序、选择排序、插入排序对于效率的对比。