016 单链表介绍和内存布局
链表(Linked List)是有序的列表，但是它在内存中是存储如下：
- 链表是以节点的方式来存储，是链式存储
- 每个节点包含 data 域，next 域指向下一个节点
- 如图：发现链表的各个节点不一定是连续存入的
- 链表分带头节点链表和没有头节点的链表，根据实际的需求来确定
顺序表易查询，链表易更新
017 单链表创建和遍历的分析实现
使用带 head 头的 单向链表实现-水浒英雄排行榜管理
- 完成对英雄人物的增删改操作，注：删除和修改，查找 建议独立完成
- 第一种方式在添加英雄时，直接添加到链表的发问
- 第二种方式在添加英雄时，根据排名将英雄插入到指定位置。（如果有这个排名，则添加失败，并给出指示）
图片这里的代码是这样写的，但是实际输出，发现最后一个无法输出，这里被我修改了
package com.old.linkedList_016_023;
public class SingleLinkedListDeme {
public static void main(String[] args) {
//测试
//创建节点
HeroNode node1 = new HeroNode(1, "宋江", "及时雨");
HeroNode node2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode node3 = new HeroNode(3, "吴用", "智多星");
HeroNode node4 = new HeroNode(4, "林冲", "豹子头");
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(node1);
singleLinkedList.add(node2);
singleLinkedList.add(node3);
singleLinkedList.add(node4);
singleLinkedList.list();
}
}
/**
* 定义 SinleLinkedList 管理英雄人物
*/
class SingleLinkedList {
/**
* 初始化头节点，头节点不要动
* 不放具体的数据
*/
private 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;
}
/**
* 当退出while 循环时，temp 就指向了链表的最后
* 因为 head 是头节点，只会是第一个，所以直接 next 不行
*/
temp.next = heroNode;
}
/**
* 显示链表
*/
public void list(){
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头结点不能动，因此需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true){
System.out.println(temp);
//判断是否到链表最后了
if (temp.next == null){
break;
}
temp = temp.next;
}
}
}
//定义 HeroNode ， 每个 HeroNode，对象就是一个节点
class HeroNode {
public int no;
private String name;
private String nickname;
/**
* 指向下一个节点
*/
public HeroNode next;
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
public HeroNode getNext() {
return next;
}
public void setNext(HeroNode next) {
this.next = next;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
018 单链表顺序插入节点
- 首先找到新添加的节点的位置，通过辅助变量（指针，通过遍历
- 新的节点.next = temp.next
- 让 temp.next = 新的节点
package com.old.linkedList_016_023;
import java.util.LinkedList;
public class SingleLinkedListDeme {
public static void main(String[] args) {
//测试
//创建节点
HeroNode node1 = new HeroNode(1, "宋江", "及时雨");
HeroNode node2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode node3 = new HeroNode(3, "吴用", "智多星");
HeroNode node4 = new HeroNode(4, "林冲", "豹子头");
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(node1);
singleLinkedList.add(node2);
singleLinkedList.add(node3);
singleLinkedList.add(node4);
singleLinkedList.list();
//清除
singleLinkedList.clear();
singleLinkedList.list();
singleLinkedList = new SingleLinkedList();
singleLinkedList.addByOrder(node2);
singleLinkedList.addByOrder(node1);
singleLinkedList.addByOrder(node4);
singleLinkedList.addByOrder(node3);
singleLinkedList.list();
}
}
/**
* 定义 SinleLinkedList 管理英雄人物
*/
class SingleLinkedList {
/**
* 初始化头节点，头节点不要动
* 不放具体的数据
*/
private HeroNode head = new HeroNode(0, "", "");
/**
* 添加节点到单身链表
* 思路：
* 1.当不考虑编号的顺序时，找到当前链表的最后节点
* 2. 将最后这个节点的 next 指向新的节点
* <p>
* 目前这种链表是按照顺序添加的，不是按照编号进行排序
*/
public void add(HeroNode heroNode) {
//因为 head 节点不能动，因此需要一个辅助记功 temp
HeroNode temp = head;
//遍历链表，找到最后
while (true) {
//找到最后一个链表
if (temp.next == null) {
break;
}
//如果没有找到，就将 temp 后移
temp = temp.next;
}
/**
* 当退出while 循环时，temp 就指向了链表的最后
* 因为 head 是头节点，只会是第一个，所以直接 next 不行
*/
temp.next = heroNode;
}
/**
* 第二种添加英雄的方式，根据排名将英雄插入到指定位置
* 如果有这个排名，则添加失败，并给出提示
*/
public void addByOrder(HeroNode heroNode) {
/**
* 因为头节点不能动，因此仍然通过一个辅助指针（变量）来帮助找到添加的位置
* 因为单链表，因为我们找到的 temp ，是位于添加位置的前一个节点，否则插入不了
*
*/
HeroNode temp = head;
//标识添加的编号是否存在，默认为false
boolean flag = false;
while (true) {
if (temp.next == null) {
/*
说明 temp 已经在链表的最后
*/
break;
}
/**
* 位置找到了，就 temp 的后边插入
*/
if (temp.next.no > heroNode.no) {
break;
} else if (temp.next.no == heroNode.no) {
//说明希望添加的 heroNode 的编号已然存在了
flag = true;
break;
}
temp = temp.next;//后移，遍历当前的链表
}
/**
* 当跳出 while 循环之后
* 判断 flag 的值
*/
if (flag) {
//说明不能添加，编号存在
System.out.println("准备插入的英雄编号已经存在，不能加入: " + heroNode.no);
} else {
//插入到链表中
heroNode.next = temp.next;
temp.next = heroNode;
}
}
public void clear() {
HeroNode temp = head;
while (true) {
HeroNode node = temp.next;
if (node == null) {
break;
}
temp = node;
node = null;
}
head = new HeroNode(0, "", "");
}
/**
* 显示链表
*/
public void list() {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头结点不能动，因此需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true) {
System.out.println(temp);
//判断是否到链表最后了
if (temp.next == null) {
break;
}
temp = temp.next;
}
}
}
//定义 HeroNode ， 每个 HeroNode，对象就是一个节点
class HeroNode {
public int no;
private String name;
private String nickname;
/**
* 指向下一个节点
*/
public HeroNode next;
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
public HeroNode getNext() {
return next;
}
public void setNext(HeroNode next) {
this.next = next;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
019 单链表节点的修改
新增的方法
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
*
* 根据 new HeroNode 的 no来修改
*
* 我写的
*/
public void update(int no, String name, String nickName){
//判断是否为空
if (isEmpty()){
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
HeroNode temp = head;
while (true){
HeroNode next = temp.next;
if (next.no == no){
next.setName(name);
next.setNickname(nickName);
break;
}
if (next.next == null){
break;
}
temp = temp.next;
}
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
*
* 根据 new HeroNode 的 no来修改
*
* 视频代码
*/
public void update(HeroNode newHeroNode){
//判断是否为空
if (head.next == null){
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
//定义一个辅助变量
HeroNode temp = head;
boolean flag = false;
while (true){
if (temp == null){
break;//已经遍历完链表
}
if(temp.no == newHeroNode.no){
//找到修改的节点
flag = true;
break;
}
temp = temp.next;
}
//根据 flag 判断是否找到要修改的节点
if (flag){
temp.setName(newHeroNode.getName());
temp.setNickname(newHeroNode.getNickname());
}else {
System.out.printf("没有找到这个节点 %d, 还在修改", newHeroNode.no);
}
}
public boolean isEmpty(){
return head.next == null;
}
完整代码
package com.old.linkedList_016_023;
import jdk.nashorn.internal.objects.annotations.Getter;
import java.util.LinkedList;
public class SingleLinkedListDeme {
public static void main(String[] args) {
//测试
//创建节点
HeroNode node1 = new HeroNode(1, "宋江", "及时雨");
HeroNode node2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode node3 = new HeroNode(3, "吴用", "智多星");
HeroNode node4 = new HeroNode(4, "林冲", "豹子头");
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(node1);
singleLinkedList.add(node2);
singleLinkedList.add(node3);
singleLinkedList.add(node4);
singleLinkedList.list();
//清除
singleLinkedList.clear();
singleLinkedList.list();
singleLinkedList = new SingleLinkedList();
singleLinkedList.addByOrder(node2);
singleLinkedList.addByOrder(node1);
singleLinkedList.addByOrder(node4);
singleLinkedList.addByOrder(node3);
singleLinkedList.list();
singleLinkedList.update(3, "诸葛亮", "卧龙");
singleLinkedList.list();
HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
singleLinkedList.update(newHeroNode);
singleLinkedList.list();
}
}
/**
* 定义 SinleLinkedList 管理英雄人物
*/
class SingleLinkedList {
/**
* 初始化头节点，头节点不要动
* 不放具体的数据
*/
private HeroNode head = new HeroNode(0, "", "");
/**
* 添加节点到单身链表
* 思路：
* 1.当不考虑编号的顺序时，找到当前链表的最后节点
* 2. 将最后这个节点的 next 指向新的节点
* <p>
* 目前这种链表是按照顺序添加的，不是按照编号进行排序
*/
public void add(HeroNode heroNode) {
//因为 head 节点不能动，因此需要一个辅助记功 temp
HeroNode temp = head;
//遍历链表，找到最后
while (true) {
//找到最后一个链表
if (temp.next == null) {
break;
}
//如果没有找到，就将 temp 后移
temp = temp.next;
}
/**
* 当退出while 循环时，temp 就指向了链表的最后
* 因为 head 是头节点，只会是第一个，所以直接 next 不行
*/
temp.next = heroNode;
}
/**
* 第二种添加英雄的方式，根据排名将英雄插入到指定位置
* 如果有这个排名，则添加失败，并给出提示
*/
public void addByOrder(HeroNode heroNode) {
/**
* 因为头节点不能动，因此仍然通过一个辅助指针（变量）来帮助找到添加的位置
* 因为单链表，因为我们找到的 temp ，是位于添加位置的前一个节点，否则插入不了
*
*/
HeroNode temp = head;
//标识添加的编号是否存在，默认为false
boolean flag = false;
while (true) {
if (temp.next == null) {
/*
说明 temp 已经在链表的最后
*/
break;
}
/**
* 位置找到了，就 temp 的后边插入
*/
if (temp.next.no > heroNode.no) {
break;
} else if (temp.next.no == heroNode.no) {
//说明希望添加的 heroNode 的编号已然存在了
flag = true;
break;
}
temp = temp.next;//后移，遍历当前的链表
}
/**
* 当跳出 while 循环之后
* 判断 flag 的值
*/
if (flag) {
//说明不能添加，编号存在
System.out.println("准备插入的英雄编号已经存在，不能加入: " + heroNode.no);
} else {
//插入到链表中
heroNode.next = temp.next;
temp.next = heroNode;
}
}
public void clear() {
HeroNode temp = head;
while (true) {
HeroNode node = temp.next;
if (node == null) {
break;
}
temp = node;
node = null;
}
head = new HeroNode(0, "", "");
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
*
* 根据 new HeroNode 的 no来修改
*
* 我写的
*/
public void update(int no, String name, String nickName){
//判断是否为空
if (isEmpty()){
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
HeroNode temp = head;
while (true){
HeroNode next = temp.next;
if (next.no == no){
next.setName(name);
next.setNickname(nickName);
break;
}
if (next.next == null){
break;
}
temp = temp.next;
}
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
*
* 根据 new HeroNode 的 no来修改
*
* 视频代码
*/
public void update(HeroNode newHeroNode){
//判断是否为空
if (head.next == null){
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
//定义一个辅助变量
HeroNode temp = head;
boolean flag = false;
while (true){
if (temp == null){
break;//已经遍历完链表
}
if(temp.no == newHeroNode.no){
//找到修改的节点
flag = true;
break;
}
temp = temp.next;
}
//根据 flag 判断是否找到要修改的节点
if (flag){
temp.setName(newHeroNode.getName());
temp.setNickname(newHeroNode.getNickname());
}else {
System.out.printf("没有找到这个节点 %d, 还在修改", newHeroNode.no);
}
}
public boolean isEmpty(){
return head.next == null;
}
/**
* 显示链表
*/
public void list() {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头结点不能动，因此需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true) {
System.out.println(temp);
//判断是否到链表最后了
if (temp.next == null) {
break;
}
temp = temp.next;
}
}
}
//定义 HeroNode ， 每个 HeroNode，对象就是一个节点
class HeroNode {
public int no;
private String name;
private String nickname;
/**
* 指向下一个节点
*/
public HeroNode next;
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public HeroNode getNext() {
return next;
}
public void setNext(HeroNode next) {
this.next = next;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
020 单链表的删除和小结
思路
- 先找到需要删除的这个节点的前一个节点
- temp.next = tenp.next.next
- 被删除的节点，将不会有其它引用指向，会被垃圾回收机制回收
新增加的代码
/**
* 我写的删除
*
* @param no
*/
public void myRemove(int no) {
if (isEmpty()) {
System.out.println("链表为空");
return;
}
HeroNode temp = this.head;
while (temp.next != null) {
HeroNode next = temp.next;
if (next.no == no) {
temp.next = next.next;
next = null;
break;
}
temp = temp.next;
}
}
全部代码
package com.old.linkedList_016_023;
import java.util.LinkedList;
public class SingleLinkedListDeme {
public static void main(String[] args) {
//测试
//创建节点
HeroNode node1 = new HeroNode(1, "宋江", "及时雨");
HeroNode node2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode node3 = new HeroNode(3, "吴用", "智多星");
HeroNode node4 = new HeroNode(4, "林冲", "豹子头");
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(node1);
singleLinkedList.add(node2);
singleLinkedList.add(node3);
singleLinkedList.add(node4);
singleLinkedList.list();
//清除
singleLinkedList.clear();
singleLinkedList.list();
singleLinkedList = new SingleLinkedList();
singleLinkedList.addByOrder(node2);
singleLinkedList.addByOrder(node1);
singleLinkedList.addByOrder(node4);
singleLinkedList.addByOrder(node3);
singleLinkedList.list();
singleLinkedList.update(6, "诸葛亮", "卧龙");
singleLinkedList.list();
HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
singleLinkedList.update(newHeroNode);
singleLinkedList.list();
System.out.println();
System.out.println("开始删除");
singleLinkedList.myRemove(9);
singleLinkedList.list();
System.out.println();
System.out.println("第二次删除");
singleLinkedList.myRemove(2);
singleLinkedList.list();
System.out.println();
System.out.println("第三次删除");
singleLinkedList.del(1);
singleLinkedList.del(4);
singleLinkedList.del(3);
singleLinkedList.list();
}
}
/**
* 定义 SinleLinkedList 管理英雄人物
*/
class SingleLinkedList {
/**
* 初始化头节点，头节点不要动
* 不放具体的数据
*/
private HeroNode head = new HeroNode(0, "", "");
/**
* 添加节点到单身链表
* 思路：
* 1.当不考虑编号的顺序时，找到当前链表的最后节点
* 2. 将最后这个节点的 next 指向新的节点
* <p>
* 目前这种链表是按照顺序添加的，不是按照编号进行排序
*/
public void add(HeroNode heroNode) {
//因为 head 节点不能动，因此需要一个辅助记功 temp
HeroNode temp = head;
//遍历链表，找到最后
while (true) {
//找到最后一个链表
if (temp.next == null) {
break;
}
//如果没有找到，就将 temp 后移
temp = temp.next;
}
/**
* 当退出while 循环时，temp 就指向了链表的最后
* 因为 head 是头节点，只会是第一个，所以直接 next 不行
*/
temp.next = heroNode;
}
/**
* 第二种添加英雄的方式，根据排名将英雄插入到指定位置
* 如果有这个排名，则添加失败，并给出提示
*/
public void addByOrder(HeroNode heroNode) {
/**
* 因为头节点不能动，因此仍然通过一个辅助指针（变量）来帮助找到添加的位置
* 因为单链表，因为我们找到的 temp ，是位于添加位置的前一个节点，否则插入不了
*
*/
HeroNode temp = head;
//标识添加的编号是否存在，默认为false
boolean flag = false;
while (true) {
if (temp.next == null) {
/*
说明 temp 已经在链表的最后
*/
break;
}
/**
* 位置找到了，就 temp 的后边插入
*/
if (temp.next.no > heroNode.no) {
break;
} else if (temp.next.no == heroNode.no) {
//说明希望添加的 heroNode 的编号已然存在了
flag = true;
break;
}
temp = temp.next;//后移，遍历当前的链表
}
/**
* 当跳出 while 循环之后
* 判断 flag 的值
*/
if (flag) {
//说明不能添加，编号存在
System.out.println("准备插入的英雄编号已经存在，不能加入: " + heroNode.no);
} else {
//插入到链表中
heroNode.next = temp.next;
temp.next = heroNode;
}
}
public void clear() {
HeroNode temp = head;
while (true) {
HeroNode node = temp.next;
if (node == null) {
break;
}
temp = node;
node = null;
}
head = new HeroNode(0, "", "");
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
* <p>
* 根据 new HeroNode 的 no来修改
* <p>
* 我写的
*/
public void update(int no, String name, String nickName) {
//判断是否为空
if (isEmpty()) {
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
HeroNode temp = head;
while (true) {
HeroNode next = temp.next;
if (next.no == no) {
next.setName(name);
next.setNickname(nickName);
break;
}
if (next.next == null) {
System.out.println("链表中没有这个节点：" + no);
break;
}
temp = temp.next;
}
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
* <p>
* 根据 new HeroNode 的 no来修改
* <p>
* 视频代码
*/
public void update(HeroNode newHeroNode) {
//判断是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
//定义一个辅助变量
HeroNode temp = head;
boolean flag = false;
while (true) {
if (temp == null) {
break;//已经遍历完链表
}
if (temp.no == newHeroNode.no) {
//找到修改的节点
flag = true;
break;
}
temp = temp.next;
}
//根据 flag 判断是否找到要修改的节点
if (flag) {
temp.setName(newHeroNode.getName());
temp.setNickname(newHeroNode.getNickname());
} else {
System.out.printf("没有找到这个节点 %d, 还在修改", newHeroNode.no);
}
}
public boolean isEmpty() {
return head.next == null;
}
/**
* 我写的删除
*
* @param no
*/
public void myRemove(int no) {
if (isEmpty()) {
System.out.println("链表为空");
return;
}
HeroNode temp = this.head;
while (temp.next != null) {
HeroNode next = temp.next;
if (next.no == no) {
temp.next = next.next;
next = null;
break;
}
temp = temp.next;
}
}
/**
* 删除节点，
* 1. head 不能动，因此需要一个 tmep 辅助节点找到待删除节点的前一个节点
* 2. 说明在比较时，是 temp.next.no 和需要删除节点的no 比较
*/
public void del(int no) {
HeroNode temp = head;
boolean flag = false;//标志是否找到待删除的节点
while (true){
if (temp.next == null){
//已经到链表的最后了
break;
}
if (temp.next.no == no){
//找到待删除节点的前一个节点
flag = true;
break;
}
temp = temp.next;//temp 后移，遍历
}
if (flag){
//找到
temp.next = temp.next.next;
}else {
System.out.println("要删除的节点不存在：" + no);
}
}
/**
* 显示链表
*/
public void list() {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头结点不能动，因此需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true) {
System.out.println(temp);
//判断是否到链表最后了
if (temp.next == null) {
break;
}
temp = temp.next;
}
}
}
//定义 HeroNode ， 每个 HeroNode，对象就是一个节点
class HeroNode {
public int no;
private String name;
private String nickname;
/**
* 指向下一个节点
*/
public HeroNode next;
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public HeroNode getNext() {
return next;
}
public void setNext(HeroNode next) {
this.next = next;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
小结
- 链表是以节点的方式来存储的，是链式存储
- 每个节点包含 data 域， next 域：指向下一个节点
- 如图：发现链表的各个节点不一定是连续存储
4.链表分带头节点的链表和没有头节点的链表，根据实际需求来确定
021 单链表新浪面试题
- 求单链表中节点的个数
- 查找单链表中倒数第k个结点 【新浪面试题】
- 单链表的反转【腾讯面试题】
- 从尾到头打印单链表【百度，要求方式1：反射遍历。方式2：Stack 栈】
- 合并两个有序的单链表，合并之后的链表依然有序
1 求单链表中节点的个数
新增加的代码
/**
* 获取到单链表的节点的个数（如果是头节点的链表，需求不统计头节点
* @param node head 链表的头节点
* @return 返回有效结果的个数
*/
public static int getLength(HeroNode node){
if (node.next == null){
//空链表
return 0;
}
int length = 0;
/*
我这遍历的节点，都是有头节点的，所以直接取当前节点的下一个开始遍历
*/
HeroNode cur = node.next;
while (cur != null){
length++;
cur = cur.next;
}
return length;
}
全部代码
package com.old.linkedList_016_023;
import java.util.LinkedList;
public class SingleLinkedListDeme {
public static void main(String[] args) {
//测试
//创建节点
HeroNode node1 = new HeroNode(1, "宋江", "及时雨");
HeroNode node2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode node3 = new HeroNode(3, "吴用", "智多星");
HeroNode node4 = new HeroNode(4, "林冲", "豹子头");
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(node1);
singleLinkedList.add(node2);
singleLinkedList.add(node3);
singleLinkedList.add(node4);
singleLinkedList.list();
System.out.println("获取倒数的节点，我的方法:" + MyfindLastNode(singleLinkedList.getHead(), 5));
System.out.println("获取倒数的节点，视频的方法:" + findLastNode(singleLinkedList.getHead(), 5));
//清除
singleLinkedList.clear();
singleLinkedList.list();
singleLinkedList = new SingleLinkedList();
singleLinkedList.addByOrder(node2);
singleLinkedList.addByOrder(node1);
singleLinkedList.addByOrder(node4);
singleLinkedList.addByOrder(node3);
singleLinkedList.list();
singleLinkedList.update(6, "诸葛亮", "卧龙");
singleLinkedList.list();
HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
singleLinkedList.update(newHeroNode);
singleLinkedList.list();
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
System.out.println();
System.out.println("开始删除");
singleLinkedList.myRemove(9);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
System.out.println();
System.out.println("第二次删除");
singleLinkedList.myRemove(2);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
System.out.println();
System.out.println("第三次删除");
singleLinkedList.del(1);
singleLinkedList.del(4);
singleLinkedList.del(3);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
}
/**
* 获取到单链表的节点的个数（如果是头节点的链表，需求不统计头节点
*
* @param node head 链表的头节点
* @return 返回有效结果的个数
*/
public static int getLength(HeroNode node) {
if (node.next == null) {
//空链表
return 0;
}
int length = 0;
/*
我这遍历的节点，都是有头节点的，所以直接取当前节点的下一个开始遍历
*/
HeroNode cur = node.next;
while (cur != null) {
length++;
cur = cur.next;
}
return length;
}
}
/**
* 定义 SinleLinkedList 管理英雄人物
*/
class SingleLinkedList {
/**
* 初始化头节点，头节点不要动
* 不放具体的数据
*/
private HeroNode head = new HeroNode(0, "", "");
/**
* 添加节点到单身链表
* 思路：
* 1.当不考虑编号的顺序时，找到当前链表的最后节点
* 2. 将最后这个节点的 next 指向新的节点
* <p>
* 目前这种链表是按照顺序添加的，不是按照编号进行排序
*/
public void add(HeroNode heroNode) {
//因为 head 节点不能动，因此需要一个辅助记功 temp
HeroNode temp = head;
//遍历链表，找到最后
while (true) {
//找到最后一个链表
if (temp.next == null) {
break;
}
//如果没有找到，就将 temp 后移
temp = temp.next;
}
/**
* 当退出while 循环时，temp 就指向了链表的最后
* 因为 head 是头节点，只会是第一个，所以直接 next 不行
*/
temp.next = heroNode;
}
/**
* 第二种添加英雄的方式，根据排名将英雄插入到指定位置
* 如果有这个排名，则添加失败，并给出提示
*/
public void addByOrder(HeroNode heroNode) {
/**
* 因为头节点不能动，因此仍然通过一个辅助指针（变量）来帮助找到添加的位置
* 因为单链表，因为我们找到的 temp ，是位于添加位置的前一个节点，否则插入不了
*
*/
HeroNode temp = head;
//标识添加的编号是否存在，默认为false
boolean flag = false;
while (true) {
if (temp.next == null) {
/*
说明 temp 已经在链表的最后
*/
break;
}
/**
* 位置找到了，就 temp 的后边插入
*/
if (temp.next.no > heroNode.no) {
break;
} else if (temp.next.no == heroNode.no) {
//说明希望添加的 heroNode 的编号已然存在了
flag = true;
break;
}
temp = temp.next;//后移，遍历当前的链表
}
/**
* 当跳出 while 循环之后
* 判断 flag 的值
*/
if (flag) {
//说明不能添加，编号存在
System.out.println("准备插入的英雄编号已经存在，不能加入: " + heroNode.no);
} else {
//插入到链表中
heroNode.next = temp.next;
temp.next = heroNode;
}
}
public void clear() {
HeroNode temp = head;
while (true) {
HeroNode node = temp.next;
if (node == null) {
break;
}
temp = node;
node = null;
}
head = new HeroNode(0, "", "");
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
* <p>
* 根据 new HeroNode 的 no来修改
* <p>
* 我写的
*/
public void update(int no, String name, String nickName) {
//判断是否为空
if (isEmpty()) {
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
HeroNode temp = head;
while (true) {
HeroNode next = temp.next;
if (next.no == no) {
next.setName(name);
next.setNickname(nickName);
break;
}
if (next.next == null) {
System.out.println("链表中没有这个节点：" + no);
break;
}
temp = temp.next;
}
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
* <p>
* 根据 new HeroNode 的 no来修改
* <p>
* 视频代码
*/
public void update(HeroNode newHeroNode) {
//判断是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
//定义一个辅助变量
HeroNode temp = head;
boolean flag = false;
while (true) {
if (temp == null) {
break;//已经遍历完链表
}
if (temp.no == newHeroNode.no) {
//找到修改的节点
flag = true;
break;
}
temp = temp.next;
}
//根据 flag 判断是否找到要修改的节点
if (flag) {
temp.setName(newHeroNode.getName());
temp.setNickname(newHeroNode.getNickname());
} else {
System.out.printf("没有找到这个节点 %d, 还在修改", newHeroNode.no);
}
}
public boolean isEmpty() {
return head.next == null;
}
/**
* 我写的删除
*
* @param no
*/
public void myRemove(int no) {
if (isEmpty()) {
System.out.println("链表为空");
return;
}
HeroNode temp = this.head;
while (temp.next != null) {
HeroNode next = temp.next;
if (next.no == no) {
temp.next = next.next;
next = null;
break;
}
temp = temp.next;
}
}
/**
* 删除节点，
* 1. head 不能动，因此需要一个 tmep 辅助节点找到待删除节点的前一个节点
* 2. 说明在比较时，是 temp.next.no 和需要删除节点的no 比较
*/
public void del(int no) {
HeroNode temp = head;
boolean flag = false;//标志是否找到待删除的节点
while (true) {
if (temp.next == null) {
//已经到链表的最后了
break;
}
if (temp.next.no == no) {
//找到待删除节点的前一个节点
flag = true;
break;
}
temp = temp.next;//temp 后移，遍历
}
if (flag) {
//找到
temp.next = temp.next.next;
} else {
System.out.println("要删除的节点不存在：" + no);
}
}
/**
* 显示链表
*/
public void list() {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头结点不能动，因此需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true) {
System.out.println(temp);
//判断是否到链表最后了
if (temp.next == null) {
break;
}
temp = temp.next;
}
}
public HeroNode getHead() {
return head;
}
}
//定义 HeroNode ， 每个 HeroNode，对象就是一个节点
class HeroNode {
public int no;
private String name;
private String nickname;
/**
* 指向下一个节点
*/
public HeroNode next;
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public HeroNode getNext() {
return next;
}
public void setNext(HeroNode next) {
this.next = next;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
2 查找单链表中倒数第k个结点 【新浪面试题】
新增加的代码
/**
* 查找单链表中倒数第k个结点 【新浪面试题】
* 1. 编写一个方法，接收 head 节点，同时接收 index，
* 2. index 表示倒数第index个节点
* 3. 先把链表从头到尾遍历，得到链表的总长度
* 4. 得到 size 后 ，从链表的第一个开始遍历，遍历 （size - index)个，就可以得到
* 5. 如果找到了返回该节点，否则返回空
* length - index 就是他的个数
*/
public static HeroNode findLastNode(HeroNode node, int index){
int length = getLength(node);
if (length == 0){
return null;
}
if (index >= length || index <= 0){
System.out.println("超过链表中的节点个数");
return null;
}
HeroNode temp = node.next;
for (int i = 0; i < length - index; i++){
temp = temp.next;
}
return temp;
}
/**
* 查找单链表中倒数第k个结点 【新浪面试题】
* 1. 编写一个方法，接收 head 节点，同时接收 index，
* 2. index 表示倒数第 index 个节点
* 3. 先把链表从头到尾遍历，得到链表的总长度
* 4. 得到 size 后 ，从链表的第一个开始遍历，将链表中所有的数据加入一个数组中，
* 5. length - index 就是他的个数 就是节点在数组的下标
*
*/
public static HeroNode MyfindLastNode(HeroNode node, int lastNum) {
int length = getLength(node);
if (length == 0) {
System.out.println("没有这个节点");
return null;
}
if (lastNum >= length || lastNum <= 0){
System.out.println("超过链表中的节点个数");
return null;
}
HeroNode temp = node.next;
HeroNode[] heroNodes = new HeroNode[length];
for (int i = 0; i < heroNodes.length; i++) {
heroNodes[i] = temp;
temp = temp.next;
}
return heroNodes[length - lastNum];
}
全部代码
package com.old.linkedList_016_023;
import java.util.LinkedList;
public class SingleLinkedListDeme {
public static void main(String[] args) {
//测试
//创建节点
HeroNode node1 = new HeroNode(1, "宋江", "及时雨");
HeroNode node2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode node3 = new HeroNode(3, "吴用", "智多星");
HeroNode node4 = new HeroNode(4, "林冲", "豹子头");
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(node1);
singleLinkedList.add(node2);
singleLinkedList.add(node3);
singleLinkedList.add(node4);
singleLinkedList.list();
System.out.println("获取倒数的节点，我的方法:" + MyfindLastNode(singleLinkedList.getHead(), 5));
System.out.println("获取倒数的节点，视频的方法:" + findLastNode(singleLinkedList.getHead(), 5));
//清除
singleLinkedList.clear();
singleLinkedList.list();
singleLinkedList = new SingleLinkedList();
singleLinkedList.addByOrder(node2);
singleLinkedList.addByOrder(node1);
singleLinkedList.addByOrder(node4);
singleLinkedList.addByOrder(node3);
singleLinkedList.list();
singleLinkedList.update(6, "诸葛亮", "卧龙");
singleLinkedList.list();
HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
singleLinkedList.update(newHeroNode);
singleLinkedList.list();
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
System.out.println();
System.out.println("开始删除");
singleLinkedList.myRemove(9);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
System.out.println();
System.out.println("第二次删除");
singleLinkedList.myRemove(2);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
System.out.println();
System.out.println("第三次删除");
singleLinkedList.del(1);
singleLinkedList.del(4);
singleLinkedList.del(3);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
}
/**
* 查找单链表中倒数第k个结点 【新浪面试题】
* 1. 编写一个方法，接收 head 节点，同时接收 index，
* 2. index 表示倒数第index个节点
* 3. 先把链表从头到尾遍历，得到链表的总长度
* 4. 得到 size 后 ，从链表的第一个开始遍历，遍历 （size - index)个，就可以得到
* 5. 如果找到了返回该节点，否则返回空
* length - index 就是他的个数
*/
public static HeroNode findLastNode(HeroNode node, int index){
int length = getLength(node);
if (length == 0){
return null;
}
if (index >= length || index <= 0){
System.out.println("超过链表中的节点个数");
return null;
}
HeroNode temp = node.next;
for (int i = 0; i < length - index; i++){
temp = temp.next;
}
return temp;
}
/**
* 查找单链表中倒数第k个结点 【新浪面试题】
* 1. 编写一个方法，接收 head 节点，同时接收 index，
* 2. index 表示倒数第 index 个节点
* 3. 先把链表从头到尾遍历，得到链表的总长度
* 4. 得到 size 后 ，从链表的第一个开始遍历，将链表中所有的数据加入一个数组中，
* 5. length - index 就是他的个数 就是节点在数组的下标
*
*/
public static HeroNode MyfindLastNode(HeroNode node, int lastNum) {
int length = getLength(node);
if (length == 0) {
System.out.println("没有这个节点");
return null;
}
if (lastNum >= length || lastNum <= 0){
System.out.println("超过链表中的节点个数");
return null;
}
HeroNode temp = node.next;
HeroNode[] heroNodes = new HeroNode[length];
for (int i = 0; i < heroNodes.length; i++) {
heroNodes[i] = temp;
temp = temp.next;
}
return heroNodes[length - lastNum];
}
/**
* 获取到单链表的节点的个数（如果是头节点的链表，需求不统计头节点
*
* @param node head 链表的头节点
* @return 返回有效结果的个数
*/
public static int getLength(HeroNode node) {
if (node.next == null) {
//空链表
return 0;
}
int length = 0;
/*
我这遍历的节点，都是有头节点的，所以直接取当前节点的下一个开始遍历
*/
HeroNode cur = node.next;
while (cur != null) {
length++;
cur = cur.next;
}
return length;
}
}
/**
* 定义 SinleLinkedList 管理英雄人物
*/
class SingleLinkedList {
/**
* 初始化头节点，头节点不要动
* 不放具体的数据
*/
private HeroNode head = new HeroNode(0, "", "");
/**
* 添加节点到单身链表
* 思路：
* 1.当不考虑编号的顺序时，找到当前链表的最后节点
* 2. 将最后这个节点的 next 指向新的节点
* <p>
* 目前这种链表是按照顺序添加的，不是按照编号进行排序
*/
public void add(HeroNode heroNode) {
//因为 head 节点不能动，因此需要一个辅助记功 temp
HeroNode temp = head;
//遍历链表，找到最后
while (true) {
//找到最后一个链表
if (temp.next == null) {
break;
}
//如果没有找到，就将 temp 后移
temp = temp.next;
}
/**
* 当退出while 循环时，temp 就指向了链表的最后
* 因为 head 是头节点，只会是第一个，所以直接 next 不行
*/
temp.next = heroNode;
}
/**
* 第二种添加英雄的方式，根据排名将英雄插入到指定位置
* 如果有这个排名，则添加失败，并给出提示
*/
public void addByOrder(HeroNode heroNode) {
/**
* 因为头节点不能动，因此仍然通过一个辅助指针（变量）来帮助找到添加的位置
* 因为单链表，因为我们找到的 temp ，是位于添加位置的前一个节点，否则插入不了
*
*/
HeroNode temp = head;
//标识添加的编号是否存在，默认为false
boolean flag = false;
while (true) {
if (temp.next == null) {
/*
说明 temp 已经在链表的最后
*/
break;
}
/**
* 位置找到了，就 temp 的后边插入
*/
if (temp.next.no > heroNode.no) {
break;
} else if (temp.next.no == heroNode.no) {
//说明希望添加的 heroNode 的编号已然存在了
flag = true;
break;
}
temp = temp.next;//后移，遍历当前的链表
}
/**
* 当跳出 while 循环之后
* 判断 flag 的值
*/
if (flag) {
//说明不能添加，编号存在
System.out.println("准备插入的英雄编号已经存在，不能加入: " + heroNode.no);
} else {
//插入到链表中
heroNode.next = temp.next;
temp.next = heroNode;
}
}
public void clear() {
HeroNode temp = head;
while (true) {
HeroNode node = temp.next;
if (node == null) {
break;
}
temp = node;
node = null;
}
head = new HeroNode(0, "", "");
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
* <p>
* 根据 new HeroNode 的 no来修改
* <p>
* 我写的
*/
public void update(int no, String name, String nickName) {
//判断是否为空
if (isEmpty()) {
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
HeroNode temp = head;
while (true) {
HeroNode next = temp.next;
if (next.no == no) {
next.setName(name);
next.setNickname(nickName);
break;
}
if (next.next == null) {
System.out.println("链表中没有这个节点：" + no);
break;
}
temp = temp.next;
}
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
* <p>
* 根据 new HeroNode 的 no来修改
* <p>
* 视频代码
*/
public void update(HeroNode newHeroNode) {
//判断是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
//定义一个辅助变量
HeroNode temp = head;
boolean flag = false;
while (true) {
if (temp == null) {
break;//已经遍历完链表
}
if (temp.no == newHeroNode.no) {
//找到修改的节点
flag = true;
break;
}
temp = temp.next;
}
//根据 flag 判断是否找到要修改的节点
if (flag) {
temp.setName(newHeroNode.getName());
temp.setNickname(newHeroNode.getNickname());
} else {
System.out.printf("没有找到这个节点 %d, 还在修改", newHeroNode.no);
}
}
public boolean isEmpty() {
return head.next == null;
}
/**
* 我写的删除
*
* @param no
*/
public void myRemove(int no) {
if (isEmpty()) {
System.out.println("链表为空");
return;
}
HeroNode temp = this.head;
while (temp.next != null) {
HeroNode next = temp.next;
if (next.no == no) {
temp.next = next.next;
next = null;
break;
}
temp = temp.next;
}
}
/**
* 删除节点，
* 1. head 不能动，因此需要一个 tmep 辅助节点找到待删除节点的前一个节点
* 2. 说明在比较时，是 temp.next.no 和需要删除节点的no 比较
*/
public void del(int no) {
HeroNode temp = head;
boolean flag = false;//标志是否找到待删除的节点
while (true) {
if (temp.next == null) {
//已经到链表的最后了
break;
}
if (temp.next.no == no) {
//找到待删除节点的前一个节点
flag = true;
break;
}
temp = temp.next;//temp 后移，遍历
}
if (flag) {
//找到
temp.next = temp.next.next;
} else {
System.out.println("要删除的节点不存在：" + no);
}
}
/**
* 显示链表
*/
public void list() {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头结点不能动，因此需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true) {
System.out.println(temp);
//判断是否到链表最后了
if (temp.next == null) {
break;
}
temp = temp.next;
}
}
public HeroNode getHead() {
return head;
}
}
//定义 HeroNode ， 每个 HeroNode，对象就是一个节点
class HeroNode {
public int no;
private String name;
private String nickname;
/**
* 指向下一个节点
*/
public HeroNode next;
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public HeroNode getNext() {
return next;
}
public void setNext(HeroNode next) {
this.next = next;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
单链表腾讯面试题
单链表的反转
思路：
- 先定义一个节点 reverseHead = new HeroNode();
- 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并在新的链表的 reverseHead 的最前端
- 原来链表的 head.next = reverseHead.next
新增加的代码
/**
* 将单链表进行返转
*
* @param head
*/
public static void reversetList(HeroNode head) {
//如果当前链表为空，或者只有一个节点，无需反转，直接返回
if (head.next == null || head.next.next == null) {
return;
}
//定义辅助的指针（变量），帮助遍历原来的链表
HeroNode cur = head.next;
HeroNode next = null;//指向当前节点 [cur] 的下一个节点
HeroNode reverseHead = new HeroNode(0, "", "");
/**
* 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表 reverseHead 的最前端
*/
while (cur != null) {
//先暂时保存当前节点的下一个节点，因为后面需要使用
next = cur.next;
/**
* 将 cur 的下一个节点指向新的链表的最前端
* 当前节点的下一个节点都是 reverseHead 的下一个节点
*
* 当前节点是下一个节点 的是 另一个链表的 头节点之后的数据
* 另一个链表的头节点每次放入的都是 当前节点的数据
* 这里缺少了
* 将 cur 连接到新的链表上
* 按照顺序遍历，每次取出当前的节点，然后将当前的节点放在一个链表的最后一个，
* 下次再取出当前的节点。我这个有点不对
*
* 重点是怎么换过来
*
* 将当前节点的下一个节点的为，另一个链表头节点之后的数据，
* 再将另一个链表 头节点之后的数据再换为当前节点的数据，这样就实现了替换
*/
cur.next = reverseHead.next;
reverseHead.next = cur;
cur = next;
}
//将 head.next 指向 reverseHead.next , 实现单链表的反转
head.next = reverseHead.next;
}
全部代码
package com.old.linkedList_016_023;
import java.util.LinkedList;
public class SingleLinkedListDeme {
public static void main(String[] args) {
//测试
//创建节点
HeroNode node1 = new HeroNode(1, "宋江", "及时雨");
HeroNode node2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode node3 = new HeroNode(3, "吴用", "智多星");
HeroNode node4 = new HeroNode(4, "林冲", "豹子头");
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(node1);
singleLinkedList.add(node2);
singleLinkedList.add(node3);
singleLinkedList.add(node4);
singleLinkedList.list();
System.out.println("获取倒数的节点，我的方法:" + MyfindLastNode(singleLinkedList.getHead(), 5));
System.out.println("获取倒数的节点，视频的方法:" + findLastNode(singleLinkedList.getHead(), 5));
//清除
singleLinkedList.clear();
singleLinkedList.list();
singleLinkedList = new SingleLinkedList();
singleLinkedList.addByOrder(node2);
singleLinkedList.addByOrder(node1);
singleLinkedList.addByOrder(node4);
singleLinkedList.addByOrder(node3);
singleLinkedList.list();
singleLinkedList.update(6, "诸葛亮", "卧龙");
singleLinkedList.list();
HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
singleLinkedList.update(newHeroNode);
singleLinkedList.list();
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
System.out.println();
System.out.println("开始删除");
singleLinkedList.myRemove(9);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
System.out.println();
System.out.println("第二次删除");
singleLinkedList.myRemove(2);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
System.out.println();
System.out.println("第三次删除");
singleLinkedList.del(1);
singleLinkedList.del(4);
singleLinkedList.del(3);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
singleLinkedList.addByOrder(node2);
singleLinkedList.addByOrder(node1);
singleLinkedList.addByOrder(node4);
singleLinkedList.addByOrder(node3);
singleLinkedList.list();
System.out.println();
System.out.println("开始反转：");
reversetList(singleLinkedList.getHead());
singleLinkedList.list();
}
/**
* 将单链表进行返转
*
* @param head
*/
public static void reversetList(HeroNode head) {
//如果当前链表为空，或者只有一个节点，无需反转，直接返回
if (head.next == null || head.next.next == null) {
return;
}
//定义辅助的指针（变量），帮助遍历原来的链表
HeroNode cur = head.next;
HeroNode next = null;//指向当前节点 [cur] 的下一个节点
HeroNode reverseHead = new HeroNode(0, "", "");
/**
* 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表 reverseHead 的最前端
*/
while (cur != null) {
//先暂时保存当前节点的下一个节点，因为后面需要使用
next = cur.next;
/**
* 将 cur 的下一个节点指向新的链表的最前端
* 当前节点的下一个节点都是 reverseHead 的下一个节点
*
* 当前节点是下一个节点 的是 另一个链表的 头节点之后的数据
* 另一个链表的头节点每次放入的都是 当前节点的数据
* 这里缺少了
* 将 cur 连接到新的链表上
* 按照顺序遍历，每次取出当前的节点，然后将当前的节点放在一个链表的最后一个，
* 下次再取出当前的节点。我这个有点不对
*
* 重点是怎么换过来
*
* 将当前节点的下一个节点的为，另一个链表头节点之后的数据，
* 再将另一个链表 头节点之后的数据再换为当前节点的数据，这样就实现了替换
*/
cur.next = reverseHead.next;
reverseHead.next = cur;
cur = next;
}
//将 head.next 指向 reverseHead.next , 实现单链表的反转
head.next = reverseHead.next;
}
/**
* 查找单链表中倒数第k个结点 【新浪面试题】
* 1. 编写一个方法，接收 head 节点，同时接收 index，
* 2. index 表示倒数第index个节点
* 3. 先把链表从头到尾遍历，得到链表的总长度
* 4. 得到 size 后 ，从链表的第一个开始遍历，遍历 （size - index)个，就可以得到
* 5. 如果找到了返回该节点，否则返回空
* length - index 就是他的个数
*/
public static HeroNode findLastNode(HeroNode node, int index) {
int length = getLength(node);
if (length == 0) {
return null;
}
if (index >= length || index <= 0) {
System.out.println("超过链表中的节点个数");
return null;
}
HeroNode temp = node.next;
for (int i = 0; i < length - index; i++) {
temp = temp.next;
}
return temp;
}
/**
* 查找单链表中倒数第k个结点 【新浪面试题】
* 1. 编写一个方法，接收 head 节点，同时接收 index，
* 2. index 表示倒数第 index 个节点
* 3. 先把链表从头到尾遍历，得到链表的总长度
* 4. 得到 size 后 ，从链表的第一个开始遍历，将链表中所有的数据加入一个数组中，
* 5. length - index 就是他的个数 就是节点在数组的下标
*/
public static HeroNode MyfindLastNode(HeroNode node, int lastNum) {
int length = getLength(node);
if (length == 0) {
System.out.println("没有这个节点");
return null;
}
if (lastNum >= length || lastNum <= 0) {
System.out.println("超过链表中的节点个数");
return null;
}
HeroNode temp = node.next;
HeroNode[] heroNodes = new HeroNode[length];
for (int i = 0; i < heroNodes.length; i++) {
heroNodes[i] = temp;
temp = temp.next;
}
return heroNodes[length - lastNum];
}
/**
* 获取到单链表的节点的个数（如果是头节点的链表，需求不统计头节点
*
* @param node head 链表的头节点
* @return 返回有效结果的个数
*/
public static int getLength(HeroNode node) {
if (node.next == null) {
//空链表
return 0;
}
int length = 0;
/*
我这遍历的节点，都是有头节点的，所以直接取当前节点的下一个开始遍历
*/
HeroNode cur = node.next;
while (cur != null) {
length++;
cur = cur.next;
}
return length;
}
}
/**
* 定义 SinleLinkedList 管理英雄人物
*/
class SingleLinkedList {
/**
* 初始化头节点，头节点不要动
* 不放具体的数据
*/
private HeroNode head = new HeroNode(0, "", "");
/**
* 添加节点到单身链表
* 思路：
* 1.当不考虑编号的顺序时，找到当前链表的最后节点
* 2. 将最后这个节点的 next 指向新的节点
* <p>
* 目前这种链表是按照顺序添加的，不是按照编号进行排序
*/
public void add(HeroNode heroNode) {
//因为 head 节点不能动，因此需要一个辅助记功 temp
HeroNode temp = head;
//遍历链表，找到最后
while (true) {
//找到最后一个链表
if (temp.next == null) {
break;
}
//如果没有找到，就将 temp 后移
temp = temp.next;
}
/**
* 当退出while 循环时，temp 就指向了链表的最后
* 因为 head 是头节点，只会是第一个，所以直接 next 不行
*/
temp.next = heroNode;
}
/**
* 第二种添加英雄的方式，根据排名将英雄插入到指定位置
* 如果有这个排名，则添加失败，并给出提示
*/
public void addByOrder(HeroNode heroNode) {
/**
* 因为头节点不能动，因此仍然通过一个辅助指针（变量）来帮助找到添加的位置
* 因为单链表，因为我们找到的 temp ，是位于添加位置的前一个节点，否则插入不了
*
*/
HeroNode temp = head;
//标识添加的编号是否存在，默认为false
boolean flag = false;
while (true) {
if (temp.next == null) {
/*
说明 temp 已经在链表的最后
*/
break;
}
/**
* 位置找到了，就 temp 的后边插入
*/
if (temp.next.no > heroNode.no) {
break;
} else if (temp.next.no == heroNode.no) {
//说明希望添加的 heroNode 的编号已然存在了
flag = true;
break;
}
temp = temp.next;//后移，遍历当前的链表
}
/**
* 当跳出 while 循环之后
* 判断 flag 的值
*/
if (flag) {
//说明不能添加，编号存在
System.out.println("准备插入的英雄编号已经存在，不能加入: " + heroNode.no);
} else {
//插入到链表中
heroNode.next = temp.next;
temp.next = heroNode;
}
}
public void clear() {
HeroNode temp = head;
while (true) {
HeroNode node = temp.next;
if (node == null) {
break;
}
temp = node;
node = null;
}
head = new HeroNode(0, "", "");
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
* <p>
* 根据 new HeroNode 的 no来修改
* <p>
* 我写的
*/
public void update(int no, String name, String nickName) {
//判断是否为空
if (isEmpty()) {
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
HeroNode temp = head;
while (true) {
HeroNode next = temp.next;
if (next.no == no) {
next.setName(name);
next.setNickname(nickName);
break;
}
if (next.next == null) {
System.out.println("链表中没有这个节点：" + no);
break;
}
temp = temp.next;
}
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
* <p>
* 根据 new HeroNode 的 no来修改
* <p>
* 视频代码
*/
public void update(HeroNode newHeroNode) {
//判断是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
//定义一个辅助变量
HeroNode temp = head;
boolean flag = false;
while (true) {
if (temp == null) {
break;//已经遍历完链表
}
if (temp.no == newHeroNode.no) {
//找到修改的节点
flag = true;
break;
}
temp = temp.next;
}
//根据 flag 判断是否找到要修改的节点
if (flag) {
temp.setName(newHeroNode.getName());
temp.setNickname(newHeroNode.getNickname());
} else {
System.out.printf("没有找到这个节点 %d, 还在修改", newHeroNode.no);
}
}
public boolean isEmpty() {
return head.next == null;
}
/**
* 我写的删除
*
* @param no
*/
public void myRemove(int no) {
if (isEmpty()) {
System.out.println("链表为空");
return;
}
HeroNode temp = this.head;
while (temp.next != null) {
HeroNode next = temp.next;
if (next.no == no) {
temp.next = next.next;
next = null;
break;
}
temp = temp.next;
}
}
/**
* 删除节点，
* 1. head 不能动，因此需要一个 tmep 辅助节点找到待删除节点的前一个节点
* 2. 说明在比较时，是 temp.next.no 和需要删除节点的no 比较
*/
public void del(int no) {
HeroNode temp = head;
boolean flag = false;//标志是否找到待删除的节点
while (true) {
if (temp.next == null) {
//已经到链表的最后了
break;
}
if (temp.next.no == no) {
//找到待删除节点的前一个节点
flag = true;
break;
}
temp = temp.next;//temp 后移，遍历
}
if (flag) {
//找到
temp.next = temp.next.next;
} else {
System.out.println("要删除的节点不存在：" + no);
}
}
/**
* 显示链表
*/
public void list() {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头结点不能动，因此需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true) {
System.out.println(temp);
//判断是否到链表最后了
if (temp.next == null) {
break;
}
temp = temp.next;
}
}
public HeroNode getHead() {
return head;
}
}
//定义 HeroNode ， 每个 HeroNode，对象就是一个节点
class HeroNode {
public int no;
private String name;
private String nickname;
/**
* 指向下一个节点
*/
public HeroNode next;
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public HeroNode getNext() {
return next;
}
public void setNext(HeroNode next) {
this.next = next;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
单链表百度面试题
从尾到头打印单链表
思路：
- 上面的题的要求就是逆序打印单链表
- 方式1：先将单链表进行反转操作，然后再遍历即可，这样做的问题会破坏原来的单链表的结构，不建议
- 方式2：可以利用栈这个数据结构，将各个结点压入栈中，就实现了逆序打印的效果
新增加的代码
/**
* 自己编写的，通过数组实现
*/
public static void myReversePrint(HeroNode node){
if (node == null || node.next == null){
System.out.println("当前链表为空");
return;
}
HeroNode temp = node.next;
List<HeroNode> list = new ArrayList<>();
while (temp != null){
list.add(temp);
temp = temp.next;
}
for (int i = list.size() - 1; i >= 0; i--) {
System.out.println(list.get(i));
}
}
/**
* 使用方式2：可以利用这个栈这个数据结构，将各个节点压入到栈中，然后利用栈
* 先进后出的特点，就实现了逆序打印的效果
*/
public static void reversePrint(HeroNode head){
if (head == null){
System.out.println("空链表");
return;
}
//创建一个栈，将各个节点压入栈中
Stack<HeroNode> stack = new Stack<>();
HeroNode cur = head.next;
//将链表的所有节点，压入栈中
while (cur != null){
stack.add(cur);
cur = cur.next;
}
while (stack.size() > 0){
System.out.println(stack.pop());
}
}
全部代码
package com.old.linkedList_016_023;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;
public class SingleLinkedListDeme {
public static void main(String[] args) {
//测试
//创建节点
HeroNode node1 = new HeroNode(1, "宋江", "及时雨");
HeroNode node2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode node3 = new HeroNode(3, "吴用", "智多星");
HeroNode node4 = new HeroNode(4, "林冲", "豹子头");
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.add(node1);
singleLinkedList.add(node2);
singleLinkedList.add(node3);
singleLinkedList.add(node4);
singleLinkedList.list();
System.out.println("获取倒数的节点，我的方法:" + MyfindLastNode(singleLinkedList.getHead(), 5));
System.out.println("获取倒数的节点，视频的方法:" + findLastNode(singleLinkedList.getHead(), 5));
//清除
singleLinkedList.clear();
singleLinkedList.list();
singleLinkedList = new SingleLinkedList();
singleLinkedList.addByOrder(node2);
singleLinkedList.addByOrder(node1);
singleLinkedList.addByOrder(node4);
singleLinkedList.addByOrder(node3);
singleLinkedList.list();
singleLinkedList.update(6, "诸葛亮", "卧龙");
singleLinkedList.list();
HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
singleLinkedList.update(newHeroNode);
singleLinkedList.list();
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
System.out.println();
System.out.println("开始删除");
singleLinkedList.myRemove(9);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
System.out.println();
System.out.println("第二次删除");
singleLinkedList.myRemove(2);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
System.out.println();
System.out.println("第三次删除");
singleLinkedList.del(1);
singleLinkedList.del(4);
singleLinkedList.del(3);
System.out.println("节点长度：" + getLength(singleLinkedList.getHead()));
singleLinkedList.list();
singleLinkedList.addByOrder(node2);
singleLinkedList.addByOrder(node1);
singleLinkedList.addByOrder(node4);
singleLinkedList.addByOrder(node3);
singleLinkedList.list();
System.out.println();
System.out.println("开始反转：");
reversetList(singleLinkedList.getHead());
singleLinkedList.list();
System.out.println("开始逆向输出");
System.out.println("输出前");
singleLinkedList.list();
System.out.println("逆转输出");
myReversePrint(singleLinkedList.getHead());
System.out.println("视频方法逆向输出");
reversePrint(singleLinkedList.getHead());
}
/**
* 自己编写的，通过数组实现
*/
public static void myReversePrint(HeroNode node){
if (node == null || node.next == null){
System.out.println("当前链表为空");
return;
}
HeroNode temp = node.next;
List<HeroNode> list = new ArrayList<>();
while (temp != null){
list.add(temp);
temp = temp.next;
}
for (int i = list.size() - 1; i >= 0; i--) {
System.out.println(list.get(i));
}
}
/**
* 使用方式2：可以利用这个栈这个数据结构，将各个节点压入到栈中，然后利用栈
* 先进后出的特点，就实现了逆序打印的效果
*/
public static void reversePrint(HeroNode head){
if (head == null){
System.out.println("空链表");
return;
}
//创建一个栈，将各个节点压入栈中
Stack<HeroNode> stack = new Stack<>();
HeroNode cur = head.next;
//将链表的所有节点，压入栈中
while (cur != null){
stack.add(cur);
cur = cur.next;
}
while (stack.size() > 0){
System.out.println(stack.pop());
}
}
/**
* 将单链表进行返转
*
* @param head
*/
public static void reversetList(HeroNode head) {
//如果当前链表为空，或者只有一个节点，无需反转，直接返回
if (head.next == null || head.next.next == null) {
return;
}
//定义辅助的指针（变量），帮助遍历原来的链表
HeroNode cur = head.next;
HeroNode next = null;//指向当前节点 [cur] 的下一个节点
HeroNode reverseHead = new HeroNode(0, "", "");
/**
* 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表 reverseHead 的最前端
*/
while (cur != null) {
//先暂时保存当前节点的下一个节点，因为后面需要使用
next = cur.next;
/**
* 将 cur 的下一个节点指向新的链表的最前端
* 当前节点的下一个节点都是 reverseHead 的下一个节点
*
* 当前节点是下一个节点 的是 另一个链表的 头节点之后的数据
* 另一个链表的头节点每次放入的都是 当前节点的数据
* 这里缺少了
* 将 cur 连接到新的链表上
* 按照顺序遍历，每次取出当前的节点，然后将当前的节点放在一个链表的最后一个，
* 下次再取出当前的节点。我这个有点不对
*
* 重点是怎么换过来
*
* 将当前节点的下一个节点的为，另一个链表头节点之后的数据，
* 再将另一个链表 头节点之后的数据再换为当前节点的数据，这样就实现了替换
*/
cur.next = reverseHead.next;
reverseHead.next = cur;
cur = next;
}
//将 head.next 指向 reverseHead.next , 实现单链表的反转
head.next = reverseHead.next;
}
/**
* 查找单链表中倒数第k个结点 【新浪面试题】
* 1. 编写一个方法，接收 head 节点，同时接收 index，
* 2. index 表示倒数第index个节点
* 3. 先把链表从头到尾遍历，得到链表的总长度
* 4. 得到 size 后 ，从链表的第一个开始遍历，遍历 （size - index)个，就可以得到
* 5. 如果找到了返回该节点，否则返回空
* length - index 就是他的个数
*/
public static HeroNode findLastNode(HeroNode node, int index) {
int length = getLength(node);
if (length == 0) {
return null;
}
if (index >= length || index <= 0) {
System.out.println("超过链表中的节点个数");
return null;
}
HeroNode temp = node.next;
for (int i = 0; i < length - index; i++) {
temp = temp.next;
}
return temp;
}
/**
* 查找单链表中倒数第k个结点 【新浪面试题】
* 1. 编写一个方法，接收 head 节点，同时接收 index，
* 2. index 表示倒数第 index 个节点
* 3. 先把链表从头到尾遍历，得到链表的总长度
* 4. 得到 size 后 ，从链表的第一个开始遍历，将链表中所有的数据加入一个数组中，
* 5. length - index 就是他的个数 就是节点在数组的下标
*/
public static HeroNode MyfindLastNode(HeroNode node, int lastNum) {
int length = getLength(node);
if (length == 0) {
System.out.println("没有这个节点");
return null;
}
if (lastNum >= length || lastNum <= 0) {
System.out.println("超过链表中的节点个数");
return null;
}
HeroNode temp = node.next;
HeroNode[] heroNodes = new HeroNode[length];
for (int i = 0; i < heroNodes.length; i++) {
heroNodes[i] = temp;
temp = temp.next;
}
return heroNodes[length - lastNum];
}
/**
* 获取到单链表的节点的个数（如果是头节点的链表，需求不统计头节点
*
* @param node head 链表的头节点
* @return 返回有效结果的个数
*/
public static int getLength(HeroNode node) {
if (node.next == null) {
//空链表
return 0;
}
int length = 0;
/*
我这遍历的节点，都是有头节点的，所以直接取当前节点的下一个开始遍历
*/
HeroNode cur = node.next;
while (cur != null) {
length++;
cur = cur.next;
}
return length;
}
}
/**
* 定义 SinleLinkedList 管理英雄人物
*/
class SingleLinkedList {
/**
* 初始化头节点，头节点不要动
* 不放具体的数据
*/
private HeroNode head = new HeroNode(0, "", "");
/**
* 添加节点到单身链表
* 思路：
* 1.当不考虑编号的顺序时，找到当前链表的最后节点
* 2. 将最后这个节点的 next 指向新的节点
* <p>
* 目前这种链表是按照顺序添加的，不是按照编号进行排序
*/
public void add(HeroNode heroNode) {
//因为 head 节点不能动，因此需要一个辅助记功 temp
HeroNode temp = head;
//遍历链表，找到最后
while (true) {
//找到最后一个链表
if (temp.next == null) {
break;
}
//如果没有找到，就将 temp 后移
temp = temp.next;
}
/**
* 当退出while 循环时，temp 就指向了链表的最后
* 因为 head 是头节点，只会是第一个，所以直接 next 不行
*/
temp.next = heroNode;
}
/**
* 第二种添加英雄的方式，根据排名将英雄插入到指定位置
* 如果有这个排名，则添加失败，并给出提示
*/
public void addByOrder(HeroNode heroNode) {
/**
* 因为头节点不能动，因此仍然通过一个辅助指针（变量）来帮助找到添加的位置
* 因为单链表，因为我们找到的 temp ，是位于添加位置的前一个节点，否则插入不了
*
*/
HeroNode temp = head;
//标识添加的编号是否存在，默认为false
boolean flag = false;
while (true) {
if (temp.next == null) {
/*
说明 temp 已经在链表的最后
*/
break;
}
/**
* 位置找到了，就 temp 的后边插入
*/
if (temp.next.no > heroNode.no) {
break;
} else if (temp.next.no == heroNode.no) {
//说明希望添加的 heroNode 的编号已然存在了
flag = true;
break;
}
temp = temp.next;//后移，遍历当前的链表
}
/**
* 当跳出 while 循环之后
* 判断 flag 的值
*/
if (flag) {
//说明不能添加，编号存在
System.out.println("准备插入的英雄编号已经存在，不能加入: " + heroNode.no);
} else {
//插入到链表中
heroNode.next = temp.next;
temp.next = heroNode;
}
}
public void clear() {
HeroNode temp = head;
while (true) {
HeroNode node = temp.next;
if (node == null) {
break;
}
temp = node;
node = null;
}
head = new HeroNode(0, "", "");
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
* <p>
* 根据 new HeroNode 的 no来修改
* <p>
* 我写的
*/
public void update(int no, String name, String nickName) {
//判断是否为空
if (isEmpty()) {
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
HeroNode temp = head;
while (true) {
HeroNode next = temp.next;
if (next.no == no) {
next.setName(name);
next.setNickname(nickName);
break;
}
if (next.next == null) {
System.out.println("链表中没有这个节点：" + no);
break;
}
temp = temp.next;
}
}
/**
* 修改节点的信息，根据编号来修改，即 no 编号不能修改，
* no编号修改相添加
* <p>
* 根据 new HeroNode 的 no来修改
* <p>
* 视频代码
*/
public void update(HeroNode newHeroNode) {
//判断是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//找到需要修改的节点，根据 no 编号
//定义一个辅助变量
HeroNode temp = head;
boolean flag = false;
while (true) {
if (temp == null) {
break;//已经遍历完链表
}
if (temp.no == newHeroNode.no) {
//找到修改的节点
flag = true;
break;
}
temp = temp.next;
}
//根据 flag 判断是否找到要修改的节点
if (flag) {
temp.setName(newHeroNode.getName());
temp.setNickname(newHeroNode.getNickname());
} else {
System.out.printf("没有找到这个节点 %d, 还在修改", newHeroNode.no);
}
}
public boolean isEmpty() {
return head.next == null;
}
/**
* 我写的删除
*
* @param no
*/
public void myRemove(int no) {
if (isEmpty()) {
System.out.println("链表为空");
return;
}
HeroNode temp = this.head;
while (temp.next != null) {
HeroNode next = temp.next;
if (next.no == no) {
temp.next = next.next;
next = null;
break;
}
temp = temp.next;
}
}
/**
* 删除节点，
* 1. head 不能动，因此需要一个 tmep 辅助节点找到待删除节点的前一个节点
* 2. 说明在比较时，是 temp.next.no 和需要删除节点的no 比较
*/
public void del(int no) {
HeroNode temp = head;
boolean flag = false;//标志是否找到待删除的节点
while (true) {
if (temp.next == null) {
//已经到链表的最后了
break;
}
if (temp.next.no == no) {
//找到待删除节点的前一个节点
flag = true;
break;
}
temp = temp.next;//temp 后移，遍历
}
if (flag) {
//找到
temp.next = temp.next.next;
} else {
System.out.println("要删除的节点不存在：" + no);
}
}
/**
* 显示链表
*/
public void list() {
//判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
//因为头结点不能动，因此需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true) {
System.out.println(temp);
//判断是否到链表最后了
if (temp.next == null) {
break;
}
temp = temp.next;
}
}
public HeroNode getHead() {
return head;
}
}
//定义 HeroNode ， 每个 HeroNode，对象就是一个节点
class HeroNode {
public int no;
private String name;
private String nickname;
/**
* 指向下一个节点
*/
public HeroNode next;
public HeroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNickname() {
return nickname;
}
public void setNickname(String nickname) {
this.nickname = nickname;
}
public HeroNode getNext() {
return next;
}
public void setNext(HeroNode next) {
this.next = next;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
合并两个有序的单链表，合并之后的链表依然有序
原来的代码中已经有了，这里不写了，那个按照顺序添加方法。将两个链表遍历，一次遍历一个，然后加入一个新链表，原有的方法会对编号进行排序，所以这里不编写代码了
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
