本文旨在加深学习印象并留记录以供日后查看。学习视频为韩顺平图解Java数据结构和算法，以下内容来自于视频内容与自我总结。如有错误请您指正。
单链表
维基百科：链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。
链表是有序的列表，它在内存中的存储如下图所示
- 链表是以节点的方式来存储,是链式存储
- 每个节点包含 data 域， next 域指向下一个节点
- 链表的各个节点不一定是连续存储
单链表(带头结点) 逻辑结构示意图如下
下面根据一个例子来分析，创建一个带头的单向链表来管理英雄，主要是新增、修改、删除
问题分析与代码实现
- 建立一个HeroNode的class来存放hero的数据信息，同时每个HeroNode都是一个节点
//每个HeroNode都是一个节点
class HeroNode {
public int no;
public String name;
public String nickName;
public HeroNode next;//指向下个节点
//构造器，初始化数据
public HeroNode(int no,String name,String nickName){
this.no = no;
this.name = name;
this.nickName = nickName;
}
//重写toString方法来输出英雄信息
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickName='" + nickName + '\'' +
'}';
}
}
- 创建链表来管理所有的节点
class SingleLinkedList {
//初始化头结点，不存放具体数据
private HeroNode head = new HeroNode(0,"","");
...
}
- 添加节点
添加节点有两种方式，第一种是直接添加到链表尾部（无序），第二种是根据排名（序号）来将添加到指定位置（有序）
(1) 直接添加到链表尾部（无序）
思路分析：
①先创建一个head 头节点， 作用就是表示单链表的头
②后面我们每添加一个节点，就直接加入到 链表的最后
代码实现：
/**
* 向链表中添加节点（不考虑编号顺序）
* 思路：1、找到链表的最后节点；2、把最后节点的next指向新节点
* 注：此添加方法是无序的，将新的节点添加到后面
* @param newNode
*/
public void add(HeroNode newNode){
//1、找到链表最后节点 遍历
HeroNode temp = this.head;//定义一个temp指向头结点
//遍历
while (true){
//如果temp的next为null,则temp为最后一个节点，然后跳出循环
if (temp.next == null){
break;
}
//如果temp的next不为null，把temp指向他的下一个节点并继续遍历
temp = temp.next;
}
//遍历到最后一个节点时，把temp的next指向新的节点，这样就把新的节点添加到链表中了
temp.next = newNode;
}
(1) 根据排名（序号）来将添加到指定位置（有序）
思路分析：
①首先通过遍历来找到新添加的节点的位置
②新的节点.next = temp.next
③将temp.next = 新的节点
代码实现：
/**
* 向链表中添加节点，有序
* 根据编号的顺序添加，如果要添加的节点已有则添加失败并提示
* @param newNode
*/
public void addByOrder(HeroNode newNode){
//定义一个temp指向头结点
HeroNode temp = this.head;
//定义一个标识来判断newNode是否已存在
boolean flag = false;
while (true){
//下个节点为空表示当前节点为最后一个节点
if (temp.next == null){
break;
}
//当前节点的下个节点的no>新节点的no，表示找到位置，新节点应该插入到这里
if (temp.next.no > newNode.no){
break;
} else if (temp.next.no == newNode.no){
//当下一个节点的no和新的节点的no相等时，认为已存在
flag = true;
}
temp = temp.next;
}
if (flag){
System.out.println(newNode.no+"已存在");
return;
}
//将结点插入
//让newNode的下一个节点等于原本temp的下一个节点
//让原本temp的下一个节点等于newNode
newNode.next = temp.next;
temp.next = newNode;
}
- 修改节点
思路分析：
①首先通过遍历找到要修改的节点，找不到则要修改的节点不存在
②temp.name = newNode.name;
③temp.nickName = newNode.nickName;
代码实现：
/**
* 修改节点
* 根据传入节点的no来对链表中现有的节点信息进行修改
* no作为标识不能修改，如果no修改了应视为添加
* @param newNode
*/
public void update(HeroNode newNode){
//如果链表为空，不需要修改，直接返回结束
if (head.next == null){
System.out.println("链表为空");
return;
}
//根据no寻找该节点
HeroNode temp = this.head;
boolean flag = false;//设置一个标识标识是否找到
while (true){
//当temp为null时，表示链表已经遍历完毕，没有找到对应节点
if (temp == null){
break;
}
//相等时说明找到了要修改的节点
if (temp.no == newNode.no){
flag = true;
break;
}
//后移
temp = temp.next;
}
if (flag){
temp.name = newNode.name;
temp.nickName = newNode.nickName;
} else {
System.out.println("未找到no为"+newNode.no+"的节点");
}
}
- 删除节点
思路分析：
①找到需要删除的这个节点的前一个节点 temp
②temp.next = temp.next.next;
③被删除的节点，将不会有其它引用指向，会被垃圾回收机制回收
代码实现：
/**
* 删除节点
* @param no
*/
public void delete(int no){
HeroNode temp = this.head;
boolean flag = false;//是否找到
while (true){
//已经到链表的最后
if (temp.next == null){
break;
}
//找到要删除的节点（当前temp指向的下一个节点为要删除的节点）
if (temp.next.no == no){
flag = true;
break;
}
//后移
temp = temp.next;
}
if (flag){
temp.next = temp.next.next;
} else {
System.out.println("要删除的节点不存在");
}
}
完整代码及测试结果
package com.hyf.linkedlist;
public class SingleLinkedListDemo {
public static void main(String[] args) {
//测试
//创建节点
HeroNode node1 = new HeroNode(1, "a", "aaa");
HeroNode node2 = new HeroNode(2, "b", "bbb");
HeroNode node3 = new HeroNode(3, "c", "ccc");
HeroNode node4 = new HeroNode(4, "d", "ddd");
HeroNode node5 = new HeroNode(5, "e", "eee");
//创建链表
SingleLinkedList linkedList = new SingleLinkedList();
//添加节点 无序，添加到链表尾部
linkedList.add(node3);
linkedList.add(node1);
linkedList.add(node5);
linkedList.add(node2);
linkedList.add(node4);
//打印列表
linkedList.list();
System.out.println("----------------------");
//创建链表
SingleLinkedList linkedList1 = new SingleLinkedList();
//添加节点 有序
linkedList1.addByOrder(node1);
linkedList1.addByOrder(node3);
linkedList1.addByOrder(node5);
linkedList1.addByOrder(node5);
linkedList1.addByOrder(node4);
linkedList1.addByOrder(node2);
//打印列表
linkedList1.list();
System.out.println("====================");
//修改节点数据
HeroNode node22 = new HeroNode(2, "b2", "bbb2");
linkedList1.update(node22);
linkedList1.list();
HeroNode node222 = new HeroNode(22, "b22", "bbb22");
linkedList1.update(node222);
System.out.println("----------------------");
//删除节点
linkedList1.delete(1);
linkedList1.delete(2);
// linkedList1.delete(3);
// linkedList1.delete(4);
linkedList1.delete(5);
linkedList1.list();
linkedList1.delete(5);
}
}
//定义链表
class SingleLinkedList {
//初始化头结点，不存放具体数据
private HeroNode head = new HeroNode(0,"","");
/**
* 向链表中添加节点（不考虑编号顺序）
* 思路：1、找到链表的最后节点；2、把最后节点的next指向新节点
* 注：此添加方法是无序的，将新的节点添加到后面
* @param newNode
*/
public void add(HeroNode newNode){
//1、找到链表最后节点 遍历
HeroNode temp = this.head;//定义一个temp指向头结点
//遍历
while (true){
//如果temp的next为null,则temp为最后一个节点，然后跳出循环
if (temp.next == null){
break;
}
//如果temp的next不为null，把temp指向他的下一个节点并继续遍历
temp = temp.next;
}
//遍历到最后一个节点时，把temp的next指向新的节点，这样就把新的节点添加到链表中了
temp.next = newNode;
}
/**
* 向链表中添加节点，有序
* 根据编号的顺序添加，如果要添加的节点已有则添加失败并提示
* @param newNode
*/
public void addByOrder(HeroNode newNode){
//定义一个temp指向头结点
HeroNode temp = this.head;
//定义一个标识来判断newNode是否已存在
boolean flag = false;
while (true){
//下个节点为空表示当前节点为最后一个节点
if (temp.next == null){
break;
}
//当前节点的下个节点的no>新节点的no，表示找到位置，新节点应该插入到这里
if (temp.next.no > newNode.no){
break;
} else if (temp.next.no == newNode.no){
//当下一个节点的no和新的节点的no相等时，认为已存在
flag = true;
}
temp = temp.next;
}
if (flag){
System.out.println(newNode.no+"已存在");
return;
}
//将结点插入
//让newNode的下一个节点等于原本temp的下一个节点
//让原本temp的下一个节点等于newNode
newNode.next = temp.next;
temp.next = newNode;
}
/**
* 修改节点
* 根据传入节点的no来对链表中现有的节点信息进行修改
* no作为标识不能修改，如果no修改了应视为添加
* @param newNode
*/
public void update(HeroNode newNode){
//如果链表为空，不需要修改，直接返回结束
if (head.next == null){
System.out.println("链表为空");
return;
}
//根据no寻找该节点
HeroNode temp = this.head;
boolean flag = false;//设置一个标识标识是否找到
while (true){
//当temp为null时，表示链表已经遍历完毕，没有找到对应节点
if (temp == null){
break;
}
//相等时说明找到了要修改的节点
if (temp.no == newNode.no){
flag = true;
break;
}
//后移
temp = temp.next;
}
if (flag){
temp.name = newNode.name;
temp.nickName = newNode.nickName;
} else {
System.out.println("未找到no为"+newNode.no+"的节点");
}
}
/**
* 删除节点
* @param no
*/
public void delete(int no){
HeroNode temp = this.head;
boolean flag = false;//是否找到
while (true){
//已经到链表的最后
if (temp.next == null){
break;
}
//找到要删除的节点（当前temp指向的下一个节点为要删除的节点）
if (temp.next.no == no){
flag = true;
break;
}
//后移
temp = temp.next;
}
if (flag){
temp.next = temp.next.next;
} else {
System.out.println("要删除的节点不存在");
}
}
/**
* 显示链表
*/
public void list(){
//当head的next为null时，代表链表为空
if (this.head.next == null){
System.out.println("链表为空");
return;
}
//不为空时，遍历显示
HeroNode temp = this.head.next;
while (true){
if (temp == null){
break;
}
System.out.println(temp.toString());
//temp指向后移
temp = temp.next;
}
}
}
//每个HeroNode都是一个节点
class HeroNode {
public int no;
public String name;
public String nickName;
public HeroNode next;//指向下个节点
//构造器，初始化数据
public HeroNode(int no,String name,String nickName){
this.no = no;
this.name = name;
this.nickName = nickName;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickName='" + nickName + '\'' +
'}';
}
}
测试结果
单链表缺点
- 单链表的查找方向只能是一个方向
- 单链表不能自我删除，需要借助辅助节点
优化方案
双向链表
扫一扫
2239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
