🍉概述
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
🍉单链表
🍊简介
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
🍋存储示意图
可以看出，链表的地址空间可以不是连续的，各个结点之间用指针连接起来形成链表
🍌单链表的基本实现（类设计）
类名：
- LinkList<T>：可以根据自己的喜好自定义，T是泛型，限制存入的元素类型，假设创建对象时，设置LinkList<String>，表示该顺序表只能存放String类型的元素
结点类：
- private class Node ：结点，方便将各个结点连接成链表
private class Node{
// 存储数据
T item;
// 下一个结点
Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
public Node() {};
}
成员变量：
- 头结点：private Node head;
- 链表长度：private int N;
构造方法：
- public LinkList()：初始化头结点指向null，初始化长度为0
public LinkList(){
// 初始化头结点
this.head = new Node();
// 初始化元素个数
this.N = 0;
}
成员方法：
- public void clear()：清空链表（直接让头结点指向null，长度重置为0）
public void clear() {
this.head = null;
this.N = 0;
}
- public int length()：获取链表长度（返回N即可）
public int length() {
return N;
}
- public boolean isEmpty()：链表是否为空（判断N是否为0即可）
public boolean isEmpty() {
return N == 0;
}
- public T get(int i)：获取指定位置的元素（用一个临时结点指向头结点，不断的让临时结点指向它的下一个结点）
public T get(int i) {
// 通过循环，从头结点开始往后查找
Node node = head;
for (int j = 0; j <= i; j++) {
node = node.next;
}
return node.item;
}
- public void insert(T t)：向链表添加元素
public void insert(T t) {
//找到当前最后一个结点
Node last = head;
while(last.next!=null)
last = last.next;
//创建新结点，保存元素t
Node now = new Node(t,null);
//让当前最后一个结点指向新结点
last.next = now;
// 让元素个数加一
this.N++;
}
- public void insert(int i, T t)：指定位置插入元素（找到前一个结点和 i 位置结点，前一个结点指向新结点，新节点指向 i 位置结点完成插入）
public void insert(int i, T t) {
Node pre = head;
//找到i位置的前一个结点
for (int j = 0; j < i; j++) {
pre = pre.next;
}
//找到i位置的结点
Node cur = pre.next;
//创建新结点，前一结点指向新结点，新结点指向原来i位置的结点
Node now = new Node(t, cur);
pre.next = now;
//元素个数加一
this.N++;
}
- public T remove(int i)：删除指定位置元素（找到 i 位置前一个和后一个结点，直接让前一个指向后一个结点）
public T remove(int i) {
//找到i位置前一个结点
Node pre = head;
for (int j = 0; j < i; j++) {
head = head.next;
}
//找到i位置的结点并保存
Node cur = pre.next;
//找到i位置下一个结点
Node next = cur.next;
//前一个结点指向下一个结点
pre.next = next;
//元素个数减一
this.N--;
return cur.item;
}
- public int indexOf(T t)：查找指定元素第一次出现的位置
public int indexOf(T t) {
// 从头开始依次查找每一个结点，取出item，和t比较，如果相同则找到了
Node now = head;
for (int i = 0; now.next!= null; i++) {
now = now.next;
if (now.item==t) {
return i;
}
}//找不到就返回-1
return -1;
}
完整代码：
public class LinkList<T> {
// 记录头结点
private Node head;
// 记录链表的长度
private int N;
// 结点类
private class Node{
// 存储数据
T item;
// 下一个结点
Node next;
public Node(T item, Node next) {
this.item = item;
this.next = next;
}
public Node() {};
}
public LinkList(){
// 初始化头结点
this.head = new Node();
// 初始化元素个数
this.N = 0;
}
// 清空链表
public void clear() {
this.head = null;
this.N = 0;
}
// 获取链表的长度
public int length() {
return N;
}
//判断链表是否为空
public boolean isEmpty() {
return N == 0;
}
//获取指定位置i处的元素
public T get(int i) {
// 通过循环，从头结点开始往后查找
Node node = head;
for (int j = 0; j <= i; j++) {
node = node.next;
}
return node.item;
}
//向链表中添加元素t
public void insert(T t) {
//找到当前最后一个结点
Node last = head;
while(last.next!=null)
last = last.next;
//创建新结点，保存元素t
Node now = new Node(t,null);
//让当前最后一个结点指向新结点
last.next = now;
// 让元素个数加一
this.N++;
}
//向指定位置i处添加元素t
public void insert(int i, T t) {
Node pre = head;
//找到i位置的前一个结点
for (int j = 0; j < i; j++) {
pre = pre.next;
}
//找到i位置的结点
Node cur = pre.next;
//创建新结点，前一结点指向新结点，新结点指向原来i位置的结点
Node now = new Node(t, cur);
pre.next = now;
//元素个数加一
this.N++;
}
//删除指定位置i的元素，返回被删除的元素
public T remove(int i) {
//找到i位置前一个结点
Node pre = head;
for (int j = 0; j < i; j++) {
head = head.next;
}
//找到i位置的结点并保存
Node cur = pre.next;
//找到i位置下一个结点
Node next = cur.next;
//前一个结点指向下一个结点
pre.next = next;
//元素个数减一
this.N--;
return cur.item;
}
//查找元素i在链表中第一次出现的位置
public int indexOf(T t) {
// 从头开始依次查找每一个结点，取出item，和t比较，如果相同则找到了
Node now = head;
for (int i = 0; now.next!= null; i++) {
now = now.next;
if (now.item==t) {
return i;
}
}
return -1;
}
}
简单测试代码：
public class LinkListTest {
public static void main(String[] args) {
// 创建单向链表对象
LinkList<String> s1 = new LinkList<>();
// 测试插入
s1.insert("姚明");
s1.insert("科比");
s1.insert("麦迪");
s1.insert(1,"詹姆斯");
for (int i = 0; i < s1.length(); i++) {
System.out.println(s1.get(i));
}
System.out.println("-----------------------------");
// 测试获取
String getres = s1.get(1);
System.out.println("获取索引1处的结果为：" + getres);
// 测试删除
String removeRes = s1.remove(0);
System.out.println("删除的元素为："+removeRes+"\t删除后长度为："+s1.length());
//测试返回元素第一次出现的索引
System.out.println("麦迪第一次出现的索引为："+s1.indexOf("麦迪"));
// 测试清空
s1.clear();
System.out.println("清空后链表中元素的个数为："+s1.length());
}
}
🍉双链表
🍊简介
双链表也叫双向链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
🍋存储示意图
跟单链表一样，双链表的地址空间也是不连续的，各结点之间通过指针连接起来形成链表，不同之处在于多了一个指向前结点的指针，这样前一个结点可以访问后一个结点，后一个结点也可以访问到前一个结点。
🍌双链表的基本实现（类设计）
类名：
- TwoWayLinkList<T>：可以自定义，T是泛型，限制存入的元素类型
结点类：
- private class Node：前后指针和存储元素
private class Node{
public T item;
public Node pre;//前一个结点
public Node next;//后一个结点
public Node(T item, Node pre, Node next) {//构造方法
this.item = item;
this.pre = pre;
this.next = next;
}
}
成员变量：
- 头结点：private Node head;
- 尾结点：private Node last;
- 链表长度：private int N;
构造方法：
- public TwoWayLinkList()：初始化头、尾结点指向null，初始链表长度为0
public TwoWayLinkList() {
//初始化头结点和尾结点
this.head = new Node(null,null,null);
this.last = null;
//初始化元素个数
this.N = 0;
}
成员方法：
- public void clear()：清空链表（头、尾结点置空，链表长度置为0）
public void clear() {
this.head.next = null;
this.last = null;
this.N = 0;
}
- public int length()：获取链表长度
public int length() {
return this.N;
}
- public boolean isEmpty()：判断链表是否为空
public boolean isEmpty() {
return N == 0;
}
- public T getFirst()：获取第一个元素
public T getFirst() {
if (isEmpty()) {
return null;
}
return head.next.item;
}
- public T getLast()：获取最后一个元素
public T getLast() {
if (isEmpty()) {
return null;
}
return last.item;
}
- public void insert(T t)：向链表插入元素
public void insert(T t) {
//如果链表为空
if (isEmpty()) {
//创建新结点，pre指向头结点
Node newNode = new Node(t,head,null);
//让新结点称为尾结点
last = newNode;
//让头结点下一个结点指向尾结点
head.next = last;
}else {//如果不为空
//创建新结点
Node newNode = new Node(t,last,null);
//让当前尾结点指向新结点
last.next = newNode;
//让新结点成为尾结点
last = newNode;
}
//元素个数加一
this.N++;
}
- public void insert(int i, T t)：指定位置插入元素（与单链表）
public void insert(int i, T t) {
//找到i位置的前一个结点
Node pre = head;
for (int j = 0; j < i; j++) {
pre = pre.next;
}
//找到i位置的结点
Node cur = pre.next;
//创建新结点，让其pre指向前一个结点，next指向i位置结点
Node newNode = new Node(t,pre,cur);
//让前一结点的next变为新结点
pre.next = newNode;
//让i位置的pre变为新结点
cur.pre = newNode;
//元素个数加一
this.N++;
}
-
public T get(int i)：获取指定位置元素
-
public int indexOf(T t)：获取指定元素第一次出现的索引
（这两个方法跟单链表的一样，就不写出来了） -
public T remove(int i)：删除指定位置元素并返回
public T remove(int i) {
//找到前一个结点
Node pre = head;
for (int j = 0; j < i; j++) {
pre = pre.next;
}
//找到i位置的下一个结点
Node cur = pre.next;
//找到下一个结点
Node nextNode = cur.next;
//让前一个结点的next指向下一个结点
pre.next = nextNode;
//让下一个结点的pre指向前一个结点
nextNode.pre = pre;
//元素个数减一
this.N--;
return cur.item;
}
完整代码：
public class TwoWayLinkList<T> {
//首结点
private Node head;
//尾结点
private Node last;
//链表长度
private int N;
//结点类
private class Node{
public T item;
public Node pre;
public Node next;
public Node(T item, Node pre, Node next) {
this.item = item;
this.pre = pre;
this.next = next;
}
}
public TwoWayLinkList() {
//初始化头结点和尾结点
this.head = new Node(null,null,null);
this.last = null;
//初始化元素个数
this.N = 0;
}
//清空链表
public void clear() {
this.head.next = null;
this.last = null;
this.N = 0;
}
//获取链表长度
public int length() {
return this.N;
}
//判断链表是否为空
public boolean isEmpty() {
return N == 0;
}
//获取第一个元素
public T getFirst() {
if (isEmpty()) {
return null;
}
return head.next.item;
}
//获取最后一个元素
public T getLast() {
if (isEmpty()) {
return null;
}
return last.item;
}
//插入元素t
public void insert(T t) {
//如果链表为空
if (isEmpty()) {
//创建新结点
Node newNode = new Node(t,head,null);
//让新结点称为尾结点
last = newNode;
//让头结点指向尾结点
head.next = last;
}else {//如果不为空
//创建新结点
Node newNode = new Node(t,last,null);
//让当前尾结点指向新结点
last.next = newNode;
//让新结点成为尾结点
last = newNode;
}
//元素个数加一
this.N++;
}
//指定位置插入元素t
public void insert(int i, T t) {
//找到i位置的前一个结点
Node pre = head;
for (int j = 0; j < i; j++) {
pre = pre.next;
}
//找到i位置的结点
Node cur = pre.next;
//创建新结点
Node newNode = new Node(t,pre,cur);
//让前一结点的next变为新结点
pre.next = newNode;
//让i位置的前一结点变为新结点
cur.pre = newNode;
//元素个数加一
this.N++;
}
//获取指定位置的元素
public T get(int i) {
Node now = head.next;
for (int j = 0; j < i; j++) {
now = now.next;
}
return now.item;
}
//找到第一次出现t的位置
public int indexOf(T t) {
Node now = head;
for (int i = 0; now.next != null; i++) {
now = now.next;
if (now.item.equals(t)) {
return i;
}
}
return -1;
}
//删除i处的元素，并返回其元素
public T remove(int i) {
//找到前一个结点
Node pre = head;
for (int j = 0; j < i; j++) {
pre = pre.next;
}
//找到i位置的下一个结点
Node cur = pre.next;
//找到下一个结点
Node nextNode = cur.next;
//让前一个结点的next指向下一个结点
pre.next = nextNode;
//让下一个结点的pre指向前一个结点
nextNode.pre = pre;
//元素个数减一
this.N--;
return cur.item;
}
}
测试可以直接模仿单链表那里的测试。
觉得有帮助的小伙伴可以给博主点个赞👀，你的点赞就是对博主的最大支持😜
3161
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
