数据结构与算法入门——线性结构之数组

一、数组的基本使用

 		//创建一个数组
        int[] arr1 = new int[3];
        int[] arr2 = new int[]{10,20,30};

        //获取数组的长度
        int len1 = arr1.length;
        int len2 = arr2.length;
        System.out.println("arr1的长度是"+len1);
        System.out.println("arr2的长度是"+len2);

        //访问数组中的元素：数组名[下标]  注意：下标从0开始，最大可取到长度-1
        System.out.println(arr1[2]);
        System.out.println(arr2[2]);

        //为数组中元素赋值
        arr1[0] = 99;
        arr1[1] = 98;
        arr1[2] = 97;

        //遍历数组
        for (int x:arr1) {
            System.out.println(x);
        }

         由此可见,数组被创造出来后，长度一定是被锁死的，所以我们需要解决数组长度不可变的问题：说白了就是用长度+1新数组替换掉旧数组

 //新建一个数组
        int[] arr = new int[]{1,2,3};
        //快速查看数组中的元素
        System.out.println(Arrays.toString(arr));
        //要加入数组中的元素
        int dst = 4;
        //创建一个新数组
        int[] newArr = new int[arr.length+1];
        //把原数组中的数据全部复制到新数组中
        for (int i=0;i<arr.length;i++){
            newArr[i] = arr[i];
        }
        //把目标元素放到数组的最后
        newArr[newArr.length-1] = dst;
        //用新数组替换掉旧数组
        arr=newArr;
        System.out.println(Arrays.toString(arr));

         同样的如果想删除数组中的某个元素，也是要创建一个长度-1新数组替换掉旧数组

//新建一个数组
        int[] arr = new int[]{1,2,3,4,5};
        //快速查看数组中的元素
        System.out.println(Arrays.toString(arr));
        //要删除的元素下标
        int dst = 2;
        //创建一个新数组
        int[] newArr = new int[arr.length-1];
        //把原数组中的数据全部复制到新数组中
        for (int i=0;i<newArr.length;i++){
            if (i<2){
                newArr[i] = arr[i];
            }else {
                newArr[i] = arr[i+1];
            }
        }
        //用新数组替换掉旧数组
        arr=newArr;
        System.out.println(Arrays.toString(arr));

二、面向对象的数组

          面向对象的数组是指把数组放在一个对象中，那么我们就可以通过对对象方法的调用实现对数据的管理

public class TestArray4Util {
    //新建一个数组
    private int[] elements;
    //构造方法
    public TestArray4Util(){
        elements = new int[0];
    }

    //获取数组长度的方法
    public int size(){
        return elements.length;
    }

    //打印数组元素
    public void show(){
        System.out.println(Arrays.toString(elements));
    }

    //往数组中添加一个元素的方法
    public void add(int element){
        //创建一个新数组
        int[] newArr = new int[elements.length+1];
        //将旧数组中的元素复制到新数组中去
        for (int i = 0; i < elements.length; i++) {
            newArr[i] = elements[i];
        }
        //将目标元素添加到新数组的最后一位
        newArr[newArr.length-1] = element;
        //用新数组代替旧数组
        elements = newArr;
    }

    //删除数组中某一元素的代码
    public void delete(int index){
        //判断下标是否越界
        if (index < 0 || index > elements.length-1){
            throw new RuntimeException("下标越界");
        }
        //创建一个新数组
        int[] newArr = new int[elements.length-1];
        //将旧数组中的元素赋值到新数组中
        for (int i = 0; i <newArr.length ; i++) {
            if (i<index){
                newArr[i] = elements[i];
            }else {
                newArr[i] = elements[i+1];
            }
        }
        //新数组替换旧数组
        elements = newArr;
    }

    //插入指定位置的元素
    public void insert(int index,int element){
     //判断下标是否越界
        if (index < 0 || index > elements.length-1){
            throw new RuntimeException("下标越界");
        }
        //创建一个新数组
        int[] newArr = new int[elements.length+1];
        //将旧数组中的元素复制到新数组中去
        for (int i = 0; i < elements.length; i++) {
            if (i<index){
                newArr[i] = elements[i];
            }else {
                newArr[i+1] = elements[i];
            }

        }
        //将要插入的元素添加到指定位置
        newArr[index] = element;
        //新数组替代旧数组
        elements = newArr;
    }

    //替换指定位置的元素
    public void set(int index,int element){
     //判断下标是否越界
        if (index < 0 || index > elements.length-1){
            throw new RuntimeException("下标越界");
        }
        elements[index] = element;
    }

    //取出指定位置的元素
    public int get(int index){
     //判断下标是否越界
        if (index < 0 || index > elements.length-1){
            throw new RuntimeException("下标越界");
        }
        return elements[index];
    }
}

三、查找算法之线性查找

          线性查找就是给你一个元素，你在数组中顺序查找是否有该元素存在，如果有，则显示下标，如果没有，则显示-1

		//创建一个数组
        int[] arr = new int[]{10,20,30,40,50};
        //要查找的元素
        int target = 30;
        //遍历并打印目标元素下标
        for (int i = 0; i <arr.length; i++) {
            if (target == arr[i]){
                System.out.println(i);
            }else{
            return -1;
            }
        }

四、查找算法之二分法查找

          二分法显而易见，先从中间开始找，将数组分成两份，若是中间的元素比目标元素大，那么只需要找前半段，反之则只需要找后半段，后面步骤同理，知道找处结果，因此二分法查找的使用是有条件的：即数组必须是顺序数组。

    //创建一个数组
        int[] arr = new int[]{10,20,30,40,50,60,70,80,90};
        //定义开始位置
        int begin = 0;
        //定义结束位置
        int end = arr.length-1;
        //定义中间位置
        int mid = (begin+end)/2;
        //要查找的元素
        int target = 50;
        //定义元素下标
        int index = -1;
        //遍历并打印目标元素下标
        while (true){
	            //如果开始位置跑到结束位置之后或者二者重叠，则没有该元素
	            if (begin>=end){
	               break;
	            }
                //如果元素正好处于正中间，则赋值并跳出循环
                if (target == arr[mid]){
                    index = mid;
                    break;
                }else {
                    //如果中间元素不相等，那么就要判断大小
                    if (target<arr[mid]){
                    //如果目标元素比中间元素小，则把末尾下标改成中间元素的前一个元素的下标
                        end = mid - 1;
                    }else {
                    //如果目标元素比中间元素大，则把开始下标改成中间元素的后一个元素的下标
                        begin = mid + 1;
                    }
                    //重新给中间元素下标赋值
                    mid = (begin+end)/2;
                }
        }
        //打印下标
        System.out.println(index);