第二章 动态数组
什么是数据结构?
- 数据结构是计算机存储、组织数据的方式
- 数据结构是指相互之间存在一种或多种特定关系的数据元素的集合
- 在实际应用中,根据使用场景来选择最合适的数据结构
线性表
线性表是具有 n 个相同类型元素的有限序列( n ≥ 0 )
- a1 是首节点(首元素), an 是尾结点(尾元素)
- a1 是 a2 的前驱节点, a2 是 a1 的后继节点
- 常见的线性表有:
- 数组
- 链表
- 栈
- 队列
- 哈希表(散列表)
数组(Array)
数组是一种顺序存储的线性表,所有元素的内存地址是连续的
- 在很多编程语言中,数组都有个致命的缺点:
- 无法动态修改容量
- 在实际开发中,我们更希望数组的容量是可以动态改变的
动态数组(Dynamic Array)
动态数组接口设计
int size(); // 元素的数量
boolean isEmpty(); // 是否为空
boolean contains (E element); // 是否包含某个元素
void add (E element); // 添加元素到尾部
E get (int index); // 获取index位置的元素
E set (int index, E element); // 设置index位置的元素
void add (int index, E element); // *在index位置插入一个元素*E remove (int index); // 删除index位置对应的元素
int indexOf (E element); // 查看元素的索引
void clear (); // 清除所有元素
数组的默认形态
添加元素 - add(E element)
add(E element)
:默认往数组最后添加元素
/**
* 添加元素到尾部
*
* @param element
*/
public void add(int element) {
elements[size++] = element;
}
删除元素 - remove(int index)
/**
* 删除index位置的元素
*
* @param index
* @return 返回删掉的元素
*/
public int remove(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
int old = elements[index];
for (int i = index + 1; i <= size - 1; i++) {
elements[i - 1] = elements[i];
}
size--;
return old;
}
思考:最后一个元素如何处理?
- 如果存放
int
类型,size--
后,最后一个元素已经无法访问了 - 如果使用泛型,数组要注意内存管理(将元素置为
null
) - 使用泛型技术可以让动态数组更加通用,可以存放任何数据类型
添加元素 - add(int index,E element)
add(int index, E element)
:在 index
位置插入一个元素
比如要往 index = 2
的地方添加元素:
正确的顺序应当是:从后往前开始将 index = 2
以后的元素依次后移,然后赋值:
如果从前往后开始移动元素,会造成如下错误的后果:
/**
* 在index位置插入一个元素
*
* @param index
* @param element
*/
public void add(int index, int element) {
//注意这个地方的index > size
if (index < 0 || index > size) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
for (int i = size - 1; i >= index; i--) {
elements[i + 1] = elements[i];
}
elements[index] = element;
size++;
}
如何扩容?- ensureCapacity(int capacity)
暴力方法:直接申请一块更大的内存
/**
* 扩容
*/
private void ensureCapacity(int capacity) {
int oldCapacity = elements.length;
if (oldCapacity >= capacity) {
return;
}
//扩容到原来容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
int[] newElements = new int[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i];
}
elements = newElements;
}
清空数组 - clear( )
/**
* 清除所有元素
*/
public void clear() {
for (int i = 0; i < size; i++) {
elements[i] = null;
}
size = 0;
}
int型动态数组完整代码
/**
* @author xiexu
* @create 2021-07-21 9:36 上午
*/
public class IntArrayList {
private int size; //元素的数量
private int[] elements; //所有的元素
private static final int DEFAULT_CAPACITY = 10; //默认容量
private static final int ELEMENT_NOT_FOUND = -1;
public IntArrayList(int capaticy) {
//小于默认容量的一律按默认容量处理
capaticy = (capaticy <= DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
elements = new int[capaticy];
}
public IntArrayList() {
//默认是10个容量
this(DEFAULT_CAPACITY);
}
/**
* 清除所有元素
*/
public void clear() {
size = 0;
}
/**
* 元素的数量
*
* @return
*/
public int size() {
return size;
}
/**
* 是否为空
*
* @return
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 是否包含某个元素
*
* @return
*/
public boolean contains(int element) {
return indexOf(element) != ELEMENT_NOT_FOUND;
}
/**
* 获取index位置的元素
*
* @param index
* @return
*/
public int get(int index) {
rangeCheck(index);
return elements[index];
}
/**
* 设置index位置的元素
*
* @param index
* @param element
* @return 原来的元素
*/
public int set(int index, int element) {
rangeCheck(index);
int old = elements[index];
elements[index] = element;
return old;
}
/**
* 添加元素到尾部
*
* @param element
*/
public void add(int element) {
add(size, element);
}
/**
* 在index位置插入一个元素
*
* @param index
* @param element
*/
public void add(int index, int element) {
rangeCheckForAdd(index);
//扩容
ensureCapacity(size + 1);
for (int i = size - 1; i >= index; i--) {
elements[i + 1] = elements[i];
}
elements[index] = element;
size++;
}
/**
* 删除index位置的元素
*
* @param index
* @return 返回删掉的元素
*/
public int remove(int index) {
rangeCheck(index);
int old = elements[index];
for (int i = index + 1; i <= size - 1; i++) {
elements[i - 1] = elements[i];
}
size--;
return old;
}
/**
* 查看元素的索引
*
* @param element
* @return
*/
public int indexOf(int element) {
for (int i = 0; i < size; i++) {
if (elements[i] == element) {
return i;
}
}
return ELEMENT_NOT_FOUND; //找不到就返回-1
}
//抛出异常
private void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
/**
* 检查范围
*
* @param index
*/
private void rangeCheck(int index) {
if (index < 0 || index >= size) {
outOfBounds(index);
}
}
/**
* 检查添加到指定位置元素的范围
*
* @param index
*/
private void rangeCheckForAdd(int index) {
if (index < 0 || index > size) {
outOfBounds(index);
}
}
/**
* 扩容
*/
private void ensureCapacity(int capacity) {
int oldCapacity = elements.length;
if (oldCapacity >= capacity) {
return;
}
//扩容到原来容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
int[] newElements = new int[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i];
}
elements = newElements;
System.out.println(oldCapacity + "扩容为:" + newCapacity);
}
/**
* 打印数组
*
* @return
*/
@Override
public String toString() {
//size = 3, [99,88,77]
StringBuilder string = new StringBuilder();
string.append("size = ").append(size).append(", [");
for (int i = 0; i < size; i++) {
if (i != 0) {
string.append(", ");
}
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
}
对象数组
泛型动态数组完整代码
使用泛型技术可以让动态数组更加通用,可以存放任何数据类型
/**
* @author xiexu
* @create 2021-07-12 5:11 下午
*/
public class ArrayList<E> {
private int size; //元素的数量
private E[] elements; //所有的元素
private static final int DEFAULT_CAPACITY = 10; //默认容量
private static final int ELEMENT_NOT_FOUND = -1;
public ArrayList(int capaticy) {
//小于默认容量的一律按默认容量处理
capaticy = (capaticy < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
elements = (E[]) new Object[capaticy];
}
public ArrayList() {
//默认是10个容量
this(DEFAULT_CAPACITY);
}
/**
* 清除所有元素
*/
public void clear() {
for (int i = 0; i < size; i++) {
elements[i] = null;
}
size = 0;
}
/**
* 元素的数量
*
* @return
*/
public int size() {
return size;
}
/**
* 是否为空
*
* @return
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 是否包含某个元素
*
* @return
*/
public boolean contains(E element) {
return indexOf(element) != ELEMENT_NOT_FOUND;
}
/**
* 获取index位置的元素
*
* @param index
* @return
*/
public E get(int index) {
rangeCheck(index);
return elements[index];
}
/**
* 设置index位置的元素
*
* @param index
* @param element
* @return 原来的元素
*/
public E set(int index, E element) {
rangeCheck(index);
E old = elements[index];
elements[index] = element;
return old;
}
/**
* 添加元素到尾部
*
* @param element
*/
public void add(E element) {
add(size, element);
}
/**
* 在index位置插入一个元素
*
* @param index
* @param element
*/
public void add(int index, E element) {
rangeCheckForAdd(index);
//扩容
ensureCapacity(size + 1);
for (int i = size; i > index; i--) {
elements[i + 1] = elements[i];
}
elements[index] = element;
size++;
}
/**
* 删除index位置的元素
*
* @param index
* @return 返回删掉的元素
*/
public E remove(int index) {
rangeCheck(index);
E old = elements[index];
for (int i = index + 1; i < size; i++) {
elements[i - 1] = elements[i];
}
elements[--size] = null;
return old;
}
/**
* 查看元素的索引
*
* @param element
* @return
*/
public int indexOf(E element) {
//null值的判断
if (element == null) { //如果当前元素是null
for (int i = 0; i < size; i++) {
if (elements[i] == null) {
return i;
}
}
} else { //如果当前元素不是null
for (int i = 0; i < size; i++) {
if (element.equals(elements[i])) {
return i;
}
}
}
return ELEMENT_NOT_FOUND; //找不到就返回-1
}
//抛出异常
private void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
/**
* 检查范围
*
* @param index
*/
private void rangeCheck(int index) {
if (index < 0 || index >= size) {
outOfBounds(index);
}
}
/**
* 检查添加到指定位置元素的范围
*
* @param index
*/
private void rangeCheckForAdd(int index) {
if (index < 0 || index > size) {
outOfBounds(index);
}
}
/**
* 扩容
*/
private void ensureCapacity(int capacity) {
int oldCapacity = elements.length;
if (oldCapacity >= capacity) {
return;
}
//扩容到原来容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E[] newElements = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i];
}
elements = newElements;
System.out.println(oldCapacity + "扩容为:" + newCapacity);
}
/**
* 打印数组
*
* @return
*/
@Override
public String toString() {
//size = 3, [99,88,77]
StringBuilder string = new StringBuilder();
string.append("size = ").append(size).append(", [");
for (int i = 0; i < size; i++) {
if (i != 0) {
string.append(", ");
}
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
}
Person类
/**
* @author xiexu
* @create 2021-07-12 9:42 下午
*/
public class Person {
private int age;
private String name;
public Person(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (obj instanceof Person) {
Person person = (Person) obj;
return this.age == person.age;
}
return false;
}
}
null值的处理
/**
* 查看元素的索引
*
* @param element
* @return
*/
public int indexOf(E element) {
//null值的判断
if (element == null) {
for (int i = 0; i < size; i++) {
if (elements[i] == null) {
return i;
}
}
} else {
for (int i = 0; i < size; i++) {
if (element.equals(elements[i])) {
return i;
}
}
}
return ELEMENT_NOT_FOUND; //找不到就返回-1
}
动态缩容操作的动态数组完整代码
/**
* 有动态缩容操作
*
* @author xiexu
* @create 2021-07-12 5:11 下午
*/
public class ArrayList2<E> extends AbstractList<E> {
private E[] elements; //所有的元素
private static final int DEFAULT_CAPACITY = 10;
public ArrayList2(int capaticy) {
//小于默认容量的一律按默认容量处理
capaticy = (capaticy < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capaticy;
elements = (E[]) new Object[capaticy];
}
public ArrayList2() {
//默认是10个容量
this(DEFAULT_CAPACITY);
}
/**
* 清除所有元素
*/
public void clear() {
for (int i = 0; i < size; i++) {
elements[i] = null;
}
size = 0;
if (elements != null && elements.length > DEFAULT_CAPACITY) {
elements = (E[]) new Object[DEFAULT_CAPACITY];
}
}
/**
* 元素的数量
*
* @return
*/
public int size() {
return size;
}
/**
* 是否为空
*
* @return
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 是否包含某个元素
*
* @return
*/
public boolean contains(E element) {
return indexOf(element) != ELEMENT_NOT_FOUND;
}
/**
* 获取index位置的元素
*
* @param index
* @return
*/
public E get(int index) { // O(1)
rangeCheck(index);
// index * 4 + 数组的首地址
return elements[index];
}
/**
* 设置index位置的元素
*
* @param index
* @param element
* @return 原来的元素
*/
public E set(int index, E element) { // O(1)
rangeCheck(index);
E old = elements[index];
elements[index] = element;
return old;
}
/**
* 添加元素到尾部
*
* @param element
*/
public void add(E element) { //O(1)
add(size, element);
}
/**
* 在index位置插入一个元素
*
* @param index
* @param element
*/
public void add(int index, E element) {
/**
* 最好:O(1)
* 最坏:O(n)
* 平均:O(n)
*/
rangeCheckForAdd(index);
//扩容
ensureCapacity(size + 1);
for (int i = size; i > index; i--) {
elements[i] = elements[i - 1];
}
elements[index] = element;
size++;
}
/**
* 删除index位置的元素
*
* @param index
* @return 返回删掉的元素
*/
public E remove(int index) {
/**
* 最好:O(1)
* 最坏:O(n)
* 平均:O(n)
*/
rangeCheck(index);
E old = elements[index];
for (int i = index + 1; i < size; i++) {
elements[i - 1] = elements[i];
}
elements[--size] = null;
trim();
return old;
}
/**
* 查看元素的索引
*
* @param element
* @return
*/
public int indexOf(E element) {
//null值的判断
if (element == null) {
for (int i = 0; i < size; i++) {
if (elements[i] == null) {
return i;
}
}
} else {
for (int i = 0; i < size; i++) {
if (element.equals(elements[i])) {
return i;
}
}
}
return ELEMENT_NOT_FOUND; //找不到就返回-1
}
/**
* 扩容
*/
private void ensureCapacity(int capacity) {
int oldCapacity = elements.length;
if (oldCapacity >= capacity) {
return;
}
//扩容到原来容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E[] newElements = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i];
}
elements = newElements;
System.out.println(oldCapacity + "扩容为:" + newCapacity);
}
/**
* 缩容
*/
private void trim() {
int oldCapacity = elements.length;
int newCapacity = oldCapacity >> 1;
if (size >= (newCapacity) || oldCapacity <= DEFAULT_CAPACITY) {
return;
}
//剩余空间还有很多
E[] newElements = (E[]) new Object[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i];
}
elements = newElements;
System.out.println(oldCapacity + "缩容为:" + newCapacity);
}
/**
* 打印数组
*
* @return
*/
@Override
public String toString() {
//size = 3, [99,88,77]
StringBuilder string = new StringBuilder();
string.append("size = ").append(size).append(", [");
for (int i = 0; i < size; i++) {
if (i != 0) {
string.append(", ");
}
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
}