单链表
- 单链表是一种链式存取的数据结构，用一组地址任意（不需要地址连续）的存储单元存放线性表中的数据元素，可以使用零碎的空间
- 链表中的数据是以节点来表示的，每个节点的构成：元素(数据元素的映象)+ 指针(指示后继元素存储位置)，元素就是存储数据的存储单元value，指针就是连接每个节点的地址数据next
- 单链表是单向的，当访问一个节点后，只能接着访问后继节点
- 单链表可以设置头节点，头节点为空
Java实现单链表
通过Java实现单链表，用于表示水浒传好汉：
- 设置对象HeroNode表示节点
- 设置链表对象SingleLinkedList，完成链表增加元素（顺序、非顺序）、遍历元素、更新元素、删除元素功能
节点对象：
设置四个成员变量，no、name、nickName类似与节点的value
next为指针
/**
*
* 每个HeroNode对象代表一个链表节点
*
*/
class HeroNode{
private int no;
public String name;
public String nickName;
//指向下一节点
private HeroNode next;
public HeroNode(int no, String name, String nickName) {
this.no = no;
this.name = name;
this.nickName = nickName;
}
public int getNo() {
return no;
}
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 + '\'' +
'}';
}
}
链表对象：
- 非顺序链表增加元素：找到当前链表的最后节点，将最后这个节点的next指向新节点
- 有序增加元素：通过辅助指针temp找到 插入位置， temp位于添加位置前一个节点
- 遍历链表
- 根据no修改节点信息
- 删除节点
/**
*
* 定义SingleLinkedList，管理英雄对象
*
*/
class SingleLinkedList{
//初始化一个头节点
private HeroNode head = new HeroNode(0,"","");
public HeroNode getHead() {
return head;
}
//添加节点到单向链表
// 1. 当不考虑编号顺序 思路 ： 找到当前链表的最后节点，将最后这个节点的next指向新节点
public void add(HeroNode node){
//需要一个辅助节点 遍历 链表
HeroNode temp = head;
//遍历链表，找到最后
while (true){
//最后的结点 next == null
if (temp.getNext() == null){
break;
}
temp = temp.getNext();
}
//当退出while循环时，temp指向链表最后节点
temp.setNext(node);
}
// 2. 在添加英雄时，根据排名将英雄插入到指定位置(如果存在该编号，添加失败)
public void addByOrder(HeroNode heroNode){
//通过辅助指针temp找到 插入位置， temp位于添加位置前一个节点
HeroNode temp = head;
//标识添加的编号是否存在
boolean flag = false;
while (true){
//如果temp在链表最后
if (temp.getNext() == null){
break;
}
//位置找到了，在temp的后面插入
if (temp.getNext().getNo() > heroNode.getNo()){
break;
}
else if (temp.getNext().getNo() == heroNode.getNo()){
//编号存在，插入失败
flag = true;
break;
}
//后移temp
temp = temp.getNext();
}
//判断flag
if (flag){
System.out.println("=== 准备插入的Hero编号"+heroNode.getNo()+"已存在 ===");
}
else {
//插入到链表中
heroNode.setNext(temp.getNext());
temp.setNext(heroNode);
}
}
//通过一个辅助变量 遍历 链表
public void list(){
//判断链表是否为空
if (head.getNext() == null){
System.out.println("=== 链表为空 ===");
return;
}
//需要一个辅助变量遍历
HeroNode temp = head.getNext();
while (true){
//输出节点信息
System.out.println(temp.toString());
//判断是否到链表最后
if (temp.getNext() == null){
break;
}
//将temp后移
temp = temp.getNext();
}
}
//根据no修改节点信息
public void update(HeroNode heroNode){
//判断是否为空
if (head.getNext() == null){
System.out.println("=== 链表为空 ===");
return;
}
//找到要修改的节点
HeroNode temp = head.getNext();
//表示是否找到该节点
boolean flag = false;
while (true){
//已经遍历完链表
if (temp == null){
break;
}
//找到该节点
if (temp.getNo() == heroNode.getNo()){
flag = true;
break;
}
temp = temp.getNext();
}
//根据 flag 判断要修改的节点
if (flag){
//因为temp获得的是对象的引用，可以直接修改
temp.name = heroNode.name;
temp.nickName = heroNode.nickName;
}else {
//没有找到
System.out.println("没有找到编号 = "+heroNode.getNo()+"不能修改");
}
}
/**
* 删除节点
* 1. 先找到要删除的节点的前一个节点 temp
* 2. temp.next = temp.next.nxet
* 3. 被删除的节点，不会其他引用指向，会被JVM垃圾回收
* */
public void delete(int no){
//辅助节点
HeroNode temp = head;
//是否找到待删除节点
boolean flag = false;
while (true){
//已经到链表的最后
if (temp.getNext() == null) {
break;
}
//如果找到带删除节点的前一个节点temp
if (temp.getNext().getNo() == no){
flag = true;
break;
}
//temp后移
temp = temp.getNext();
}
//判断flag
if (flag){
//找到，转移next指针
temp.setNext(temp.getNext().getNext());
}
else {
System.out.println("=== 没有找到该节点"+no+" ===");
}
}
}
测试：
public class SingleLinkedListDemo {
//测试
public static void main(String[] args) {
//创建节点
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
//创建链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
//加入
// singleLinkedList.add(hero1);
// singleLinkedList.add(hero2);
// singleLinkedList.add(hero3);
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
//遍历
singleLinkedList.list();
singleLinkedList.update(new HeroNode(3,"有用","智多星"));
System.out.println("=== 修改后 ===");
singleLinkedList.list();
System.out.println("=== 删除节点2 ===");
singleLinkedList.delete(2);
singleLinkedList.list();
System.out.println("=== 删除节点1 ===");
singleLinkedList.delete(1);
singleLinkedList.list();
System.out.println("=== 删除节点3 ===");
singleLinkedList.delete(3);
singleLinkedList.list();
}
}
求单链表中有效节点的个数
求有效节点个数：先排除头节点，设置计数器，然后遍历到temp.next == null即结束
/**
* @return
* 获得单链表的有效节点数(没有统计头节点)
*/
public static int getLength(HeroNode head){
int length = 0;
if (head.getNext() == null){
return length;
}
//定义一个辅助变量
HeroNode temp = head.getNext();
while (temp != null){
length++;
temp = temp.getNext();
}
return length;
}
查找倒数第k个数据
有两个方法：
- 可以使用暴力解法：先遍历一遍获得链表length，在直接找(length-lastIndex)个节点的next节点
- 可以简化，滑动窗口算法：定义两个指针，后一个指针延迟第一个指针lastIndex出发遍历，当第一个指针到达链表末尾，第二个指针指向的节点的next就是需要查找的节点
first指针先走lastIndex步，当first指针指向链表尾结束
这里通过滑动窗口算法解决：
/**
* 查找倒数第k个数据
* @param head 链表头节点
* @param lastIndex 倒数第k个节点
* 可以使用暴力解法：先遍历一遍获得链表length，在直接找(length-lastIndex)个节点的next节点
* 可以简化，滑动窗口算法：定义两个指针，后一个指针延迟第一个指针lastIndex出发遍历，
* 当第一个指针到达链表末尾，第二个指针指向的节点的next就是需要查找的节点
*/
public static HeroNode findLastIndexNode(HeroNode head,int lastIndex){
//滑动窗口算法
//前后指针
HeroNode first = head;
HeroNode second = head;
//first指针先走lastIndex距离
for (int i = 0;i < lastIndex;i++){
first = first.getNext();
}
//两个指针一起走，当first指针指向链表末尾结束
while (first.getNext() != null){
first = first.getNext();
second = second.getNext();
}
//需要的是second.next
return second.getNext();
}
测试：
HeroNode lastIndexNode = findLastIndexNode(singleLinkedList.getHead(), 2);
System.out.println("=== 查找倒数第2个Hero ===");
System.out.println(lastIndexNode);
反转链表
实现思路：
创建一个新的链表头，遍历原始的链表，每遍历一个节点，将节点取出设置为新表头的next，直到遍历完原始链表
/**
* 反转链表
* @param head 待反转的链表头节点
* 实现思路：1.遍历链表时，取出每一个节点，逆序创建新链表
* 2.多次遍历（不可取）
*/
public static void reverseList(HeroNode head){
//如果当前链表为空，或者只有一个节点，无需反转
if (head.getNext() == null || head.getNext().getNext() == null){
return;
}
//定义一个辅助指针
HeroNode temp = head.getNext();
//指向当前节点的下一个节点
HeroNode next = null;
//新链表的头节点
HeroNode reverseHead = new HeroNode(0,"","");
//从头到尾遍历原来的链表，每遍历一个节点，取出放到新链表reverseHead 的后一位
while (temp != null){
//先暂时保存当前节点的下一节点
next = temp.getNext();
//将temp的下一节点指向新链表的头节点后
temp.setNext(reverseHead.getNext());
// 让temp连接到reverseHead
reverseHead.setNext(temp);
//遍历原来的链表：temp后移
temp = next;
}
//将head.next 指向 reverseHead.next，实现单链表的反转
head.setNext(reverseHead.getNext());
}
测试：
System.out.println("=== 原来的链表 ===");
singleLinkedList.list();
System.out.println("=== 反转后的链表 ===");
reverseList(singleLinkedList.getHead());
singleLinkedList.list();
从尾到头打印单链表
从尾到头打印单链表可以分为是否破坏原有链表：
- 反转链表，再遍历就是从尾到头打印
- 利用栈，遍历链表，压入栈，在出栈打印
/**
* 从尾到头打印单链表
* @param head 原始单链表 头节点
* 思路：1. 通过反转单链表，再打印，但是会破坏原有链表的结构
* 2. 利用栈数据结构，遍历时将节点压入栈，利于先进后出实现逆序打印
*
* 使用栈实现
*/
public static void reversePrint(HeroNode head){
//如果单链表为空
if (head.getNext() == null){
System.out.println("=== 链表为空 ===");
return;
}
//创建一个栈
Stack<HeroNode> stack = new Stack<>();
//辅助变量
HeroNode temp = head.getNext();
//遍历时将节点压入栈
while (temp != null){
//压栈
stack.push(temp);
//后移temp
temp = temp.getNext();
}
//将栈中的节点进行打印
while (stack.size() > 0){
System.out.println(stack.pop());
}
}
测试：
public static void main(String[] args) {
//创建节点
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
//创建链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero1);
singleLinkedList.addByOrder(hero4);
singleLinkedList.list();
System.out.println("=== 逆序打印单链表 ===");
reversePrint(singleLinkedList.getHead());
}
合并两个有序链表，合并后链表也有序
利用最开始的有序插入数据的方法即可完成，需要注意设置一个next辅助变量
先存储当前节点temp的后一节点，在插入排序，然后temp后移，因为在插入排序时会把temp的next设置为新链表插入位置的后续
/**
* 合并两个有序链表，合并后链表也有序
* @param firstHead 第一个链表的头节点
* @param secondHead 第二个链表的头节点
*
* 思路：1. 以第一个链表为基准，遍历第二个链表，一个一个插入第一个链表
* 2. 创建新的链表，原始链表1,2通过不断比较插入，当一个链表插入完，查看两个链表是否剩下，如果剩下就直接全部插入新链表
*
* 实现方案1
*/
public static void combineLinkedList(HeroNode firstHead,HeroNode secondHead){
//判断是否为空
if (firstHead.getNext() == null || secondHead.getNext() == null){
System.out.println("=== 链表为空，不需要合并 ===");
return;
}
//以firstHead链表为基准
//辅助变量
HeroNode temp = secondHead.getNext();
HeroNode next = null;
while (temp != null) {
next = temp.getNext();
//有序插入方法addByOrder
addByOrder(firstHead, temp);
//temp后移
temp = next;
}
}
// 有序插入
public static void addByOrder(HeroNode head,HeroNode heroNode){
//通过辅助指针temp找到 插入位置， temp位于添加位置前一个节点
HeroNode temp = head;
//标识添加的编号是否存在
boolean flag = false;
while (true){
//如果temp在链表最后
if (temp.getNext() == null){
break;
}
//位置找到了，在temp的后面插入
if (temp.getNext().getNo() > heroNode.getNo()){
break;
}
else if (temp.getNext().getNo() == heroNode.getNo()){
//编号存在，插入失败
flag = true;
break;
}
//后移temp
temp = temp.getNext();
}
//判断flag
if (flag){
System.out.println("=== 准备插入的Hero编号"+heroNode.getNo()+"已存在 ===");
}
else {
//插入到链表中
heroNode.setNext(temp.getNext());
temp.setNext(heroNode);
}
}
测试：
@Test
public void test(){
//创建节点
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
HeroNode hero5 = new HeroNode(5, "花荣", "小李广");
//创建链表
SingleLinkedList singleLinkedList1 = new SingleLinkedList();
SingleLinkedList singleLinkedList2 = new SingleLinkedList();
singleLinkedList1.add(hero1);
singleLinkedList1.add(hero4);
System.out.println("=== singleLinkedList1 ===");
singleLinkedList1.list();
singleLinkedList2.add(hero2);
singleLinkedList2.add(hero3);
singleLinkedList2.add(hero5);
System.out.println("=== singleLinkedList2 ===");
singleLinkedList2.list();
System.out.println("=== 合并后 ===");
combineLinkedList(singleLinkedList1.getHead(),singleLinkedList2.getHead());
singleLinkedList1.list();
}
502
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
