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 extends E> 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。
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 extends E> 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进行扩容
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 extends E> c)
//使用其他集合容器中元素构造List
LinkedList是双向链表,所以可以进行正反两头遍历。
// 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) |
插入 | 空间不够时需要扩容 | 没有容量的概念 |
应用场景 | 元素高效存储+频繁访问 | 任意位置插入和删除频繁 |