深入理解数组-下

本文以实践为主，举几个基本的常用的例子。所以源码已上传至github:链接

No.1 实现一个大小固定的有序数组，支持动态增删改操作，支持动态扩容 

1.查找数组中指定元素

	public int find(int index) {
		if (index < 0 || index > count)
			return -1;
		return array[index];
	}复制代码

2.向数组中插入元素，如果数组已满，则扩容

	public boolean insert(int index, int value) {
		if (index < 0 || index > count)
			return false;
		if (count == size) {
			arrayExpansion(size * 2);
			System.out.println("动态扩容....");
		}

		for (int i = count - 1; i > index; --i) {
			array[i + 1] = array[i];
		}
		array[index] = value;
		++count;
		return true;
	}复制代码

3.删除元素，当数组中元素数量小于一定程度的时候，则进行缩容

	public boolean delete(int index) {
		if (index < 0 || index > count)
			return false;
		for (int i = index + 1; i < count; i++) {
			array[i - 1] = array[i];
		}
		--count;
		// 缩容
		if (count == array.length / 4 && array.length / 2 != 0) {
			arrayExpansion(array.length / 2);
			System.out.println("动态缩容....");
		}
		return true;
	}复制代码

4.扩容方法

	private boolean arrayExpansion(int capacity) {
		int[] newArray = new int[capacity];
		for (int i = 0; i < size; i++) {
			newArray[i] = array[i];
		}
		array = newArray;
		return true;
	}复制代码

5.测试

	public static void main(String[] args) {
		Array array = new Array(10);
		for (int i = 0; i < array.size; ++i) {
			array.insert(i, i);
		}
		array.printAll();
		//扩容
		array.insert(10, 10);
		array.printAll();
		//缩容
		for (int i = array.size; i > array.size/ 4; --i) {
			array.delete(i);
		}
		array.printAll();
	}复制代码

6.运行结果

No.2 实现两个有序数组合并为一个有序数组 .

描述：

将一个长度为m的有序数组array1和一个长度为n的有序数组array2合并为一个有序数组。

思路1：

首先想到的方法是创建一个长度为m+n的array3数组，以此从array1和array2中取出元素进行比较，然后将较小的元素加入array3，然后在考虑array1数组有剩余和array2数组有剩余的两种情况，最后在把新数组的元素重新加入到array3数组中即可。

但是这种思路会占用额外的空间。

具体实现如下：

	public int[] merge1(int[] array1, int m, int[] array2, int n) {
		int[] array3 = new int[m + n];
		int i = 0;
		int j = 0;
		int k = 0;
		// 通过一个while循环来进行添加
		while (i < m && j < n) {
			if (array1[i] < array2[j]) {
				// 将array1的元素加入array3，下标各加一
				array3[k++] = array1[i++];
			} else {
				// 将array2的元素加入array3，下标各加一
				array3[k++] = array2[j++];
			}
		}
		// 如果array1有剩余
		if (i != m) {
			while (i < m) {
				array3[k++] = array1[i++];
			}
		}
		// 如果array2有剩余
		if (j != n) {
			while (j < n) {
				array3[k++] = array2[j++];
			}
		}
		return array3;
	}复制代码

测试结果：

思路2:

因为从前往后排序的话，会涉及到数组元素多次移动，所以我们考虑从后往前进行排序，也就是末尾排序法。

前提：默认array1数组长度为m+n

具体实现如下：

public int[] merge2(int[] array1, int m, int[] array2, int n) {
		// 两个有序数组所有数组总和
		int num = m + n - 1;
		--m;
		--n;
		while (m >= 0 && n >= 0) {
			if (array2[n] > array1[m]) {
				array1[num--] = array2[n--];
			} else {
				array1[num--] = array1[m--];
			}
		}
		// 将n中剩余的数据加入array1
		while (n >= 0) {
			array1[num--] = array2[n--];
		}
		return array1;
	}复制代码

或者更精简，一个三元表达式搞定

	public int[] mergeOpt2(int[] array1, int m, int[] array2, int n) {
		int num = m + n - 1;
		int i = m - 1;
		int j = n - 1;
		while (j >= 0) {
			array1[num--] = i >= 0 && array1[i] > array2[j] ? array1[i--] : array2[j--];
		}
		return array1;
	}复制代码

测试结果：

end

您的点赞和关注是对我最大的支持，谢谢！