单向链表的实现与常见操作

单链表的定义:

一个线性表由若干个结点组成，每个结 点均含有两个域：存放元素的信息域和存放其后继结点的指针域，这样就形成一个单向链接式存储结构，简称单向链表或单链表。

(a1, a2 ,a3, a4)的存储示意图：

存储结构特点：

• 逻辑次序和物理次序不一定相同；
• 元素之间的逻辑关系用指针表示；
• 需要额外空间存储元素之间的关系
• 非随机访问存取结构（顺序访问）

逻辑结构示意图：

先定义一个测试链表结构如下：

英雄节点：

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;
    }
    //为了显示方法，我们重新toString
    @Override
    public String toString() {
    
    
        return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
    }

对链表的操作如下：

1.添加数据到单向链表，直接添加到表尾

//添加数据到单向链表，添加到表尾
    public void add(HeroNode node) {
    
    
        //因为head结点不能动，因此我们需要一个辅助变量temp
        HeroNode temp = head;
        //遍历链表找到最后
        while (true) {
    
    
            //找到链表最后
            if (temp.next == null) {
    
    
                break;
            }
            //如果没有找到最后，则将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个结点的next指向新节点
        temp.next = node;

    }

2.第二种方式在添节点时，根据排名将英雄插入到指定位置
(如果有这个排名，则添加失败，并给出提示)

//第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    //(如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode) {
    
    
        //因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        //因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false; // flag标志添加的编号是否存在，默认为false
        while (true) {
    
    
            if (temp.next == null) {
    
    //说明链表已经遍历完了
                break;
            }
            if (temp.next.no > heroNode.no) {
    
    //找到位置
                break;
            } else if (temp.no == heroNode.no) {
    
     //说明希望添加的编号已经存在
                flag = true;
                break;
            }
            temp = temp.next;//后移
        }
        if (flag) {
    
    
            System.out.printf("准备插入的节点编号%d已经存在 ，不能在加入", heroNode.no);
        } else {
    
    
            //插入到链表中,temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

3.显示遍历链表

   //显示遍历链表
    public void list() {
    
    
        //先判断是否为空
        if (head.next == null) {
    
    
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head.next;
        while (true) {
    
    
            //判断链表是否为空
            if (temp == null) {
    
    
                break;
            }
            //输出结点信息
            System.out.println(temp.toString());
            //将temp后移
            temp = temp.next;
        }
    }

4.修改节点的信息
根据no编号来修改，即no编号不能改.
说明

1. 根据 newHeroNode 的 no 来修改即可

 //修改节点的信息, 根据no编号来修改，即no编号不能改.
    //说明
    //1. 根据 newHeroNode 的 no 来修改即可
    public void update(HeroNode newHeroNode) {
    
    
        //判断是否空
        if (head.next == null) {
    
    
            System.out.println("链表为空~");
            return;
        }
        //找到需要修改的节点, 根据no编号
        //定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag = false; //表示是否找到该节点
        while(true) {
    
    
            if (temp == null) {
    
    
                break; //已经遍历完链表
            }
            if(temp.no == newHeroNode.no) {
    
    
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag 判断是否找到要修改的节点
        if(flag) {
    
    
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
    
     //没有找到
            System.out.printf("没有找到 编号 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

5.删除节点
思路

1. head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
2. 说明我们在比较时，是temp.next.no 和 需要删除的节点的no比较
3. 删除时 temp.next = temp.next.next;，即移向下一个节点，空闲节点会被垃圾回收器回收，c/c++需要手动释放内存

//删除节点
    //思路
    //1. head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //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) {
    
    
                //找到的待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next; //temp后移，遍历
        }
        //判断flag
        if(flag) {
    
     //找到
            //可以删除
            temp.next = temp.next.next;
        }else {
    
    
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }

6.获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)

  //方法：获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
    public int getLength() {
    
    
        if(head.next == null) {
    
     //空链表
            return 0;
        }
        int length = 0;
        //定义一个辅助的变量, 这里我们没有统计头节点
        HeroNode cur = head.next;
        while(cur != null) {
    
    
            length++;
            cur = cur.next; //遍历
        }
        return length;
    }

7.查找单链表中的倒数第k个结点
思路

1. 编写一个方法，接收head节点，同时接收一个index
2. index 表示是倒数第index个节点
3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得
5. 如果找到了，则返回该节点，否则返回nulll

 //查找单链表中的倒数第k个结点
    //思路
    //1. 编写一个方法，接收head节点，同时接收一个index
    //2. index 表示是倒数第index个节点
    //3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
    //4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得
    //5. 如果找到了，则返回该节点，否则返回nulll
    public  HeroNode findLastIndexNode(int index) {
    
    
        //判断如果链表为空，返回null
        if(head.next == null) {
    
    
            return null;//没有找到
        }
        //第一个遍历得到链表的长度(节点个数)
        int size = getLength();
        //第二次遍历  size-index 位置，就是我们倒数的第K个节点
        //先做一个index的校验
        if(index <=0 || index > size) {
    
    
            return null;
        }
        //定义给辅助变量， for 循环定位到倒数的index
        HeroNode cur = head.next; //3 // 3 - 1 = 2
        for(int i =0; i< size - index; i++) {
    
    
            cur = cur.next;
        }
        return cur;
    }

8.将单链表反转
思路:

1. 先定义一个节点 reverseHead = new HeroNode();
2. 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端.
3. 原来的链表的head.next = reverseHead.next

//将单链表反转
    //思路:
    //1. 先定义一个节点 reverseHead = new HeroNode();
    //2. 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端.
    //3. 原来的链表的head.next = reverseHead.next
    public void reversetList() {
    
    
        //如果当前链表为空，或者只有一个节点，无需反转，直接返回
        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.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
            reverseHead.next = cur; //将cur 连接到新的链表上
            cur = next;//让cur后移
        }
        //将head.next 指向 reverseHead.next , 实现单链表的反转
        head.next = reverseHead.next;

    }

9.逆序打印单链表
方式1： 先将单链表进行反转操作，然后再遍历即可，这样的做的问题是会破坏原来的单链表的结构，不建议
方式2：不破坏原来链表的结构
可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果

 //逆序打印单链表
    //方式1： 先将单链表进行反转操作，然后再遍历即可，这样的做的问题是会破坏原来的单链表的结构，不建议
    //方式2：不破坏原来链表的结构
    //可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果
    public  void reversePrint() {
    
    
        if(head.next == null) {
    
    
            return;//空链表，不能打印
        }
        //创建要给一个栈，将各个节点压入栈
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur = head.next;
        //将链表的所有节点压入栈
        while(cur != null) {
    
    
            stack.push(cur);
            cur = cur.next; //cur后移，这样就可以压入下一个节点
        }
        //将栈中的节点进行打印,pop 出栈
        while (stack.size() > 0) {
    
    
            System.out.println(stack.pop()); //stack的特点是先进后出
        }
    }

10.合并两个有序的单链表，合并之后的链表依然有序

 //合并两个有序的单链表，合并之后的链表依然有序
    public HeroNode orderByTwoList(HeroNode node1,HeroNode node2){
    
    
        if(node1.next ==null){
    
    
            return node2;
        }
        if(node2.next ==null){
    
    
            return node1;
        }
        HeroNode newhead = new HeroNode(0, "","");
        //定义一个辅助的指针(变量)，帮助我们遍历原来的链表
        HeroNode headtemp = newhead;
        if(!(node1.next ==null&&node2.next ==null)){
    
    //如果两个链表都不为空
            //定义辅助的指针(变量)，帮助我们遍历原来的链表
            HeroNode temp1 = node1.next;
            HeroNode temp2 = node2.next;
            while (temp1!=null&&temp2!=null){
    
    //类似于归并
                if(temp1.no<=temp2.no){
    
    
                    headtemp.next = temp1;
                    headtemp = headtemp.next;
                    temp1 = temp1.next;
                }else {
    
    
                    headtemp.next = temp2;
                    headtemp = headtemp.next;
                    temp2 = temp2.next;
                }
            }
            if(temp1!=null){
    
    //第一个链表有剩余，将后面的剩余节点直接加到尾部
                headtemp.next = temp1;
                headtemp = headtemp.next;
                temp1 = temp1.next;
            }
            if(temp2!=null){
    
    //第二个链表有剩余，
                headtemp.next = temp2;
                headtemp = headtemp.next;
                temp2 = temp2.next;
            }

        }
           return newhead;
    }

完整代码如下：

import java.util.Stack;

/**
 * @anthor longzx
 * @create 2021 01 22 23:25
 * @Description
 **/
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(hero4);
        //singleLinkedList.add(hero2);
        //singleLinkedList.add(hero3);
        //加入按照编号的顺序
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);
        //显示一把
        System.out.println("原来链表的情况~~");
        singleLinkedList.list();
        System.out.println(singleLinkedList.getLength());
        System.out.println(singleLinkedList.findLastIndexNode(2));
        //singleLinkedList.reversetList();
        //System.out.println("翻转后的链表~~");
        //singleLinkedList.list();
        System.out.println("倒叙打印链表~~");
        singleLinkedList.reversePrint();

        //测试链表合并


    }
}
class SingleLinkedList {
    
    
    //先初始化一个头结点，头结点不要动，不存放具体的数据
    private HeroNode head = new HeroNode(0, "", "");

    //添加数据到单向链表，添加到表尾
    public void add(HeroNode node) {
    
    
        //因为head结点不能动，因此我们需要一个辅助变量temp
        HeroNode temp = head;
        //遍历链表找到最后
        while (true) {
    
    
            //找到链表最后
            if (temp.next == null) {
    
    
                break;
            }
            //如果没有找到最后，则将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个结点的next指向新节点
        temp.next = node;

    }

    //第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    //(如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode) {
    
    
        //因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
        //因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false; // flag标志添加的编号是否存在，默认为false
        while (true) {
    
    
            if (temp.next == null) {
    
    //说明链表已经遍历完了
                break;
            }
            if (temp.next.no > heroNode.no) {
    
    //找到位置
                break;
            } else if (temp.no == heroNode.no) {
    
     //说明希望添加的编号已经存在
                flag = true;
                break;
            }
            temp = temp.next;//后移
        }
        if (flag) {
    
    
            System.out.printf("准备插入的节点编号%d已经存在 ，不能在加入", heroNode.no);
        } else {
    
    
            //插入到链表中,temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //显示遍历链表
    public void list() {
    
    
        //先判断是否为空
        if (head.next == null) {
    
    
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head.next;
        while (true) {
    
    
            //判断链表是否为空
            if (temp == null) {
    
    
                break;
            }
            //输出结点信息
            System.out.println(temp.toString());
            //将temp后移
            temp = temp.next;
        }
    }




    //修改节点的信息, 根据no编号来修改，即no编号不能改.
    //说明
    //1. 根据 newHeroNode 的 no 来修改即可
    public void update(HeroNode newHeroNode) {
    
    
        //判断是否空
        if (head.next == null) {
    
    
            System.out.println("链表为空~");
            return;
        }
        //找到需要修改的节点, 根据no编号
        //定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag = false; //表示是否找到该节点
        while(true) {
    
    
            if (temp == null) {
    
    
                break; //已经遍历完链表
            }
            if(temp.no == newHeroNode.no) {
    
    
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag 判断是否找到要修改的节点
        if(flag) {
    
    
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        } else {
    
     //没有找到
            System.out.printf("没有找到 编号 %d 的节点，不能修改\n", newHeroNode.no);
        }
    }

    //删除节点
    //思路
    //1. head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //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) {
    
    
                //找到的待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next; //temp后移，遍历
        }
        //判断flag
        if(flag) {
    
     //找到
            //可以删除
            temp.next = temp.next.next;
        }else {
    
    
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }


    //方法：获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
    public int getLength() {
    
    
        if(head.next == null) {
    
     //空链表
            return 0;
        }
        int length = 0;
        //定义一个辅助的变量, 这里我们没有统计头节点
        HeroNode cur = head.next;
        while(cur != null) {
    
    
            length++;
            cur = cur.next; //遍历
        }
        return length;
    }

    //查找单链表中的倒数第k个结点
    //思路
    //1. 编写一个方法，接收head节点，同时接收一个index
    //2. index 表示是倒数第index个节点
    //3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
    //4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得
    //5. 如果找到了，则返回该节点，否则返回nulll
    public  HeroNode findLastIndexNode(int index) {
    
    
        //判断如果链表为空，返回null
        if(head.next == null) {
    
    
            return null;//没有找到
        }
        //第一个遍历得到链表的长度(节点个数)
        int size = getLength();
        //第二次遍历  size-index 位置，就是我们倒数的第K个节点
        //先做一个index的校验
        if(index <=0 || index > size) {
    
    
            return null;
        }
        //定义给辅助变量， for 循环定位到倒数的index
        HeroNode cur = head.next; //3 // 3 - 1 = 2
        for(int i =0; i< size - index; i++) {
    
    
            cur = cur.next;
        }
        return cur;
    }

    //将单链表反转
    //思路:
    //1. 先定义一个节点 reverseHead = new HeroNode();
    //2. 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端.
    //3. 原来的链表的head.next = reverseHead.next
    public void reversetList() {
    
    
        //如果当前链表为空，或者只有一个节点，无需反转，直接返回
        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.next = reverseHead.next;//将cur的下一个节点指向新的链表的最前端
            reverseHead.next = cur; //将cur 连接到新的链表上
            cur = next;//让cur后移
        }
        //将head.next 指向 reverseHead.next , 实现单链表的反转
        head.next = reverseHead.next;

    }

    //逆序打印单链表
    //方式1： 先将单链表进行反转操作，然后再遍历即可，这样的做的问题是会破坏原来的单链表的结构，不建议
    //方式2：不破坏原来链表的结构
    //可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果
    public  void reversePrint() {
    
    
        if(head.next == null) {
    
    
            return;//空链表，不能打印
        }
        //创建要给一个栈，将各个节点压入栈
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode cur = head.next;
        //将链表的所有节点压入栈
        while(cur != null) {
    
    
            stack.push(cur);
            cur = cur.next; //cur后移，这样就可以压入下一个节点
        }
        //将栈中的节点进行打印,pop 出栈
        while (stack.size() > 0) {
    
    
            System.out.println(stack.pop()); //stack的特点是先进后出
        }
    }

    //合并两个有序的单链表，合并之后的链表依然有序
    public HeroNode orderByTwoList(HeroNode node1,HeroNode node2){
    
    
        if(node1.next ==null){
    
    
            return node2;
        }
        if(node2.next ==null){
    
    
            return node1;
        }
        HeroNode newhead = new HeroNode(0, "","");
        //定义一个辅助的指针(变量)，帮助我们遍历原来的链表
        HeroNode headtemp = newhead;
        if(!(node1.next ==null&&node2.next ==null)){
    
    //如果两个链表都不为空
            //定义辅助的指针(变量)，帮助我们遍历原来的链表
            HeroNode temp1 = node1.next;
            HeroNode temp2 = node2.next;
            while (temp1!=null&&temp2!=null){
    
    //类似于归并
                if(temp1.no<=temp2.no){
    
    
                    headtemp.next = temp1;
                    headtemp = headtemp.next;
                    temp1 = temp1.next;
                }else {
    
    
                    headtemp.next = temp2;
                    headtemp = headtemp.next;
                    temp2 = temp2.next;
                }
            }
            if(temp1!=null){
    
    //第一个链表有剩余，将后面的剩余节点直接加到尾部
                headtemp.next = temp1;
                headtemp = headtemp.next;
                temp1 = temp1.next;
            }
            if(temp2!=null){
    
    //第二个链表有剩余，
                headtemp.next = temp2;
                headtemp = headtemp.next;
                temp2 = temp2.next;
            }

        }
           return newhead;
    }

}
//定义HeroNode ， 每个HeroNode 对象就是一个节点
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;
    }
    //为了显示方法，我们重新toString
    @Override
    public String toString() {
    
    
        return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
    }

}