链表
特点
- 链表是以节点的方式来存储,是链式存储
- 每个节点包含 data 域 和 next 域。next域用来指向下一个节点
- 链表的各个节点不一定是连续存储的
- 链表分带头节点的链表和没有头节点的链表,根据实际的需求来确定
单链表
基本操作
添加(尾部)
-
先创建一个Head头节点,表示单链表的头
后面我们每添加一个节点,就放在链表的最后
遍历 -
通过一个辅助变量,来遍历整个链表
测试
package com.atguigu.linkedlist;
public class SingleLikedListDemo {
public static void main(String[] args){
//先创建节点
HeroNode heroNode1 = new HeroNode(1,"x", "x");
HeroNode heroNode2 = new HeroNode(2,"xx","xx");
HeroNode heroNode3 = new HeroNode(3,"xxx","xxx");
//创建一个链表
SingleLikedlist singleLikedlist = new SingleLikedlist();
singleLikedlist.add(heroNode1);
singleLikedlist.add(heroNode2);
singleLikedlist.add(heroNode3);
singleLikedlist.showList();
}
}
单链表
//定义SingleLinkedlist 管理我们的英雄
class SingleLikedlist{
//先初始化一个头节点
private HeroNode head = new HeroNode(0,"","");
//添加节点到单向节点
//当不考虑编号的顺序时,找到当前链表的最后节点,将最后这个节点测next指向新节点
public void add(HeroNode heroNode){
//因为head节点不能动,因此我们需要一个辅助变量
HeroNode temp = head;
//遍历链表,找到最后
while(true){
if(temp.next == null){
break;
}
//没有到最后
temp = temp.next;
}
//当推出while循环时,temp指向链表最后
//将最后这个节点的next指向新的节点
temp.next = heroNode;//将最后一个节点的next指向新加入的点
}
//显示链表
public void showList(){
//先判断链表是否为空
if(head.next == null){
return;
}
HeroNode temp = head.next;
while(true){
//是否到链表最后
if (temp == null){
break;
}
//输出节点信息;
System.out.println(temp);
temp = temp.next;//后移节点
}
}
}
结点
//定义一个HeroNode,每一个HroeNode就是一个节点
class HeroNode{
//定义节点的私有属性 编号,姓名 外号 和next
public int no;
public String name;
public String nickname;
public HeroNode next;
//构造器
public HeroNode() {
}
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
//重写toString 方便显示
public String toString(){
return "Heronode [no= "+no+",name="+name+",nickname="+nickname+"]";
}
}
有序添加(按顺序)
- 先遍历链表,找到应该插入的位置
- 要插入的节点的next指向插入位置的后一个节点
- 插入位置的前一个节点的next指向要插入节点
- 插入前要判断是否在队尾插入
单链表的成员方法
//按顺序添加
public void addOder(HeroNode heroNode){
//因为head节点不能动,因此我们需要一个辅助变量,找到添加的位置
//找的temp是添加位置的前一个节点
HeroNode temp = head;
boolean flag = false;//添加的编号是否存在
while (true){
if (temp.next == null){//说明temp已经在链表的最后
break;
}
if (temp.next.no >heroNode.no){///位置找到了,在temp后面添加
break;
}
else if (temp.next.no == heroNode.no){//编号已经存在
flag = true;
break;
}
temp = temp.next;//后移继续寻找
}
//判断flag值
if (flag){
System.out.println("编号已经存在" + heroNode.no);
}else {//可以插入到temp的后面
heroNode.next = temp.next;
temp.next = heroNode;
}
}
修改结点
- 先遍历节点,找到修改的位置
- 如果未找到修改节点,则不修改
//修改
//根据no信息来进行修改
public void updata(HeroNode heroNode){
if (head.next == null){
System.out.println("链表为空");
}
//找到需要修改的节点
HeroNode temp = head;
boolean flag = false;
while (true){
if (temp == null){
break;//链表已经遍历结束了
}
if (temp.no == heroNode.no){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.name = heroNode.name;
temp.nickname = heroNode.nickname;
}else {
System.out.println("没有找到这个编号" + heroNode.no);
}
}
删除结点
- 先遍历节点,找到要删除节点的前一个节点(temp)
- temp.next = temp.next.next
- 进行删除操作,被删除的结点不会有其他引用指向,会被垃圾机制回收
//删除
public void deleteNode(int no){
if (head.next == null){
return;
}
boolean flag = false;
HeroNode temp = head;
while (true){
if (temp == null){
break;
}
if (temp.next.no == no){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.next = temp.next.next;
}
}
测试
package com.atguigu.linkedlist;
public class SingleLikedListDemo {
public static void main(String[] args){
//先创建节点
HeroNode heroNode1 = new HeroNode(1,"x", "x");
HeroNode heroNode2 = new HeroNode(2,"xx","xx");
HeroNode heroNode3 = new HeroNode(3,"xxx","xxx");
HeroNode heroNode4 = new HeroNode(4,"xxxx","xxxx");
HeroNode heroNode5 = new HeroNode(5,"xxxxx","xxxxx");
HeroNode newheroNode = new HeroNode(2,"xx1","xx1");
//创建一个链表
SingleLikedlist singleLikedlist = new SingleLikedlist();
//有序添加节点
singleLikedlist.addOder(heroNode1);
singleLikedlist.addOder(heroNode2);
singleLikedlist.addOder(heroNode3);
singleLikedlist.addOder(heroNode5);
singleLikedlist.addOder(heroNode4);
singleLikedlist.showList();
System.out.println("修改后");
singleLikedlist.updata(newheroNode);
//遍历
singleLikedlist.showList();
singleLikedlist.deleteNode(1);
singleLikedlist.deleteNode(5);
System.out.println("删除后");
singleLikedlist.showList();
}
}
求单链表中有效节点的个数
- 遍历,不算头节点,得到length
method如下
public static int Length(ListNode head){
ListNode temp = head.next;
int count = 0;
if (head.next == null){
return 0;
}
while (true){
if (temp == null){
break;
}
temp = temp.next;
count++;
}
//System.out.println("链表的总长度:" + count);
return count;
}
求单链表的倒数第K个节点
- 遍历链表,求出链表的有效长度length(不算头结点)
- 遍历链表到第length-n的节点
method如下
public static ListNode findNode(ListNode head,int index){
///得到总长度
int l = Length(head);
int goal = l - index;
ListNode temp = head;
if (index <= 0 || index > l){
System.out.println("输入错误");
}
if (head.next == null){
return null;
}
for (int i =0; i <= goal;i++){
if (temp == null){
System.out.println("已经遍历结束,没有想要的节点");
break;
}
temp = temp.next;
}
//System.out.println("倒数第"+index+"个节点为" + temp.var);
return temp;
}
反转链表
- 创建一个新的头结点,作为新链表的头
- 从头遍历旧链表,将遍历到的节点插入新链表的头结点之后
- 注意需要用到两个暂存节点
- 一个用来保存正在遍历的节点
- 一个用来保存正在遍历节点的下一个节点
method如下
public static void reverseList(ListNode head){
ListNode reverseNode = new ListNode();
//只有一个节点或者没有节点不需要处理
if (head.next == null || head.next.next == null){
return;
}
ListNode cur = head.next;
ListNode next = null;//表示当前节点的下一个节点
while(cur!=null){
next = cur.next;//暂时保存当前节点的下一个节点
cur.next = reverseNode.next;//将cur下一个节点,指向新的链表的头部
reverseNode.next = cur;
cur = next;
}
head.next = reverseNode.next;
}
打印逆序列表
- 遍历链表,将遍历到的节点入栈
- 遍历完后,进行出栈操作,同时打印出栈元素
使用反转再遍历,会破环原来的结构。
method
public static void reversePrint(ListNode head){
if(head.next == null){
return;
}
//创建一个栈,将各个节点压栈
Stack<ListNode> stack = new Stack<>();
ListNode cur = head.next;
//将链表的所有节点压入栈中
while(cur!=null){
stack.push(cur);
cur = cur.next;
}
//将栈中的节点进行打印
while(stack.size()>0){
System.out.println(stack.pop());
}
}
以上代码最终结构
双向链表
单向链表,查找的方向只能是一个方向,而双向链表可以向前或者向后查找。
单向链表不能自我删除,需要靠辅助节点 ,而双向链表,则可以自我删除,所以前面我们单链表删除时节点,总是找到 temp,temp 是待删除节点的前一个节点
基本操作
节点
class HeroNode2{
//定义节点的私有属性 编号,姓名 外号 和next
public int no;
public String name;
public String nickname;
public HeroNode2 next;//默认为null
public HeroNode2 per;//指向前一个结点,默认为null
//构造器
public HeroNode2() {
}
public HeroNode2(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
//重写toString 方便显示
public String toString(){
return "Heronode [no= "+no+",name="+name+",nickname="+nickname+"]";
}
}
遍历
和单向链表的遍历相同,需要一个辅助节点来保存当前正在遍历的节点
method
//创建一个双向链表的类
class DoubleLinkedList{
//初始化
private HeroNode2 head = new HeroNode2(0,"","");
//返回头节点
public HeroNode2 getHead(){
return head;
}
//遍历双向链表的方法
public void list(){
//判断链表是否为空
if (head.next == null){
return;
}
//头节点不能动,所以要创建辅助节点
HeroNode2 temp = head.next;
while(true){
//判断链表是否到最后
if (temp == null){
break;
}
System.out.println(temp);
temp = temp.next;
}
}
}
添加
双向链表多出了一个frnot,所以在添加时,要让新增节点的front指向链表尾节点
//默认添加到双向链表的结尾
public void add(HeroNode2 heroNode2){
HeroNode2 temp = head;
while (true){
if(temp.next == null){
break;
}
temp = temp.next;
}
//形成一个双向链表
temp.next = heroNode2;
heroNode2.per = temp;
}
修改
和单向链表的修改相同
//修改一个结点的内容
public void updata(HeroNode2 heroNode2) {
if (head.next == null) {
System.out.println("链表为空");
}
//找到需要修改的节点
HeroNode2 temp = head;
boolean flag = false;
while (true) {
if (temp == null) {
break;//链表已经遍历结束了
}
if (temp.no == heroNode2.no) {
flag = true;
break;
}
temp = temp.next;
}
if (flag) {
temp.name = heroNode2.name;
temp.nickname = heroNode2.nickname;
} else {
System.out.println("没有找到这个编号" + heroNode2.no);
}
}
删除
- 使用temp来保存要删除的节点
- temp.pre.next指向temp.next
- temp.next指向temp.pre
//删除
public void del(int no){
//判断当前链表是否为空
if (head.next == null)
{
return;
}
HeroNode2 temp = head.next;
boolean flag = false;
//找到待删除的节点
while(true){
if (temp == null){
break;//已经到了链表的最后
}
if (temp.no == no){//找到待删除节点
flag = true;
break;//说明找到了
}
temp = temp.next;
}
if (flag){
temp.per.next = temp.next;//删除最后一个结点的时候 temp.pre.next == null
if (temp.next != null){
temp.next.per = temp.per; // 防止出现空指针异常
}
}
else {
System.out.println("节点不存在");
}
}
测试
public class DoubleLinkedListDemo {
public static void main(String[] args) {
System.out.println("-----------双向链表的测试----------");
HeroNode2 heroNode1 = new HeroNode2(1,"x", "x");
HeroNode2 heroNode2 = new HeroNode2(2,"xx","xx");
HeroNode2 heroNode3 = new HeroNode2(3,"xxx","xxx");
HeroNode2 heroNode4 = new HeroNode2(4,"xxxx","xxxx");
HeroNode2 heroNode5 = new HeroNode2(5,"xxxxx","xxxxx");
HeroNode2 newheroNode = new HeroNode2(2,"xx1","xx1");
DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
doubleLinkedList.add(heroNode1);
doubleLinkedList.add(heroNode2);
doubleLinkedList.add(heroNode3);
doubleLinkedList.list();
System.out.println("--------修改过后的节点----------");
doubleLinkedList.updata(newheroNode);
doubleLinkedList.list();
doubleLinkedList.del(heroNode2.no);
System.out.println("--------删除后的节点----------");
doubleLinkedList.list();
}
}
结构如下
单向环形链表
单向环形链表的介绍
Josephu(约瑟夫、约瑟夫环) 问题 利用单向环形链表解决
实现代码
package com.atguigu.linkedlist;
public class Joesphu {
public static void main(String[] args) {
CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
circleSingleLinkedList.add(5);
circleSingleLinkedList.show();
System.out.println();
circleSingleLinkedList.count(1,2,5);
}
}
也可先全部连接,最后成环。
//创建一个环形的单向链表
class CircleSingleLinkedList{
//创建一个first节点,当前没有编号;next为空。即无头结点的链表。
private Boy first = new Boy(-1);
public void add(int no){
//做一个数据校验
if(no < 1){
System.out.println("数据输入错误");
return;
}
//创建环形列表
Boy cur = new Boy();
for (int i =1; i < no+1; i++){
//根据编号创建节点
Boy boy = new Boy(i);
if (i == 1){
first = boy;
boy.setNext(first); // 构成环形
cur = first;
}else {
cur.setNext(boy);
boy.setNext(first);
cur = boy;
}
}
}
//遍历当前环形列表
public void show(){
if (first == null){
System.out.println("链表为空");
return;
}
Boy cur =new Boy();
cur = first;
while (true){
System.out.print(cur.getNo()+ " ");
if (cur.getNext() == first){
break;
}
cur = cur.getNext();
}
}
//根据用户的输入,计算小孩出圈的顺序
/**
*
* @param strNo 表示从第几个小孩开始数数
* @param countNum 表示数几下
* @param nums 表示最初有多少小孩在圈中
*/
public void count(int strNo , int countNum, int nums){
//先对数据进行校验
if (first == null || strNo < 1 || strNo > nums){
System.out.println("参数输入有误");
return;
}
//创建一个辅助指针,帮助完成小孩出圈
Boy helper = first;
while (true){//辅助指针指向最后
if (helper.getNext() == first){
break;
}
helper = helper.getNext();
}
//在移动之前,先让first和helper移动到起点k
for (int j = 0; j < strNo - 1 ;j++){
first = first.getNext();
helper = helper.getNext();
}
//进行循环操作,直到圈中只有一个节点
while(true){
if (helper == first){
break;
}
//移动countNum-1次
for (int i =0; i< countNum-1;i++){
first = first.getNext();
helper = helper.getNext();
}
//这是first这个节点为出圈的节点
System.out.println(first.getNo());
first = first.getNext();
helper.setNext(first);
}
System.out.println("最后的一个节点" + first.getNo());
}
}
//创建一个Boy类表示一个节点
class Boy{
private int no;
private Boy next;
public Boy() {
}
Boy(int no){
this.no = no;
}
//省略getter、setter方法
}