【数据结构与算法】数组的增删改查

int[] arr = new int[10];
length = 0;
for(int i = 0; i < 5; i++){
    arr[length++] = i + 1;
}
System.out.println(“数组容量： ” + arr.length)；
System.out.println(“数组长度： ” + length；

/**
* 插入元素到数组开头
* @param arr 待插入元素的数组
* @param val 待插入的元素
* @return 插入元素后的数组
*/
public int[] insertStart(int[] arr, int val){
    // 用于存放插入元素后的数据
    int[] destArr = new int[arr.length + 1];
    // 将元素插入新数组开头，同时将原数组整体赋值给新数组
    destArr[0] = val;
    for(int i = 0; i < arr.length; i++){
        destArr[i + 1] = arr[i];
    }
    return destArr;
}

/**
* 插入元素到数组开头
* @param arr 待插入元素的数组
* @param val 待插入的元素
* @return 插入元素后的数组
*/
public int[] insertEnd(int[] arr, int val){
    // 用于存放插入元素后的数据
    int[] destArr = new int[arr.length + 1];
    // 将元素插入新数组结尾，同时将原数组整体赋值给新数组
    destArr[arr.length] = val;
    for(int i = 0; i < arr.length; i++){
        destArr[i] = arr[i];
    }
    return destArr;
}

/**
* 插入元素到数组任意位置
* @param arr 待插入元素的数组
* @param val 待插入的元素
* @param index 待插入元素的索引位置
* @return 插入元素后的数组
*/
public int[] insertAnyWhere(int[] arr, int index, int val){
    // 用于存放插入元素后的数据
    int[] destArr = new int[arr.length + 1];
    // 将原数组插入元素位置前半段赋值给新数组
    for(int i = 0; i < index; i++){
        destArr[i] = arr[i];
    }
    // 将原数组插入元素位置后半段赋值给新数组
    for(int j = index; j < arr.length; j++){
        destArr[j + 1] = arr[j];
    }
    // 将元素插入新数组指定位置
    destArr[index] = val;
    return destArr;
}

/**
* 删除数组开头元素
* @param arr 待删除元素的数组
* @return 删除元素后的数组
*/
public int[] deleteStart(int[] arr){
    // 删除元素后，数组容量减小
    int[] destArr = new int[arr.length - 1];
    // 删除开头元素，相当与将后边的元素整体向前移动一位
    for(int i = 1; i < arr.length; i++){
        destArr[i - 1] = arr[i];
    }
    return destArr;
}

/**
* 删除数组末尾元素
* @param arr 待删除元素的数组
* @return 删除元素后的数组
*/
public int[] deleteEnd(int[] arr){
    // 删除元素后，数组容量减小
    int[] destArr = new int[arr.length - 1];
    // 删除最后一个元素，相当于不去管最后一个元素
    for(int i = 0; i < arr.length - 1; i++){
        destArr[i] = arr[i];
    }
    return destArr;
}

/**
* 删除数组任意位置元素
* @param arr 待删除元素的数组
* @param index 待删除元素索引位置
* @return 删除元素后的数组
*/
public int[] deleteMiddle(int[] arr, int index){
    // 删除元素后，数组容量减小
    int[] destArr = new int[arr.length - 1];
    // 删除任意位置元素，前半段保持
    for(int i = 0; i < index; i++){
        destArr[i] = arr[i];
    }
    // 后半段整体向前移动一位
    for(int j = index; j < arr.length - 1; j++){
        destArr[j] = arr[j + 1];
    }
    return destArr;
}

/**
* 修改数组任意位置元素
* @param arr 待修改元素的数组
* @param index 待修改元素索引位置
* @param val 修改后的元素值
* @return 修改元素后的数组
*/
public int[] update(int[] arr, int index, int val){
    arr[index] = val;
    return arr;
}

/**
* 线性查找
* @param array 
* @param target 要查找的目标值
* @return -1 说明未找到目标值，否则返回目标值索引位置
*/
public int linearSearch(int[] array, int target) {
    // 查找到目标值时，返回目标之索引位置
    for(int i = 0; i < array.length; i++){
      if(target == array[i]){
            reurn i;
        }    
    }
    return -1;
}

/**
* 二分查找
* @param array 
* @param target 要查找的目标值
* @return -1 说明未找到目标值，否则返回目标值索引位置
*/
public int binarySearch(int[] array, int target) {
    // 左右指针
    int left = 0; 
    int right = array.length - 1; 
    while(left <= right) {
        int mid = left + (right - left) / 2;
        // 当前值等于目标值时，返回当前索引位置
        if(array[mid] == target){
            return mid; 
        } else if (array[mid] < target){ // 当前值小于目标值，左指针向右移动一位
            left = mid + 1; 
        } else { // 当前值大于目标值，右指针向左移动一位
            right = mid - 1;
        }            
    }
    return -1;
}