java linked list,javalinkedlist链表结构
如何解决写爬虫IP受阻的问题？立即使用。
文章目录
1.单链表介绍2。单链表的实现1。单链表的创建(添加)1.1尾添加1.2按排名添加2。修改单链表节点3。删除单链表节点4。单链表的完整实现3。单链表面试问题一、单链表介绍
单链表是一种有序列表，以节点的形式存储信息，但节点不一定是连续的。每个节点包括数据域和下一个域。
数据字段：用于存储数据。下一域：指向下一个节点。
链表分为有前导节点的链表和无前导节点的链表。
单链表(前导节点)单链表(非前导节点)二、单链表的实现
1.单链表的创建(添加)
1.1尾添加
尾添加的思路
先创建一个head节点，用来表示单个链表的头。
每增加一个节点，就直接加到链表的末尾。
添加：查找当前链表的最后一个节点，不考虑编号顺序，并将最后一个节点的下一个指向新节点。代码实现
//添加方法一：末尾添加。
public void add(HeroNode HeroNode){
//因为头部不能移动，所以需要一个辅助变量(指针)temp。
HeroNode temp=head
while (true) {
//如果遍历到链表的末尾
if (temp.next==null) {
打破；
}
//临时指针向后移动
temp=temp.next
}
//退出循环时，temp指向链表的末尾
temp.next=heroNode
}1.2按排名添加
按排名添加的思路
首先通过辅助变量(temp指针)找到新添加节点的位置。
新节点。next=temp.next
temp.next=新节点；
代码实现
//添加方法二：按排名添加。
public void addByOrder(HeroNode HeroNode){
HeroNode temp=head//借助辅助指针
布尔标志=假；//添加的号码存在吗？
while (true) {
If (temp.next==null) {//遍历到末尾
打破；
}
if(temp . next . no heronode . no){//position，并紧接在temp之后插入。
打破；
} else if(temp . next . no==heronode . no){//此号码已经存在。
flag=true
打破；
}
temp=temp.next//向后移动并遍历当前链表
}
如果(标志){
//不能添加
System.out.printf(要插入的英雄号%d已经存在，不能添加\n ，heronode . no)；
}否则{
//在temp之后插入
heronode . next=temp . next；
temp.next=heroNode
}
}2.单链表节点的修改
修改的思路
先通过遍历找到节点。
temp . name=new heronode . name；temp . nickname=newheronode . nickname；
代码实现
//修改节点信息，根据节点的no属性修改其他信息。
公共void更新(HeroNode newHeroNode) {
//空链表不能修改节点信息。
if (head.next==null) {
System.out.println(链表为空~ )；
返回；
}
//根据no排名找到需要修改的节点
HeroNode temp=head.next
布尔标志=假；//标志表示是否找到要修改的节点。
while (true) {
if (temp==null) {
//遍历到末尾
打破；
}
if (temp.no==newHeroNode.no) {
//找到
flag=true
打破；
}
temp=temp.next//向后移动
}
如果(标志){
temp . name=new heronode . name；
temp . nickname=new heronode . nickname；
}否则{
System.out.printf(找不到编号为%d的节点，无法修改\n ，new heronode . No)；
}
}3.单链表节点的删除
删除的思路
找到要删除的节点的上一个节点。
temp.next=temp.next.next
被删除的节点不会有其他引用，会被垃圾收集机制回收。代码实现
公共无效删除(整数){
HeroNode temp=head
布尔标志=假；//找到要删除的节点了吗？
while (true) {
if (temp.next==null) {
//遍历到末尾
打破；
}
if (temp.next.no==no) {
//找到要删除的节点的上一个节点。
flag=true
打破；
}
temp=temp.next//向后移动
}
如果(标志){
//可以删除
temp . next=temp . next . next；
}否则{
System.out.printf (%d要删除的节点不存在\n ，否)；
}
}4.单链表的完整实现
包com . gql . linked list；/**
*单链表
*
* @郭千亮
*
*/public类SingleLinkedListDemo {
公共静态void main(String[] args) {
//创建一个节点
HeroNode hero1=new HeroNode(1，宋江，及时雨)；
HeroNode hero2=new HeroNode(2，卢俊义，玉麒麟)；
HeroNode hero3=新英雄节点(3，吴用, 智多星);
HeroNode hero4=新的英雄节点(4，林冲, 豹子头);
//创建单向链表
single linked list single linked list=new single link list()；
//加入
单链表。addbyorder(英雄1)；
单链表。addbyorder(英雄4)；
单链表。addbyorder(英雄3)；
单链表。addbyorder(英雄2)；
单链表。list()；
//测试修改节点
英雄节点新英雄节点=新英雄节点(2，小卢, 玉麒麟~);
单链表。更新(newHeroNode)；
System.out.println(修改后的链表情况：);
单链表。list()；
//删除一个节点
list链表。删除(1)；
list链表。删除(2)；
list链表。删除(3)；
list链表。删除(4)；
System.out.println(删除后的链表情况：);
单链表。list()；
}}//定义SingleLinkedList，管理英雄类SingleLinkedList {
//初始化头结点，不存放具体数据
private HeroNode head=new HeroNode(0，， )；
//添加方式1:尾添加
//思路：
//1.找到当前链表的最后节点
//2.将这个最后的节点的然后指向新的节点
public void add(HeroNode HeroNode){
//因为头头不能动，因此需要一个辅助变量（指针)温度
HeroNode temp=head
while (true) {
//如果遍历到链表的最后
if (temp.next==null) {
打破；
}
//临时指针后移
temp=temp.next
}
//当退出循环时，温度指向链表的最后
temp.next=heroNode
}
//添加方式2:根据排名添加
public void addByOrder(HeroNode HeroNode){
HeroNode temp=head//借助辅助指针
布尔标志=假；//添加的编号是否存在
while (true) {
if (temp.next==null) {//遍历到结尾
打破；
}
if (temp.next.no heroNode.no) {//位置找到，就在临时雇员的后面插入
打破；
} else if(temp。下一个。no==heronode。否){//该编号已存在
标志=真
打破；
}
温度=temp.next//后移，遍历当前链表
}
如果（标志){
//不能添加
System.out.printf(准备插入的英雄的编号%d已经存在，不能加入\n ，英雄节点。否)；
}否则{
//插入到临时雇员的后面
英雄节点。next=温度。接下来；
temp.next=heroNode
}
}
//修改节点信息，根据节点的不属性修改其他信息
公共空的更新(HeroNode newHeroNode) {
//空链表无法修改节点信息
if (head.next==null) {
System.out.println(链表为空~);
返回；
}
//根据不排名找到需要修改的节点
HeroNode temp=head.next
布尔标志=假；//标志表示是否找到需要修改的节点
while (true) {
if (temp==null) {
//遍历到结尾
打破；
}
if (temp.no==newHeroNode.no) {
//找到
标志=真
打破；
}
温度=temp.next//后移
}
如果（标志){
在…之时name=new heronode。姓名；
在…之时昵称=新英雄节点。昵称；
}否则{
System.out.printf(没有找到编号为%d的节点，不能修改\n ，新的heronode。否)；
}
}
//删除节点
//思路：
//1.找到需要删除节点的前一个节点
//2.temp.next=temp.next.next
//3.被删除的节点将会被垃圾回收机制回收
公共无效删除（整数){
HeroNode temp=head
布尔标志=假；//是否找到待删除节点
while (true) {
if (temp.next==null) {
//遍历到结尾
打破；
}
if (temp.next.no==no) {
//找到了待删除节点的前一个节点
标志=真
打破；
}
温度=temp.next//后移
}
如果（标志){
//可以删除
在…之时next=温度。下一个。接下来；
}否则{
System.out.printf(要删除的%d节点不存在\n ，否);
}
}
//显示链表[遍历]
公共无效列表(){
//空链表直接返回
if (head.next==null) {
System.out.println(链表为空);
返回；
}
//仍然使用辅助变量（指针),进行循环
HeroNode temp=head.next
while (true) {
if (temp==null) {
打破；
}
系统。出去。println(temp)；
//将临时雇员后移
temp=temp.next
}
}}//定义英雄节点，每一个英雄节点就是一个节点类英雄节点{
公共（同Internationalorganizations）国际组织号；//排名
公共字符串名称；
公共字符串昵称；//昵称
public HeroNode next//指向下一个节点
//构造器
公共HeroNode() {
super()；
}
public HeroNode(int no，String name，String nickname) {
super()；
this.no=no
this.name=name
this.nickname=昵称；
}
//重写转换对象为字符串
@覆盖
公共字符串toString() {
返回HeroNode [no= no ，name= name ，nickname= nickname ]；
}}运行结果
三、单链表面试题
上面四个面试题，答案都放在下面的代码中
包com。gql。链表；导入Java。util。堆栈；/**
* 模拟单链表
*
* @作者胡蝶
* @Email:guoqianliang@foxmail.com
* @日期2020年七月16日下午6:47:42
*/公共类SingleLinkedListDemo {
公共静态void main(String[] args) {
//创建节点
HeroNode hero1=新的英雄节点(1，宋江, 及时雨);
HeroNode hero2=新英雄节点(2，卢俊义, 玉麒麟);
HeroNode hero3=新英雄节点(3，吴用, 智多星);
HeroNode hero4=新的英雄节点(4，林冲, 豹子头);
//创建单向链表
single linked list single linked list=new single link list()；
//加入
单链表。addbyorder(英雄1)；
单链表。addbyorder(英雄4)；
单链表。addbyorder(英雄3)；
单链表。addbyorder(英雄2)；
单链表。list()；
//测试修改节点
英雄节点新英雄节点=新英雄节点(2，小卢, 玉麒麟~);
单链表。更新(newHeroNode)；
System.out.println(修改后的链表情况：);
单链表。list()；
//删除一个节点
list链表。删除(4)；
System.out.println(删除后的链表情况：);
单链表。list()；
//练习4:反向打印单链表
System.out.println(反向打印单链表：);
反向打印(单链表。gethead())；
//练习3:反转单链表
反转列表(单链接列表。gethead())；
System.out.println(反转过后的单链表为：);
单链表。list()；
//练习1:获取单链表节点个数
System.out.println(单链表的有效个数为：);
系统。出去。println(getLength(sing链表。gethead())；
int index=2；
//练习2:获取单链表倒数第指数给节点
System.out.println(倒数第索引个节点为：);
系统。出去。println(getLastKNode(sing linked list。gethead()、index))；
}
/**
* @描述：获取单链表节点个数思路：当循环遍历指针
*/
public static int getLength(hero node head){
if (head.next==null) {
返回0;
}
int length=0；
//辅助指针
HeroNode p=head.next
而(p！=null) {
长度；
p=p . next
}
返回长度；
}
/**
* @描述：
* 查找单链表中倒数第指数个节点索引：表示倒数第指数给节点
* 思路：
* 1.首先获取链表的长度长度，可直接调用长度
* 2.然后从链表第一个开始遍历，遍历（长度索引)个
* 3.找不到返回空
*/
公共静态HeroNode getLastKNode(HeroNode head，int index) {
if (head.next==null) {
返回空
}
int length=getLength(head)；
if (index=0 索引长度){
返回空
}
HeroNode p=head.next
for(int I=0；我长度指数；i ){
p=p . next
}
返回p；
}
/**
* @描述：
* 反转单链表[带头节点]
* 思路：
* 1.先定义一个节点reversalHead=new HeroNode(0，， )；
* 2.遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表反向磁头的最前端
* 3.原来的链表的head.next=reversalHead
*/
公共静态作废冲销列表(英雄节点头){
//链表为空或只有一个节点，无需反转，直接返回
如果(头。next==null head。下一个。next==null){
返回；
}
//辅助指针p
HeroNode p=head.next
HeroNode next=null//指向辅助指针p的下一个位置
HeroNode反转头=new HeroNode(0，， )；
//遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表反向磁头的最前端
而(p！=null){
next=p.next
p。下一个=反转头。接下来；
反转头。next=p；
p=下一个；
}
头。下一个=反转头。接下来；
}
/**
* @描述：
* 反向打印单链表[带头节点]
* 思路1:单链表反转后打印（不建议，因为破坏了单链表的结构)
* 思路2:使用栈结构，利用栈先进后出的特点
*/
公共静态作废反印(英雄节点头){
if(head.next==null){
返回；
}
StackHeroNode stack=new StackHeroNode()；
HeroNode p=head.next
而(p！=null){
堆栈。推(p)；
p=p . next
}
//将栈中的节点进行打印
while(stack.size() 0){
系统。出去。println(堆栈。pop())；
}
}}//定义SingleLinkedList，管理英雄，即链表的增删改查类SingleLinkedList {
//初始化头结点，不存放具体数据
private HeroNode head=new HeroNode(0，， )；
//添加方式1:尾添加
//思路：
//1.找到当前链表的最后节点
//2.将这个最后的节点的然后指向新的节点
public void add(HeroNode HeroNode){
//因为头头不能动，因此需要一个辅助变量（指针)温度
HeroNode temp=head
while (true) {
//如果遍历到链表的最后
if (temp.next==null) {
打破；
}
//临时指针后移
temp=temp.next
}
//当退出循环时，温度指向链表的最后
temp.next=heroNode
}
public HeroNode getHead() {
回程头；
}
//添加方式2:根据排名添加
public void addByOrder(HeroNode HeroNode){
HeroNode temp=head//借助辅助指针
布尔标志=假；//添加的编号是否存在
while (true) {
if (temp.next==null) {//遍历到结尾
打破；
}
if (temp.next.no heroNode.no) {//位置找到，就在临时雇员的后面插入
打破；
} else if(temp。下一个。no==heronode。否){//该编号已存在
标志=真
打破；
}
温度=temp.next//后移，遍历当前链表
}
如果（标志){
//不能添加
System.out.printf(准备插入的英雄的编号%d已经存在，不能加入\n ，英雄节点。否)；
}否则{
//插入到临时雇员的后面
英雄节点。next=温度。接下来；
temp.next=heroNode
}
}
//修改节点信息，根据节点的不属性修改其他信息
公共空的更新(HeroNode newHeroNode) {
//空链表无法修改节点信息
if (head.next==null) {
System.out.println(链表为空~);
返回；
}
//根据不排名找到需要修改的节点
HeroNode temp=head.next
布尔标志=假；//标志表示是否找到需要修改的节点
while (true) {
if (temp==null) {
//遍历到结尾
打破；
}
if (temp.no==newHeroNode.no) {
//找到
标志=真
打破；
}
温度=temp.next//后移
}
如果（标志){
在…之时name=new heronode。姓名；
在…之时昵称=新英雄节点。昵称；
}否则{
System.out.printf(没有找到编号为%d的节点，不能修改\n ，新的heronode。否)；
}
}
//删除节点
//思路：
//1.找到需要删除节点的前一个节点
//2.temp.next=temp.next.next
//3.被删除的节点将会被垃圾回收机制回收
公共无效删除（整数){
HeroNode temp=head
布尔标志=假；//是否找到待删除节点
while (true) {
if (temp.next==null) {
//遍历到结尾
打破；
}
if (temp.next.no==no) {
//找到了待删除节点的前一个节点
标志=真
打破；
}
温度=temp.next//后移
}
如果（标志){
//可以删除
在…之时next=温度。下一个。接下来；
}否则{
System.out.printf(要删除的%d节点不存在\n ，否);
}
}
//显示链表[遍历]
公共无效列表(){
//空链表直接返回
if (head.next==null) {
System.out.println(链表为空);
返回；
}
//仍然使用辅助变量（指针),进行循环
HeroNode temp=head.next
while (true) {
if (temp==null) {
打破；
}
系统。出去。println(temp)；
//将临时雇员后移
temp=temp.next
}
}}//定义英雄节点，每一个英雄节点就是一个节点类英雄节点{
公共（同Internationalorganizations）国际组织号；//排名
公共字符串名称；
公共字符串昵称；//昵称
public HeroNode next//指向下一个节点
//构造器
公共HeroNode() {
super()；
}
public HeroNode(int no，String name，String nickname) {
super()；
this.no=no
this.name=name
this.nickname=昵称；
}
//重写转换对象为字符串
@覆盖
公共字符串toString() {
返回HeroNode [no= no ，name= name ，nickname= nickname ]；
}}以上就是爪哇岛实现单链表（链表)相关的详细内容，更多请关注我们其它相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。