改进的动态数组 （循环队列）
2021-01-22 本文已影响0人
游龙飞雪
（其实这种改进的动态数组，就是个循环队列！）
自己实现的常规的动态数组，其底层是由数组实现的。对前半部分的添加/删除操作需要挪动大量的元素（半数以上），如果频繁这种操作，及其消耗性能。
改进的动态数组，是设置一个first标识，来标记首元素在哪个位置。因为改进之后，首元素可能不在0位置。为什么呢，先来解释下改进之后的动态数组是什么模样。
正常的动态数组
正常的动态数组是从0-n编号的，其添加和删除只能把index后面所有的元素移动位置。
改进的动态数组
改进的动态数组，进行添加和删除操作的时候，挪动的元素最多是半数。
是这样操作的：操作之前会先判断目标index在数组的前半部分还是后半部分。如果在前半部分，则挪动index之前的元素；如果在后半部分，则挪动index之后的元素。
如果在前半部分挪动index之前的元素，则first前移一位。那么问题来了，first原本在0位置，往前挪动到哪里呢？其实，这就可以从数组容器最后面借一个位置。
image.png
这样在使用索引的时候，将表面索引对数组容器的容量取模 index % elements.count 就得出真实索引。
使用 first 、（index % count）来进行操作。
代码
代码在下面贴出来了，索引的转换使用 convertIndex(int index) 方法。
测试这个改进的动态数组的代码在后面。
源代码
package upgrade;
/**
* 动态数组的升级版
* ①标记第一个元素的位置
* ②挪动元素最多挪动一半元素
* ③查找索引indexOf
* ④扩容缩容
* @param <E>
*/
public class ArrayListUpgrade<E> {
/**
* 元素数量
*/
private int size = 0;
/**
* 所有元素
*/
private E[] elements;
/**
* 第一个元素的索引
*/
private int first = 0;
private static final int DEFAULT_CAPACITY = 10;
private static final int ELEMENT_NOT_FOUND = -1;
public ArrayListUpgrade(int capacity) {
int capa = capacity < DEFAULT_CAPACITY ? DEFAULT_CAPACITY : capacity;
elements = (E[]) new Object[capa];
}
public ArrayListUpgrade() {
this(DEFAULT_CAPACITY);
}
/**
* 元素的数量
*/
public int count() {
return size;
}
/**
* 清除所有元素
*/
public void clear() {
for (int i = 0; i < size; i++) {
elements[i] = null;
}
size = 0;
first = 0;
}
/**
* 是否为空
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 是否包含某个元素
*/
public boolean contains(E element) {
return indexOf(element) != ELEMENT_NOT_FOUND;
}
/**
* 添加元素到最后面
*/
public void add(E element) {
add(size, element);
}
/**
* 返回index位置对应的元素
*/
public E get(int index) {
rangeCheck(index);
return elements[convertIndex(index)];
}
/**
* 设置index位置的元素
*/
public E set(int index, E element) {
rangeCheck(index);
int insideIndex = convertIndex(index);
E old = elements[insideIndex];
elements[insideIndex] = element;
return old;
}
/**
* 往index位置添加元素
*/
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacity(size+1);
// 转换为可以内部使用的 currentIndex/ lastIndex
int current = convertIndex(index);
int last = convertIndex(size-1);
// 判断index属于前后哪一段
if (isInPrev(index)) //前半段前移
{
if(first == 0) { //特殊节点
first = elements.length - 1; //first前移到容器末尾
elements[first] = elements[0];
for (int i = 0; i < current; i++) {
elements[i] = elements[i+1];
}
} else {
for (int i = 0; i < index; i++) {
elements[convertIndex(i-1)] = elements[convertIndex(i)];
}
first -= 1;
}
current = convertIndex(index); //前半段前移，修改了first就要同步修改currentIndex
}
else //后半段后移
{
for (int i = size; i > index; i--) {
elements[convertIndex(i)] = elements[convertIndex(i-1)];
}
}
elements[current] = element;
size += 1;
}
/**
* 删除index位置对应的元素
*/
public E remove(int index) {
rangeCheck(index);
// 转换为可以内部使用的 currentIndex/ lastIndex
int current = convertIndex(index);
int last = convertIndex(size-1);
E old = elements[current]; //旧元素
// 判断index属于前后哪一段
if (isInPrev(index)) //前半段-前半段后移
{
for (int i = index; i > 0; i--) {
elements[convertIndex(i)] = elements[convertIndex(i-1)];
}
elements[first] = null;
first = (first + 1) % elements.length;
}
else //后半段-后半段前移
{
for (int i = index; i < size; i++) {
elements[convertIndex(i)] = elements[convertIndex(i+1)];
}
elements[last] = null;
}
size -= 1;
return old;
}
public E removeLast() {
return remove(size-1);
}
/**
* 查看元素的位置
*/
public int indexOf(E element) {
if(element == null) {
for (int i = 0; i < size; i++) {
if (elements[convertIndex(i)] == null) { return i; }
}
} else {
for (int i = 0; i < size; i++) {
if (elements[convertIndex(i)].equals(element)) { return i; }
}
}
return ELEMENT_NOT_FOUND;
}
// Mark: private method
/**
* 扩容
*/
private void ensureCapacity(int capacity) {
int old = elements.length;
if (old >= capacity) { return; }
int newcapa = old + (old >> 1);
E[] newEle = (E[]) new Object[newcapa];
for (int i = 0; i < size; i++) {
newEle[i] = elements[convertIndex(i)];
}
elements = newEle;
first = 0;
System.out.println("\n" + old + "扩容为：" + newcapa);
System.out.println("扩容后的数组容器为：");
this.printElements();
System.out.println("\n");
}
private void rangeCheck(int index) {
if (index < 0 || index >= size) {
outOfBounds(index);
}
}
private void rangeCheckForAdd(int index) {
if (index < 0 || index > size) {
outOfBounds(index);
}
}
private void outOfBounds(int index) {
throw new IndexOutOfBoundsException("index: " + index + ", size: " + size);
}
/** 将传进来的index转换为内部可以使用的index索引 */
private int convertIndex(int index) {
return (first + index) % elements.length;
}
/** 判断index在前后哪一段 */
private boolean isInPrev(int index) {
int mid = (size >> 1);
return index < mid;
}
@Override
public String toString() {
StringBuilder str = new StringBuilder();
str.append("count = ").append(size).append(", [");
if (size > 0) { str.append(elements[first]); }
for (int i = 1; i < size; i++) {
str.append(", ").append(elements[convertIndex(i)]);
}
str.append("]");
printElements();
return str.toString();
}
public String toStringln() {
StringBuilder str = new StringBuilder();
str.append("count = ").append(size).append(", [\n");
if (size > 0) { str.append(elements[first]); }
for (int i = 1; i < size; i++) {
str.append(", \n\t").append(elements[convertIndex(i)]);
}
str.append("\n]");
printElements();
return str.toString();
}
private void printElements() {
System.out.print("整个数组容器：[" + elements[0]);
for (int i = 1; i < elements.length; i++) {
System.out.print(", " + elements[i]);
}
System.out.println("]");
}
}
测试代码
public static void testArrayListUpgrade() {
System.out.println("test ArrayListUpgrade");
ArrayListUpgrade<Integer> list = new ArrayListUpgrade();
// add
System.out.println("\n//-add");
list.add(18);
list.add(22);
list.add(33);
list.add(99); //[18, 22, 33, 99]
System.out.println(list);
list.add(1, 55); //[18, 55, 22, 33, 99]
System.out.println(list);
list.add(1, 32); //[18, 32, 55, 22, 33, 99]
System.out.println(list);
list.add(4, 88); //[18, 32, 55, 22, 88, 33, 99]
System.out.println(list);
list.add(77);
list.add(66); //[18, 32, 55, 22, 88, 33, 99, 77, 66] , 9
System.out.println(list);
list.add(11); //[18, 32, 55, 22, 88, 33, 99, 77, 66, 11]
System.out.println(list);
// 测试扩容
System.out.println("\n//-扩容");
list.add(10); //[18, 32, 55, 22, 88, 33, 99, 77, 66, 11, 10]
System.out.println(list);
// remove
System.out.println("\n//-remove");
list.removeLast(); //[18, 32, 55, 22, 88, 33, 99, 77, 66, 11]
System.out.println(list);
list.remove(1); //[18, 55, 22, 88, 33, 99, 77, 66, 11]
System.out.println(list);
list.remove(5); //[18, 55, 22, 88, 33, 77, 66, 11]
System.out.println(list);
list.remove(0); //[55, 22, 88, 33, 77, 66, 11]
System.out.println(list);
// indexOf
System.out.println("\n//-indexOf");
Asserts.test(list.indexOf(55) == 0);
Asserts.test(list.indexOf(33) == 3);
Asserts.test(list.indexOf(11) == 6);
}
控制台输出结果
Hellow world!
test ArrayListUpgrade
//-add
整个数组容器：[18, 22, 33, 99, null, null, null, null, null, null]
count = 4, [18, 22, 33, 99]
整个数组容器：[55, 22, 33, 99, null, null, null, null, null, 18]
count = 5, [18, 55, 22, 33, 99]
整个数组容器：[55, 22, 33, 99, null, null, null, null, 18, 32]
count = 6, [18, 32, 55, 22, 33, 99]
整个数组容器：[55, 22, 88, 33, 99, null, null, null, 18, 32]
count = 7, [18, 32, 55, 22, 88, 33, 99]
整个数组容器：[55, 22, 88, 33, 99, 77, 66, null, 18, 32]
count = 9, [18, 32, 55, 22, 88, 33, 99, 77, 66]
整个数组容器：[55, 22, 88, 33, 99, 77, 66, 11, 18, 32]
count = 10, [18, 32, 55, 22, 88, 33, 99, 77, 66, 11]
//-扩容
10扩容为：15
扩容后的数组容器为：
整个数组容器：[18, 32, 55, 22, 88, 33, 99, 77, 66, 11, null, null, null, null, null]
整个数组容器：[18, 32, 55, 22, 88, 33, 99, 77, 66, 11, 10, null, null, null, null]
count = 11, [18, 32, 55, 22, 88, 33, 99, 77, 66, 11, 10]
//-remove
整个数组容器：[18, 32, 55, 22, 88, 33, 99, 77, 66, 11, null, null, null, null, null]
count = 10, [18, 32, 55, 22, 88, 33, 99, 77, 66, 11]
整个数组容器：[null, 18, 55, 22, 88, 33, 99, 77, 66, 11, null, null, null, null, null]
count = 9, [18, 55, 22, 88, 33, 99, 77, 66, 11]
整个数组容器：[null, 18, 55, 22, 88, 33, 77, 66, 11, null, null, null, null, null, null]
count = 8, [18, 55, 22, 88, 33, 77, 66, 11]
整个数组容器：[null, null, 55, 22, 88, 33, 77, 66, 11, null, null, null, null, null, null]
count = 7, [55, 22, 88, 33, 77, 66, 11]
//-indexOf
>>>>end
关于测试 indexOf ，由于使用Assert断言来判断，控制台没有错误就表示通过。所以本测试是通过的。
（其实这种改进的动态数组，就是个循环队列！）
本类是子类，代码还没有上传到github，如果有需要关联源代码的朋友，欢迎留言。
