数组的算法升华提高对数组的理解

数组的算法升华

1. 数组的反转

方法有两种：

1、借助一个新数组

2、首尾对应位置交换

第一种方式示例代码：

int[] arr = {1,2,3,4,5,6,7,8,9};

//(1)先创建一个新数组
int[] newArr = new int[arr.length];

//(2)复制元素
int len = arr.length;
for(int i=0; i<newArr.length; i++){
    newArr[i] = arr[len -1 - i];
}

//(3)舍弃旧的，让arr指向新数组
arr = newArr;//这里把新数组的首地址赋值给了arr

//(4)遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

缺点：需要借助一个数组，浪费额外空间，原数组需要垃圾回收

第二种方式示例代码：

实现思想：数组对称位置的元素互换。

	public static void main(String[] args){
		int[] arr = {1,2,3,4,5,6,7,8,9};

		//左右对称位置交换
		for(int left=0,right=arr.length-1; left<right; left++,right--){
		    //首  与  尾交换
		    int temp = arr[left];
		    arr[left] = arr[right];
			arr[right] = temp;
		}

		//（3）遍历显示
		for(int i=0; i<arr.length; i++){
		    System.out.println(arr[i]);
		}
	}

2. 数组的扩容

int[] arr = {1,2,3,4,5,6,7,8,9};

//如果要把arr数组扩容，增加1个位置
//(1)先创建一个新数组，它的长度 = 旧数组的长度+1，或者也可以扩大为原来数组长度的1.5倍，2倍等
int[] newArr = new int[arr.length + 1];

//(2)复制元素
//注意：i<arr.length   因位arr比newArr短，避免下标越界
for(int i=0; i<arr.length; i++){
    newArr[i] = arr[i];
}

//(3)把新元素添加到newArr的最后
newArr[newArr.length-1] = 10;

//(4)如果下面继续使用arr，可以让arr指向新数组
arr = newArr;

//(4)遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

（1）至于新数组的长度定义多少合适，看实际情况，如果新增的元素个数确定，那么可以增加指定长度，如果新增元素个数不确定，那么可以扩容为原来的1.5倍、2倍等
（2）数组扩容太多会造成浪费，太少会导致频繁扩容，效率低下

3. 数组元素的插入

//在索引index位置插入一个整数5
int index=1;
int[] arr={1,2,3,4};
//创建新数组扩容
int[] newArr=new int[5];
//复制数组
for (int i = 0; i < arr.length; i++) {
    newArr[i]=arr[i];
}
//向后移动插入位置之后的每个元素
for (int i = newArr.length - 1; i >= 0; i--) {
    if(i>index){
        newArr[i]=newArr[i-1];
    }
}
//插入新元素
newArr[index]=5;
arr=newArr;
//遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

4. 数组元素的删除

//删除索引1位置的元素
int[] arr={1,2,3,4,5};
//把删除位置之后的每个元素向前移动
for (int i = 0; i < arr.length-1; i++) {
    if(i>=1){
        arr[i]=arr[i+1];
    }
}
//根据实际业务需求，把最后位置的元素修改为null
//使得垃圾回收尽快回收对应对象的内存
arr[arr.length-1]=null;
//遍历显示
for(int i=0; i<arr.length; i++){
    System.out.println(arr[i]);
}

5. 数组的二分查找

二分查找：折半查找，前提条件是有序的数组

要求：要求数组元素必须支持比较大小，并且数组中的元素已经按大小排好序

class Exam2{
    public static void main(String[] args){
        int[] arr = {2,5,7,8,10,15,18,20,22,25,28};//数组是有序的	
        //二分查找
        int num = 18;//目标值
        int index = -1;//目标的位置默认为-1表示不存在
        int left = 0;//左边位置默认为最小索引位置
        int right = arr.length - 1;//右边位置默认为最大索引位置
        int mid;//中间位置
        //循环查找，每次查找left与right之间的数据，并比较中间位置元素与目标元素的大小
        do {
            //每次计算中间位置
            mid = (left + right) / 2;
            if (num == arr[mid]) {//目标元素等于中间位置元素时，找到
                index = mid;//保存找到的元素位置
                break;//跳出循环
            }
            if (num > arr[mid])//目标元素比中间位置元素大时
                left = mid + 1;//修改新的左边位置
            if (num < arr[mid])//目标元素比中间位置元素小时
                right = mid - 1;//修改新的右边位置
        } while (left <= right);//当左右位置重合时说明已经找遍了整个数组。

        if(index==-1){
            System.out.println(value + "不存在");
        }else{
            System.out.println(value + "的下标是" + index);
        }

    }
}