目录
1.概述
线性表,全名为线性存储结构。使用线性表存储数据的方式可以这样理解,即“把所有数据按照顺序(线性)的存储结构方式,存储在物理空间”。
线性存储结构
顺序存储结构:数据依次存储在连续的物理空间中(顺序表);
链式存储结构:数据分散存储在不连续物理空间中,通过某种指向关系,来维持它们之间的逻辑关系(链表)。
2.顺序表(数组)
2.1 概述
顺序表,全名顺序存储结构,是线性表的一种。顺序表对数据的物理存储结构有明确的要求:顺序表存储数据时,会提前申请一整块足够大小的内存,然后将数据依次存储起来,元素的存储空间在内存中是连续存在的。
2.2优缺点
优点:
- 内存地址连续,遍历数组元素速度快。
- 根据下标,查找指定位置元素时,速度快。
缺点:
- 长度固定,使用前要预估长度。
- 插入删除元素时,时间复杂度较高。
2.3时间复杂度
数组长度为n。
- 访问特定位置元素,时间复杂度为O(1)。
- 插入元素时间复杂度为O(n):插入元素时最坏情况,新元素插入到数组的头部,需要移动n个元素。
- 删除元素时间复杂度为O(n):删除元素时最坏情况,删除数组的头部元素,需要移动n-1个元素。
3.链表
3.1概述
链表,全名链式存储结构,也是线性表的一种。与顺序表不同,链表不限制数据的物理存储位置,使用链表存储的数据元素,其物理存储位置是随机的。由于链表节点之间根本无法体现出各数据之间的逻辑关系。对此,链表的解决方案是:每个数据元素在存储时都配备一个指针,用于指向自己的直接后继元素。
链表每个数据存储由两部分组成:
数据域:数据元素本身。
指针域:指向直接后继元素的指针。
在链表中,实际存储的是一个一个的节点,真正的数据元素包含在这些节点中,所以链表是一种在物理上非连续的数据结构,由若干个节点(Node)组成的一种线性存储结构。
3.2优缺点
优点:
- 不需要提前预估长度,可以克服数组需要预先知道数据长度的缺点。
- 不需要连续的内存空间,可以充分利用计算机内存空间,实现灵活的内存动态管理。
缺点:
- 链表相比于数组会占用更多的空间,因为链表中每个节点中,除了存放元素本身,还有存放指向其他节点的指针。
- 不能随机读取元素(RandomAccess)。
- 遍历和查找元素的速度比较。
3.3时间复杂度
- 链表的插入和删除操作的复杂度为 O(1):只需要知道目标位置元素的上一个元素即可。
- 查找一个节点或者访问特定位置的节点的时候复杂度为 O(n) : 最坏情况下需要遍历链表。
3.4链表分类
3.4.1单向链表
单向链表的每一个节点Node中包含1个数据域和1个指针域。数据域是存放数据的变量data,指针域是指向下一个节点的指针next,所以单向链表只有一个方向。
public class Linked1<E> {
private Node<E> first;
private Node<E> last;
//尾插法
public void addLast(E item) {
//创建新节点
final Node<E> newNode=new Node<E>(item);
//保存旧尾节点
final Node<E> l=last;
//新尾节点
last=newNode;
if(l==null) {
first=newNode;
}else{
//旧尾节点的后继节点
l.next=newNode;
}
}
//头插法
public void addFirst(E item) {
final Node<E> newNode=new Node<E>(item);
//保存旧头节点
final Node<E> f=first;
//新头节点
first=newNode;
if(f==null) {
last=newNode;
}else {
//新头节点后继节点
first.next=f;
}
}
@Override
public String toString() {
StringJoiner sj=new StringJoiner("->");
for(Node<E> n=first;n!=null;n=n.next) {
sj.add(n.item.toString());
}
return sj.toString();
}
/*
* 单向链表的节点
*/
static class Node<E>{
E item; // 数据域
Node<E> next; // 后继节点(指针域)
public Node(E data) {
this.item = data;
}
}
}
public static void main(String[] args) {
Linked1<String> link=new Linked1<String>();
link.addFirst("A");
link.addFirst("B");
link.addFirst("C");
System.out.println(link);
link.addLast("a");
link.addLast("b");
link.addLast("c");
System.out.println(link);
}
3.4.2双向链表
双向链表 的每个节点Node中包含2个指针域和1个数据域,指针域next指向后一个节点, prev 指向前一个节点,数据域item用于存储数据。
双向链表节点内部类:
public static class Node<E>{
Node<E> prev;
E item;
Node<E> next;
Node(Node<E> prev,E element,Node<E> next){
this.prev=prev;
this.item=element;
this.next=next;
}
}
3.4.2.1 双向链表-按照指定下标查找节点
如果指定下标小于size>>1长度一半,则从头部节点开始顺序遍历查找
如果指定下标大于size>>1长度一半,则从尾部节点开始逆序遍历查找
// 根据"下标(位置)"查找节点
public Node<E> node(int index) {
// 判断下标(位置)在整个链表的"上半区"或"下半区"
if (index < (size >> 1)) {
// 从头节点开始查找
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
// 从尾节点开始查找
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
3.4.2.2 双向链表-添加节点
头插法:
//头插法
public void addFirst(E item) {
//获取原头节点
final Node<E> f=first;
//创建新节点
final Node<E> newNode=new Node<E>(null, item, f);
//将新节点设置为头节点
first=newNode;
//如果原头节点为null
if(f==null) {
//代表原链表没有节点,新节点也是尾节点
last=newNode;
}else{
//设置原头节点的前驱节点为新节点
f.prev=newNode;
}
//链表长度自增
size++;
}
尾插法:
//尾插法
public void addLast(E item) {
final Node<E> l=last;
final Node<E> newNode=new Node<E>(l,item,null);
last=newNode;
if(l==null) {
first=newNode;
}else {
//原尾节点的后继结点为新节点
l.next=newNode;
}
size++;
}
3.4.2.3双向链表-删除节点
删除头节点:
//删除头节点
public void removeFirst() {
//获取原头节点
final Node<E> f=first;
//获取原头节点的后继节点
final Node<E> next=f.next;
//将原头节点的item和next设置为null
f.item=null;
f.next=null;
//设置原头节点的后继结点为头节点
first=next;
//如果next为null,设置尾节点为null,否则设置后继节点的前驱为null
if(next==null) {
last=null;
}else {
next.prev=null;
}
//链表长度自减
size--;
}
删除尾节点:
//删除尾节点
public void removeLast() {
final Node<E> l=last;
final Node<E> prev=l.prev;
l.item=null;
l.prev=null;
last=prev;
if(prev==null) {
first=null;
}else {
prev.next=null;
}
}
全部代码:
public class Linked2<E> {
private Node<E> first;
private Node<E> last;
private int size;
//头插法
public void addFirst(E item) {
//获取原头节点
final Node<E> f=first;
//创建新节点
final Node<E> newNode=new Node<E>(null, item, f);
//将新节点设置为头节点
first=newNode;
//如果原头节点为null
if(f==null) {
//将新节点设置为尾节点
last=newNode;
}else{
//设置原头节点的前驱节点为新节点
f.prev=newNode;
}
//链表长度自增
size++;
}
//尾插法
public void addLast(E item) {
final Node<E> l=last;
final Node<E> newNode=new Node<E>(l,item,null);
last=newNode;
if(l==null) {
first=newNode;
}else {
//原尾节点的后继结点为新节点
l.next=newNode;
}
size++;
}
//删除头节点
public void removeFirst() {
//获取原头节点
final Node<E> f=first;
//获取原头节点的后继节点
final Node<E> next=f.next;
//将原头节点的item和next设置为null
f.item=null;
f.next=null;
//设置原头节点的后继结点为头节点
first=next;
//如果next为null,设置尾节点为null,否则设置后继节点的前驱为null
if(next==null) {
last=null;
}else {
next.prev=null;
}
//链表长度自减
size--;
}
//删除尾节点
public void removeLast() {
final Node<E> l=last;
final Node<E> prev=l.prev;
l.item=null;
l.prev=null;
last=prev;
if(prev==null) {
first=null;
}else {
prev.next=null;
}
}
@Override
public String toString() {
StringJoiner sj=new StringJoiner("<->");
for(Node<E> n=first;n!=null;n=n.next) {
sj.add(n.item.toString());
}
return sj.toString();
}
//从头部开始遍历
public String toStringFromFirst() {
StringJoiner sj=new StringJoiner("->");
for(Node<E> n=first;n!=null;n=n.next) {
sj.add(n.item.toString());
}
return sj.toString();
}
//从尾部开始遍历
public String toStringFromLast() {
StringJoiner sj=new StringJoiner("<-");
for(Node<E> n=last;n!=null;n=n.prev) {
sj.add(n.item.toString());
}
return sj.toString();
}
public static class Node<E>{
Node<E> prev;
E item;
Node<E> next;
Node(Node<E> prev,E element,Node<E> next){
this.prev=prev;
this.item=element;
this.next=next;
}
}
}
public class Test02 {
public static void main(String[] args) {
Linked2<String> link=new Linked2<String>();
link.addFirst("A");
link.addFirst("B");
link.addFirst("C");
// System.out.println(link.toStringFromFirst());
// System.out.println(link.toStringFromLast());
link.addLast("a");
link.addLast("b");
link.addLast("c");
System.out.println(link);
link.removeFirst();
link.removeLast();
System.out.println(link);
}
}
3.4.3循环链表
循环链表 其实是一种特殊的单链表,和单链表不同的是循环链表的尾结点不是指向 null,而是指向链表的头结点。
3.4.4双向循环链表
双向循环链表 最后一个节点的 next 指向 head,而 head 的 prev 指向最后一个节点,构成一个环。