【数据结构-Java描述】List接口/ArrayList与顺序表/LinkedList与链表
一.List接口
1.线性表
线性表是n个数据元素的有限序列，常见的线性表有顺序表、链表、栈、队列...
线性表上存放的元素呈一条连续的直线，所以说线性表在逻辑上是连续的，但在物理结构上不一定连续，因为线性表是可以由数组和链表实现的。
2.List接口
List是一个继承至Collection的接口，从数据结构的角度看，List是一个线性表，可以存储一组不唯一，类型相同，插入顺序有序的对象，并可以通过List接口提供的方法进行增删改查。
使用List接口能够精确的控制每个元素插入的位置，能够通过索引(元素在List中的位置)来访问List中的元素，第一个元素的索引为0，List允许有相同的元素。
List接口中的常用方法
| boolean add(E e) | 尾插 e |
| void add(int index, E element) | 将 e 插入到 index 位置 |
| boolean addAll(Collection c) | 尾插 c 中的元素 |
| E remove(int index) | 删除 index 位置元素 |
| boolean remove(Object o) | 删除遇到的第一个 o |
| E get(int index) | 获取下标 index 位置元素 |
| E set(int index, E element) | 将下标 index 位置元素设置为 element |
| void clear() | 清空 |
| boolean contains(Object o) | 判断 o 是否在线性表中 |
| int indexOf(Object o) | 返回第一个 o 所在下标 |
| int lastIndexOf(Object o) | 返回最后一个 o 的下标 |
| List |
截取部分 list |
List是一个接口，是不能够直接进行实例化的，使用List接口，需要去实例化List接口的具体实现类，这里有ArrayList和LinkedList。
二.ArrayList与顺序表
1.顺序表
线性表分为顺序表及链表，顺序表上存储的数据元素在内存单元是连续分布的，因此顺序表既逻辑连续也物理连续。一般情况下采用数组存储。在数组上完成数据的增删查改。
2.模拟实现一个顺序表
我们可以用数组实现一个顺序表，在数组的基础上实现增删改查。
这里我们实现的顺序表可以自动扩容，每次以原数组大小的两倍进行扩容。
import java.util.Arrays;
public class MyArraylist {
public int[] elem;
public int usedSize;//使用大小
private static final int DEFAULT_SIZE = 5;
public MyArraylist() {
this.elem = new int[DEFAULT_SIZE];
}
/**
* 打印顺序表:
* 根据usedSize判断即可
*/
public void display() {
for (int i = 0; i < usedSize; i++) {
System.out.print(elem[i] + " ");
}
}
// 新增元素,默认在数组最后新增
public void add(int data) {
if (isFull()) resize();
elem[usedSize] = data;
usedSize++;
}
//2倍扩容
public void resize() {
elem = Arrays.copyOf(elem, 2 * elem.length);
}
/**
* 判断当前的顺序表是不是满的！
*
* @return true:满 false代表空
*/
public boolean isFull() {
return usedSize == elem.length;
}
private boolean checkPosInAdd(int pos) {
if (pos<0 || pos > usedSize) return false;
return true;//合法
}
// 在 pos 位置新增元素
public void add(int pos, int data) {
if (checkPosInAdd(pos)) {
if (isFull()) resize();
for(int i=usedSize;i>pos;i--){
elem[i]=elem[i-1];
}
elem[pos]=data;
usedSize++;
}
}
// 判定是否包含某个元素
public boolean contains(int toFind) {
for (int i = 0; i < usedSize; i++) {
if (elem[i] == toFind) return true;
}
return false;
}
// 查找某个元素对应的位置
public int indexOf(int toFind) {
for (int i = 0; i < usedSize; i++) {
if (elem[i] == toFind) return i;
}
return -1;
}
// 获取 pos 位置的元素
public int get(int pos) {
if (pos < usedSize) return elem[pos];
return -1;
}
private boolean isEmpty() {
return usedSize == 0;
}
// 给 pos 位置的元素设为【更新为】 value
public void set(int pos, int value) {
if (pos < usedSize) {
elem[pos] = value;
}
}
/**
* 删除第一次出现的关键字key
*
* @param key
*/
public void remove(int key) {
if(isEmpty()) return;
for (int i = 0; i < usedSize; i++) {
if (elem[i] == key) {
while (i + 1 < usedSize) {
elem[i] = elem[i + 1];
i++;
}
usedSize--;
break;
}
}
}
// 获取顺序表长度
public int size() {
return usedSize;
}
// 清空顺序表
public void clear() {
usedSize = 0;
elem = null;
}
}3.ArrayList
在Java集合框架中，ArrayList是一个普通的类，实现了List接口，我们可以直接通过实例化ArrayList来实现一个顺序表，
Arrlist的构造：
ArrayList() //无参构造
ArrayList(Collection c) //利用其他 Collection 构建 ArrayList
ArrayList(int initialCapacity) //指定顺序表初始容量ArrayLisy的常用方法和上述List常用方法一致。
4.ArrayList的遍历与扩容
ArrayList的遍历可以通过For+下标，foreach和迭代器实现：
//使用下标+for遍历
for (int i = 0; i < list.size(); i++) {
System.out.print(list.get(i) + " ");
}
System.out.println();
//使用foreach遍历
for (Integer integer : list) {
System.out.print(integer + " ");
}
System.out.println();
//使用迭代器遍历
Iterator it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next() + " ");
} ArrayList是一个动态类型的顺序表，在插入元素的过程中会自动扩容，
ArrayList的扩容机制如下：
1. 检测是否真正需要扩容，如果是调用grow准备扩容
2. 预估需要库容的大小
初步预估按照1.5倍大小扩容
如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
3. 使用copyOf进行扩容
二.LinkedList与链表
1.ArrayList的缺陷
ArrayList的底层是一个数组，其在内存单元是连续储存的，所以当我们想插入或删除一个顺序表中的元素时，需要将数组进行前后挪移，该操作的时间复杂度为O(n)；所以，当涉及插入和删除较多的操作时，就不适合使用ArrayList了，但是Java提供了另一数据结构LinkedList即链表。
2.链表
链表在物理存储结构上是非连续存的构，数据元素之间逻辑顺序是通过链表中的引用链接次序实现。
链表种类较多，存在带头与不带头链表，单向与双向链表，循环与非循环链表。
3.无头单向链表的模拟实现
class SingleLinkedList {
public int val;
public SingleLinkedList next;
public SingleLinkedList head;
public int usersize;
SingleLinkedList(int data) {
this.val=data;
}
SingleLinkedList() {
}
//头部插入
public void addFirst(int data){
SingleLinkedList Node=new SingleLinkedList(data);
Node.next=head;
head=Node;
usersize++;
}
//尾插插入
public void addLast(int data){
if(this.head==null){
addFirst(data);
return;
}
SingleLinkedList cur=head;
while(cur.next!=null){
cur=cur.next;
}
SingleLinkedList Node=new SingleLinkedList(data);
cur.next=Node;
usersize++;
}
//指定位置插入
public boolean addIndex(int index,int data){
if(index>usersize || index<0) return false;
if(index==usersize) {
addLast(data);
return true;
}
if(index==0) {
addFirst(data);
return true;
}
SingleLinkedList cur=head;
SingleLinkedList prev = null;
while(index>0){
prev=cur;
cur=cur.next;
index--;
}
SingleLinkedList Node=new SingleLinkedList(data);
prev.next=Node;
Node.next=cur;
usersize++;
return true;
}
//查找是否包含关键字key是否在单链表当中public boolean contains(int key){
SingleLinkedList cur=head;
while(cur!=null){
if(cur.val==key) return true;
cur=cur.next;
}
return false;
}
//删除第一次出现关键字为key的节点public void remove(int key){
SingleLinkedList cur=head;
SingleLinkedList prev=null;
while(cur!=null){
if(cur.val==key) {
if(prev==null){
this.head=head.next;
usersize--;
return;
}else{
prev.next=cur.next;
usersize--;
return;
}
}
prev=cur;
cur=cur.next;
}
}
//删除全部关键字为key的节点
public void removeAllKey(int key){
SingleLinkedList cur=head;
SingleLinkedList prev=head;
while(cur!=null){
if(cur.val==key) {
if(prev==this.head){
this.head=head.next;
}else{
prev.next=cur.next;
}
usersize--;
prev=cur.next;
cur=cur.next;
continue;
}
prev=cur;
cur=cur.next;
}
}
//得到单链表的长度
public int size(){
return usersize;
}
public void display(){
SingleLinkedList cur=head;
while(cur!=null){
System.out.println(cur.val+" ");
cur=cur.next;
}
}
public void clear(){
this.head.next=null;
this.head=null;
}
}4.LinkedList
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。用LinkeList可以实现链表，也可以实现栈，双端队列。
5.LinkedList的构造与遍历
LinkedList() //无参构造
public LinkedList(Collection c)
//使用其他集合容器中元素构造ListLinkedList是双向链表，所以可以进行正反两头遍历。
// foreach遍历
for (int e:list) {
System.out.print(e + " ");
}
System.out.println();
// 使用迭代器遍历---正向遍历
ListIterator it = list.listIterator();
while(it.hasNext()){
System.out.print(it.next()+ " ");
}
System.out.println();
// 使用反向迭代器---反向遍历
ListIterator rit = list.listIterator(list.size());
while (rit.hasPrevious()){
System.out.print(rit.previous() +" ");
} 6.ArrayList与LinkedList区别
| 存储空间上 | 物理上一定连续 | 逻辑上连续，但物理上不一定连续 |
| 随机访问 | 支持O(1) | 不支持：O(N) |
| 头插 | 需要搬移元素，效率低O(N) | 只需修改引用的指向，时间复杂度为O(1) |
| 插入 | 空间不够时需要扩容 | 没有容量的概念 |
| 应用场景 | 元素高效存储+频繁访问 | 任意位置插入和删除频繁 |