一:单向链表基本介绍
链表是一种数据结构,和数组同级。比如,Java中我们使用的ArrayList,其实现原理是数组。而LinkedList的实现原理就是链表了。链表在进行循环遍历时效率不高,但是插入和删除时优势明显。下面对单向链表做一个介绍。
单向链表是一种线性表,实际上是由节点(Node)组成的,一个链表拥有不定数量的节点。其数据在内存中存储是不连续的,它存储的数据分散在内存中,每个结点只能也只有它能知道下一个结点的存储位置。由N各节点(Node)组成单向链表,每一个Node记录本Node的数据及下一个Node。向外暴露的只有一个头节点(Head),我们对链表的所有操作,都是直接或者间接地通过其头节点来进行的。 上图中最左边的节点即为头结点(Head),但是添加节点的顺序是从右向左的,添加的新节点会被作为新节点。最先添加的节点对下一节点的引用可以为空。引用是引用下一个节点而非下一个节点的对象。因为有着不断的引用,所以头节点就可以操作所有节点了。 下图描述了单向链表存储情况。存储是分散的,每一个节点只要记录下一节点,就把所有数据串了起来,形成了一个单向链表。 节点(Node)是由一个需要储存的对象及对下一个节点的引用组成的。也就是说,节点拥有两个成员:储存的对象、对下一个节点的引用。下面图是具体的说明:
二:链表的实现
package com.cgs.demo.service;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.Stack;
/**
* @author chenguangshuai
* @title: SingleLinkedListDemo
* @projectName demo
* @description: 链表
* @date 2/24/22-3:54 PM
*/
public class SingleLinkedListDemo {
public static void main(String[] args) {
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(new HeroNode(1, "卢本伟", "五五开"));
singleLinkedList.add(new HeroNode(5, "韩金龙", "芜湖大司马"));
// singleLinkedList.list();
singleLinkedList.addByOrder(new HeroNode(3, "王云浩", "小天才"));
System.out.println("----------------------------------");
// singleLinkedList.list();
singleLinkedList.updateByNo(new HeroNode(3, "DSM", "芜湖厨子"));
// singleLinkedList.list();
// System.out.println("----------------删除---------------");
// singleLinkedList.deleteByNo(5);
SingleLinkedList.reverse(singleLinkedList.head);
singleLinkedList.list();
singleLinkedList.reversePrint(singleLinkedList.head);
// System.out.println(singleLinkedList.getLength(singleLinkedList.head));
// System.out.println(SingleLinkedList.getIndexHeroNode(singleLinkedList.head, 1));
}
static class SingleLinkedList {
//先初始化一个节点,头节点不动,不存在具体数据
HeroNode head = new HeroNode(0, "", "");
//添加节点到单向链表
//1. 找到当前链表的最后节点
//2. 将最后这个节点的next指定新节点
public void add(HeroNode heroNode) {
//因为head节点不能动,所以需要一个辅助变量temp
HeroNode temp = head;
while (true) {
//根据是否有下个节点判断 是否到了链表动最后
if (temp.next == null) {
break;
}
//如果没有找到最后 temp后移
temp = temp.next;
}
//当退出循环时,temp就指向了链表的最后位置
//当最后这个节点的next 指向新的节点
temp.next = heroNode;
}
//显示链表
/**
* 显示链表
*/
public void list() {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
}
//因为头节点,不能动,因此我们需要一个中间变量来遍历
HeroNode temp = head.next;
while (true) {
//判断是否到链表最后
if (temp == null) {
break;
}
//输出节点的信息
System.out.println(temp);
//将中间变量后移
temp = temp.next;
}
}
/**
* 根据顺序添加
*
* @param heroNode 节点元素
*/
public void addByOrder(HeroNode heroNode) {
//因为头节点不能动,因此需要一个辅助指针(变量)来帮助找到到添加到位置
//因为单链表,因为temp(中间变量)是位于添加位置到上一个节点
HeroNode temp = head;
//标记需要添加到编号是否存在,默认为false
boolean flag = false;
while (true) {
//temp为链表到尾节点
if (temp.next == null) {
break;
}
//temp的下个节点的编号大于要插入的节点 位置找到
if (temp.next.no > heroNode.no) {
break;
}
//编号已经存在
if (temp.next.no == heroNode.no) {
flag = true;
break;
}
//后移
temp = temp.next;
}
//根据flag的值判断
if (flag) {
System.out.printf("准备插入的英雄编号%d已经存在了\n", heroNode.no);
} else {
//找到对应的位置
heroNode.next = temp.next;
temp.next = heroNode;
}
}
/**
* 根据编号修改节点
*
* @param heroNode 新节点
*/
public void updateByNo(HeroNode heroNode) {
//判断队列是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
HeroNode temp = head;
//对链表进行遍历找到要修改对节点
boolean flag = false;
while (true) {
//已经遍历到链表尾
if (temp.next == null) {
break;
}
if (temp.no == heroNode.no) {
//找到对应对节点
flag = true;
break;
}
temp = temp.next;
}
//找到对应编号到节点
if (flag) {
temp.nickName = heroNode.nickName;
temp.name = heroNode.name;
} else {
System.out.println("没有找到对应节点");
}
}
/**
* 根据编号删除节点
*
* @param no 节点编号
*/
public void deleteByNo(int no) {
//判断是否链表为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
HeroNode temp = head;
//设置标识
boolean flag = false;
while (true) {
//已经遍历到链表尾
if (temp.next == null) {
break;
}
//找到修改节点的上一个节点
if (temp.next.no == no) {
flag = true;
break;
}
temp = temp.next;
}
//找到对应的节点
if (flag) {
//找到要删除节点的上一个节点 将删除节点的下一个节点 绑定为中间变量的下一个节点
temp.next = temp.next.next;
} else {
System.out.println("没有对应的节点无法删除");
}
}
/***
* 单链表面试题
* 1。求单链表中的有效节点的个数
* 2。查找单链表中倒数第K个节点
* 3。单链表的反转
* 4。从尾到头打印单链表【百度,要求方式1 : 反向遍历。方式2 :stack栈】
* 5。合并两个有序的单链表,合并玩之后的链表依然有序【课后练习】
* 6。约瑟夫环问题:已知n个人(以编号1,2,3...n分别表示)围坐在一张圆桌周围。从编号为k的人开始报数,数到m的那个人出列;他的下一个人又从1开始报数,数到m的那个人又出列;依此规律重复下去,直到圆桌周围的人全部出列。
*/
/**
* 链表的长度计算
*
* @param head 头节点
* @return
*/
public static int getLength(HeroNode head) {
if (head.next == null) {
return 0;
}
int index = 0;
HeroNode temp = head.next;
while (true) {
if (temp == null) {
break;
}
index++;
temp = temp.next;
}
return index;
}
/**
* 获取链表中第K个节点
* @param index 第K节点
* @return
*/
/***
* 思路
* 1.编写函数,接受head节点,同时接受一个index
* 2.index表示是倒数第index个节点
* 3.先把链表从头到尾遍历,得到链表的总长度
* 4.得到size后 我们从头开始遍历(size-index)个,就可以得到
*/
public static HeroNode getIndexHeroNode(HeroNode temp, int index) {
//判断如果链表为空,返回null
if (temp.next == null) {
return null;
}
//获取链表的长度
int length = getLength(temp);
//第二次遍历
// int mark = 0;
//从第一个有效节点开始
temp = temp.next;
// while (true) {
// if (mark == length - index) {
// break;
// }else {
// mark++;
// temp = temp.next;
// }
// }
//校验index
if (index <= 0 || index > length) {
return null;
}
for (int i = 0; i < length - index; i++) {
temp = temp.next;
}
return temp;
}
/**
* 反转链表
* @param head 头节点
* @return
*/
/***
* 思路
* 1.先定义一个节点 reverseHead = new HeroNode();
* 2.从头到尾遍历原来的链表,每遍历一个节点,并放在新的链表reverseHeroNode的最前端
* 3.原来的链表的head.next = reverseHead.next
*/
public static void reverse(HeroNode head) {
//检验链表
if (head.next == null || head.next.next == null) {
return;
}
//定义一个新的辅助指针(变量),帮助我们遍历原来的链表
HeroNode cur = head.next;
//指向当前节点【cur】的下一个节点
HeroNode next = null;
HeroNode reverseHead = new HeroNode(0, "", "");
//遍历原来的链表,每遍历一个节点,就将它取出来,并放在新的链表reverseHead的最前端
while (cur != null) {
//先暂时保存在当前节点的下一个节点,因为后面需求使用
next = cur.next;
//将cur的下一个节点指向新的链表的节点
cur.next = reverseHead.next;
reverseHead.next = cur;
cur = next;//后移
}
//将head.next 指向reverseHead.next 实现单链表的反转
head.next = reverseHead.next;
}
/**
* 思路
* 利用栈这个数据结构,将各个节点压入到栈中,利用栈的先进后出的特点,就实现了逆序打印的效果
* @param head 链表的头节点
*/
public void reversePrint(HeroNode head) {
if (head.next == null) {
return; // 空链表,不能打印
}
//创建一个栈,给所有节点压入栈
Stack<HeroNode> stack = new Stack<>();
HeroNode temp = head.next;
//将链表中的所有节点压入栈
while (temp != null) {
stack.push(temp);
temp = temp.next;//temp后移,这样就可以压入下一个节点
}
//将栈中的节点进行打印,pop出栈
while(stack.size()>0){
System.out.println(stack.pop());
}
}
}
@Data
@NoArgsConstructor
static
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;
}
public HeroNode(int no, String name) {
this.no = no;
this.name = name;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickName='" + nickName + '\'' +
'}';
}
}
}