数据结构之单链表超详细

已于 2022-06-06 07:50:42 修改
阅读量989 收藏 3
点赞数 6
分类专栏： 数据结构与算法Java 文章标签： 链表 数据结构 java
于 2022-06-05 19:41:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiangjunyes/article/details/125126033
版权

目录

单链表介绍和内存布局

链表是有序的列表，它在内存中存储结构如下：
下图是带头结点的链表
在这里插入图片描述

简单的描述一下：
头指针head 指向地址150的data域a1，a1的next域指向110的地址的data域a2,，依次类推。

从上图我们可以得到如下信息：

  • 链表是以节点的方式来存储,是链式存储。
  • 每个节点包含data域，next域:指向下一个节点。
  • 如上图:发现链表的各个节点不一定是连续存储。
  • 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。

单链表(带头结点）逻辑结构示意图如下：

在这里插入图片描述

单链表的应用实例

使用带 head头的单向链表实现–水浒英雄排行榜管理完成对英雄人物的增删改查操作。

单链表的创建和和遍历分析

在这里插入图片描述

单链表的创建和和遍历代码

package LinkList;

/**
 * 单链表
 */
public class SingleLinkListTest {

    public static void main(String[] args) {
        SingleLinkList singleLinkList = new SingleLinkList();
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(3,"鲁智深","花和尚");
        singleLinkList.insert(heroNode1);
        singleLinkList.insert(heroNode2);
        singleLinkList.insert(heroNode3);

        singleLinkList.show();
    }
}

/**
 * 定义SingleLinkList管理 管理节点
 */
class SingleLinkList{

    /**
     * 初始化一个头结点,不存放具体的数据。
     */
    private HeroNode head = new HeroNode(0,"","");

    /**
     * 添加结点
     *
     * 不考虑当前编号，找到当前链表的最后一个节点，最后一个节点为NULL。
     * 将最后这个节点的next 指向新的节点。
     */
    public void insert(HeroNode heroNode){
        //因为头结点不动，我们需要一个辅助遍历
        HeroNode temp = head;

        //遍历链表
        while (true){
            //当temp的next==null 则找到了最后一个节点。
            if (temp.next == null){
                break;
            }
            //若没有找到，就将temp后移下一个节点
            temp = temp.next;
        }
        //退出循环时，temp指向了链表的最后,就可以将这个节点的next，指向新的节点。
        temp.next = heroNode;
    }

    /**
     * 遍历链表
     */
    public void show(){
        //通过一辅助遍历 遍历整个链表。
        //判断链表是否为空
        if (isEmpty()){
            System.out.println("链表当前没有元素");
            return;
        }
        HeroNode temp = head.next;
        while (true){
            // 是否到了最后一个节点
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

    /**
     * 链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return head.next == null;
    }

}


/**
 * 定义HeroNode 每个HeroNode 对象就是一个节点
 */
class HeroNode{
    /**
     * 编号
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 昵称
     */
    public String nickName;
    /**
     * 指向下一个节点
     */
    public HeroNode next;

    /**
     * 构造器
     * @param no 编号
     * @param name 名字
     * @param nickName 昵称
     */
    public HeroNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

}

输出结果
在这里插入图片描述
目前insert插入没有考虑编号，怎么根据no排序了？

单链表按顺序插入节点

添加结点的时候，根据排名将结点插入到指定的位置（如果这个位置有人，则添加失败，并提示。）
在这里插入图片描述

代码实现

package LinkList;

import java.awt.image.BufferStrategy;
import java.beans.beancontext.BeanContext;

/**
 * 单链表
 */
public class SingleLinkListTest {

    public static void main(String[] args) {
        SingleLinkList singleLinkList = new SingleLinkList();
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(6,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(5,"鲁智深","花和尚");
        HeroNode heroNode4 = new HeroNode(4,"杨志","青面兽");
        HeroNode heroNode5 = new HeroNode(2,"吴用","智多星");

       /* singleLinkList.insert(heroNode1);
        singleLinkList.insert(heroNode2);
        singleLinkList.insert(heroNode3);*/

        singleLinkList.insertByOrder(heroNode1);
        singleLinkList.insertByOrder(heroNode2);
        singleLinkList.insertByOrder(heroNode3);
        singleLinkList.insertByOrder(heroNode4);
        singleLinkList.insertByOrder(heroNode5);

        singleLinkList.show();
    }
}

/**
 * 定义SingleLinkList管理 管理节点
 */
class SingleLinkList{

    /**
     * 初始化一个头结点,不存放具体的数据。
     */
    private HeroNode head = new HeroNode(0,"","");

    /**
     * 添加结点
     *
     * 不考虑当前编号，找到当前链表的最后一个节点，最后一个节点为NULL。
     * 将最后这个节点的next 指向新的节点。
     */
    public void insert(HeroNode heroNode){
        //因为头结点不动，我们需要一个辅助遍历
        HeroNode temp = head;

        //遍历链表
        while (true){
            //当temp的next==null 则找到了最后一个节点。
            if (temp.next == null){
                break;
            }
            //若没有找到，就将temp后移下一个节点
            temp = temp.next;
        }
        //退出循环时，temp指向了链表的最后,就可以将这个节点的next，指向新的节点。
        temp.next = heroNode;
    }

    /**
     * 按照no大小按升序序插入节点
     * @param heroNode
     */
    public void insertByOrder(HeroNode heroNode){
        //因为头结点不动，需要借助一个辅助，来帮助找到合适添加位置
        //单链表，temp是位于添加位置的前一个结点，否则插入失败， 因为我们可以根据上一个结点找到下一个节点位置，但是不能根据下一个节点找到上一个结点位置。
        HeroNode temp = head;
        // 添加no是否存在，默认为false
        boolean flag = false;

        while (true){
            // 找到链表结尾
            if (temp.next == null){
                break;
            }
            // 找到插入位置，就在temp的后面
            if (temp.next.no > heroNode.no){
                break;
            }else if (temp.next.no == heroNode.no){ //要添加的no已经存在
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }

        if (flag){
            throw new RuntimeException("待插入的编号："+ heroNode.no + "，已经存在，插入失败。");
        }else {
            //将结点插入到链表，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    /**
     * 遍历链表
     */
    public void show(){
        //通过一辅助遍历 遍历整个链表。
        //判断链表是否为空
        if (isEmpty()){
            System.out.println("链表当前没有元素");
            return;
        }
        HeroNode temp = head.next;
        while (true){
            // 是否到了最后一个节点
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

    /**
     * 链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return head.next == null;
    }

}


/**
 * 定义HeroNode 每个HeroNode 对象就是一个节点
 */
class HeroNode{
    /**
     * 编号
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 昵称
     */
    public String nickName;
    /**
     * 指向下一个节点
     */
    public HeroNode next;

    /**
     * 构造器
     * @param no 编号
     * @param name 名字
     * @param nickName 昵称
     */
    public HeroNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

}

输出结果
在这里插入图片描述

单链表结点的修改

修改结点的数据信息根据编号no来修改。

package LinkList;

import java.awt.image.BufferStrategy;
import java.beans.beancontext.BeanContext;

/**
 * 单链表
 */
public class SingleLinkListTest {

    public static void main(String[] args) {
        SingleLinkList singleLinkList = new SingleLinkList();
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(6,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(5,"鲁智深","花和尚");
        HeroNode heroNode4 = new HeroNode(4,"杨志","青面兽");
        HeroNode heroNode5 = new HeroNode(2,"吴用","智多星");

       /* singleLinkList.insert(heroNode1);
        singleLinkList.insert(heroNode2);
        singleLinkList.insert(heroNode3);*/

        //测试按照编号升序插入
        singleLinkList.insertByOrder(heroNode1);
        singleLinkList.insertByOrder(heroNode2);
        singleLinkList.insertByOrder(heroNode3);
        singleLinkList.insertByOrder(heroNode4);
        singleLinkList.insertByOrder(heroNode5);
        //测试修改
        HeroNode heroNode6 = new HeroNode(2,"吴用","大笨蛋");
        singleLinkList.update(heroNode6);
        
        singleLinkList.show();
    }
}

/**
 * 定义SingleLinkList管理 管理节点
 */
class SingleLinkList{

    /**
     * 初始化一个头结点,不存放具体的数据。
     */
    private HeroNode head = new HeroNode(0,"","");

    /**
     * 添加结点
     *
     * 不考虑当前编号，找到当前链表的最后一个节点，最后一个节点为NULL。
     * 将最后这个节点的next 指向新的节点。
     */
    public void insert(HeroNode heroNode){
        //因为头结点不动，我们需要一个辅助遍历
        HeroNode temp = head;

        //遍历链表
        while (true){
            //当temp的next==null 则找到了最后一个节点。
            if (temp.next == null){
                break;
            }
            //若没有找到，就将temp后移下一个节点
            temp = temp.next;
        }
        //退出循环时，temp指向了链表的最后,就可以将这个节点的next，指向新的节点。
        temp.next = heroNode;
    }

    /**
     * 按照no大小按升序序插入节点
     * @param heroNode
     */
    public void insertByOrder(HeroNode heroNode){
        //因为头结点不动，需要借助一个辅助，来帮助找到合适添加位置
        //单链表，temp是位于添加位置的前一个结点，否则插入失败， 因为我们可以根据上一个结点找到下一个节点位置，但是不能根据下一个节点找到上一个结点位置。
        HeroNode temp = head;
        // 添加no是否存在，默认为false
        boolean flag = false;

        while (true){
            // 找到链表结尾
            if (temp.next == null){
                break;
            }
            // 找到插入位置，就在temp的后面
            if (temp.next.no > heroNode.no){
                break;
            }else if (temp.next.no == heroNode.no){ //要添加的no已经存在
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }

        if (flag){
            throw new RuntimeException("待插入的编号："+ heroNode.no + "，已经存在，插入失败。");
        }else {
            //将结点插入到链表，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }


    /**
     * 根据结点的编号no来修改结点data信息
     * @param newHeroNode
     */
    public void update(HeroNode newHeroNode){


        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        //找到需要修改修改的结点
        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为true找到该结点，修改结点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        }else {
            throw  new RuntimeException("当前链表没有结点no = "+ newHeroNode.no);
        }
    }

    /**
     * 遍历链表
     */
    public void show(){
        //通过一辅助遍历 遍历整个链表。
        //判断链表是否为空
        if (isEmpty()){
            System.out.println("链表当前没有元素");
            return;
        }
        HeroNode temp = head.next;
        while (true){
            // 是否到了最后一个节点
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

    /**
     * 链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return head.next == null;
    }

}


/**
 * 定义HeroNode 每个HeroNode 对象就是一个节点
 */
class HeroNode{
    /**
     * 编号
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 昵称
     */
    public String nickName;
    /**
     * 指向下一个节点
     */
    public HeroNode next;

    /**
     * 构造器
     * @param no 编号
     * @param name 名字
     * @param nickName 昵称
     */
    public HeroNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

}

输出结果
在这里插入图片描述

删除结点

删除结点的操作其实和修改操作比较类似。
在这里插入图片描述

package LinkList;

import java.awt.image.BufferStrategy;
import java.beans.beancontext.BeanContext;

/**
 * 单链表
 */
public class SingleLinkListTest {

    public static void main(String[] args) {
        SingleLinkList singleLinkList = new SingleLinkList();
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(6,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(5,"鲁智深","花和尚");
        HeroNode heroNode4 = new HeroNode(4,"杨志","青面兽");
        HeroNode heroNode5 = new HeroNode(2,"吴用","智多星");

       /* singleLinkList.insert(heroNode1);
        singleLinkList.insert(heroNode2);
        singleLinkList.insert(heroNode3);*/

        //测试按照编号升序插入
        singleLinkList.insertByOrder(heroNode1);
        singleLinkList.insertByOrder(heroNode2);
        singleLinkList.insertByOrder(heroNode3);
        singleLinkList.insertByOrder(heroNode4);
        singleLinkList.insertByOrder(heroNode5);
        //测试修改
        HeroNode heroNode6 = new HeroNode(2,"吴用","大笨蛋");
        singleLinkList.update(heroNode6);

        singleLinkList.delete(2);

        singleLinkList.show();
    }
}

/**
 * 定义SingleLinkList管理 管理节点
 */
class SingleLinkList{

    /**
     * 初始化一个头结点,不存放具体的数据。
     */
    private HeroNode head = new HeroNode(0,"","");

    /**
     * 添加结点
     *
     * 不考虑当前编号，找到当前链表的最后一个节点，最后一个节点为NULL。
     * 将最后这个节点的next 指向新的节点。
     */
    public void insert(HeroNode heroNode){
        //因为头结点不动，我们需要一个辅助遍历
        HeroNode temp = head;

        //遍历链表
        while (true){
            //当temp的next==null 则找到了最后一个节点。
            if (temp.next == null){
                break;
            }
            //若没有找到，就将temp后移下一个节点
            temp = temp.next;
        }
        //退出循环时，temp指向了链表的最后,就可以将这个节点的next，指向新的节点。
        temp.next = heroNode;
    }

    /**
     * 按照no大小按升序序插入节点
     * @param heroNode
     */
    public void insertByOrder(HeroNode heroNode){
        //因为头结点不动，需要借助一个辅助，来帮助找到合适添加位置
        //单链表，temp是位于添加位置的前一个结点，否则插入失败， 因为我们可以根据上一个结点找到下一个节点位置，但是不能根据下一个节点找到上一个结点位置。
        HeroNode temp = head;
        // 添加no是否存在，默认为false
        boolean flag = false;

        while (true){
            // 找到链表结尾
            if (temp.next == null){
                break;
            }
            // 找到插入位置，就在temp的后面
            if (temp.next.no > heroNode.no){
                break;
            }else if (temp.next.no == heroNode.no){ //要添加的no已经存在
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }

        if (flag){
            throw new RuntimeException("待插入的编号："+ heroNode.no + "，已经存在，插入失败。");
        }else {
            //将结点插入到链表，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }


    /**
     * 根据结点的编号no来修改结点data信息
     * @param newHeroNode
     */
    public void update(HeroNode newHeroNode){


        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        //找到需要修改修改的结点
        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为true找到该结点，修改结点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        }else {
            throw  new RuntimeException("当前链表没有结点no = "+ newHeroNode.no);
        }
    }

    /**
     * 删除结点
     * 比较的时候，是temp.next.no 和需要删除结点的no
     * @param no 待删除结点no
     */
    public void delete(int no){
        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            //找到了结点最后位置，依旧没有找到该元素
            if (temp.next == null){
                break;
            }
            //找到待删除结点的前一个结点temp
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag){
            System.out.println("成功删除结点："+ temp.next);
            temp.next = temp.next.next;
        }
    }

    /**
     * 遍历链表
     */
    public void show(){
        //通过一辅助遍历 遍历整个链表。
        //判断链表是否为空
        if (isEmpty()){
            System.out.println("链表当前没有元素");
            return;
        }
        HeroNode temp = head.next;
        while (true){
            // 是否到了最后一个节点
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

    /**
     * 链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return head.next == null;
    }

}


/**
 * 定义HeroNode 每个HeroNode 对象就是一个节点
 */
class HeroNode{
    /**
     * 编号
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 昵称
     */
    public String nickName;
    /**
     * 指向下一个节点
     */
    public HeroNode next;

    /**
     * 构造器
     * @param no 编号
     * @param name 名字
     * @param nickName 昵称
     */
    public HeroNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

}

经典面试题

求单链表的结点个数

package LinkList;

import java.awt.image.BufferStrategy;
import java.beans.beancontext.BeanContext;

/**
 * 单链表
 */
public class SingleLinkListTest {

    public static void main(String[] args) {
        SingleLinkList singleLinkList = new SingleLinkList();
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(6,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(5,"鲁智深","花和尚");
        HeroNode heroNode4 = new HeroNode(4,"杨志","青面兽");
        HeroNode heroNode5 = new HeroNode(2,"吴用","智多星");

       /* singleLinkList.insert(heroNode1);
        singleLinkList.insert(heroNode2);
        singleLinkList.insert(heroNode3);*/

        //测试按照编号升序插入
        singleLinkList.insertByOrder(heroNode1);
        singleLinkList.insertByOrder(heroNode2);
        singleLinkList.insertByOrder(heroNode3);
        singleLinkList.insertByOrder(heroNode4);
        singleLinkList.insertByOrder(heroNode5);
        //测试修改
        HeroNode heroNode6 = new HeroNode(2,"吴用","大笨蛋");
        singleLinkList.update(heroNode6);

        singleLinkList.delete(2);

        singleLinkList.show();

        System.out.println("有效元素个数：" + singleLinkList.listLength(singleLinkList.getHead()));
    }
}

/**
 * 定义SingleLinkList管理 管理节点
 */
class SingleLinkList{

    /**
     * 初始化一个头结点,不存放具体的数据。
     */
    private HeroNode head = new HeroNode(0,"","");

    /**
     *
     * @return 头结点
     */
    public HeroNode getHead() {
        return head;
    }

    /**
     * 添加结点
     *
     * 不考虑当前编号，找到当前链表的最后一个节点，最后一个节点为NULL。
     * 将最后这个节点的next 指向新的节点。
     */
    public void insert(HeroNode heroNode){
        //因为头结点不动，我们需要一个辅助遍历
        HeroNode temp = head;

        //遍历链表
        while (true){
            //当temp的next==null 则找到了最后一个节点。
            if (temp.next == null){
                break;
            }
            //若没有找到，就将temp后移下一个节点
            temp = temp.next;
        }
        //退出循环时，temp指向了链表的最后,就可以将这个节点的next，指向新的节点。
        temp.next = heroNode;
    }

    /**
     * 按照no大小按升序序插入节点
     * @param heroNode
     */
    public void insertByOrder(HeroNode heroNode){
        //因为头结点不动，需要借助一个辅助，来帮助找到合适添加位置
        //单链表，temp是位于添加位置的前一个结点，否则插入失败， 因为我们可以根据上一个结点找到下一个节点位置，但是不能根据下一个节点找到上一个结点位置。
        HeroNode temp = head;
        // 添加no是否存在，默认为false
        boolean flag = false;

        while (true){
            // 找到链表结尾
            if (temp.next == null){
                break;
            }
            // 找到插入位置，就在temp的后面
            if (temp.next.no > heroNode.no){
                break;
            }else if (temp.next.no == heroNode.no){ //要添加的no已经存在
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }

        if (flag){
            throw new RuntimeException("待插入的编号："+ heroNode.no + "，已经存在，插入失败。");
        }else {
            //将结点插入到链表，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }


    /**
     * 根据结点的编号no来修改结点data信息
     * @param newHeroNode
     */
    public void update(HeroNode newHeroNode){


        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        //找到需要修改修改的结点
        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为true找到该结点，修改结点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        }else {
            throw  new RuntimeException("当前链表没有结点no = "+ newHeroNode.no);
        }
    }

    /**
     * 删除结点
     * 比较的时候，是temp.next.no 和需要删除结点的no
     * @param no 待删除结点no
     */
    public void delete(int no){
        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            //找到了结点最后位置，依旧没有找到该元素
            if (temp.next == null){
                break;
            }
            //找到待删除结点的前一个结点temp
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag){
            System.out.println("成功删除结点："+ temp.next);
            temp.next = temp.next.next;
        }
    }


    /**
     * 获取到链表结点的个数(如果是带头结点的链表，不统计头结点)
     * @param head 链表的头结点
     * @return
     */
    public int listLength(HeroNode head){
        //空链表 返回0
        if (head.next == null){
            return 0;
        }
        int length = 0;
        //定义一个辅助变量，不统计头结点
        HeroNode  cur = head.next;
        while (cur != null){
            length++;
            cur = cur.next;//遍历，指向下一个节点。
        }
        return length;
    }

    /**
     * 遍历链表
     */
    public void show(){
        //通过一辅助遍历 遍历整个链表。
        //判断链表是否为空
        if (isEmpty()){
            System.out.println("链表当前没有元素");
            return;
        }
        HeroNode temp = head.next;
        while (true){
            // 是否到了最后一个节点
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

    /**
     * 链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return head.next == null;
    }

}


/**
 * 定义HeroNode 每个HeroNode 对象就是一个节点
 */
class HeroNode{
    /**
     * 编号
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 昵称
     */
    public String nickName;
    /**
     * 指向下一个节点
     */
    public HeroNode next;

    /**
     * 构造器
     * @param no 编号
     * @param name 名字
     * @param nickName 昵称
     */
    public HeroNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

}

查找单链表中倒数第K个结点

思路分析

  • 编写一个方法，接收head头结点，一个location位置。
  • location表示是倒数第index个结点。
  • 先把链表从头到尾遍历，获取到链表的总长度。
  • 得到总长度后，从链表的第一个开始遍历（size-index）个。
package LinkList;

import java.awt.image.BufferStrategy;
import java.beans.beancontext.BeanContext;

/**
 * 单链表
 */
public class SingleLinkListTest {

    public static void main(String[] args) {
        SingleLinkList singleLinkList = new SingleLinkList();
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(6,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(5,"鲁智深","花和尚");
        HeroNode heroNode4 = new HeroNode(4,"杨志","青面兽");
        HeroNode heroNode5 = new HeroNode(2,"吴用","智多星");

       /* singleLinkList.insert(heroNode1);
        singleLinkList.insert(heroNode2);
        singleLinkList.insert(heroNode3);*/

        //测试按照编号升序插入
        singleLinkList.insertByOrder(heroNode1);
        singleLinkList.insertByOrder(heroNode2);
        singleLinkList.insertByOrder(heroNode3);
        singleLinkList.insertByOrder(heroNode4);
        singleLinkList.insertByOrder(heroNode5);
        //测试修改
        HeroNode heroNode6 = new HeroNode(2,"吴用","大笨蛋");
        singleLinkList.update(heroNode6);

        singleLinkList.delete(2);

        singleLinkList.show();

        System.out.println("有效元素个数：" + singleLinkList.listLength(singleLinkList.getHead()));

        System.out.println("倒数第三个元素：" + singleLinkList.locateElem(singleLinkList.getHead(),3));
    }
}

/**
 * 定义SingleLinkList管理 管理节点
 */
class SingleLinkList{

    /**
     * 初始化一个头结点,不存放具体的数据。
     */
    private HeroNode head = new HeroNode(0,"","");

    /**
     *
     * @return 头结点
     */
    public HeroNode getHead() {
        return head;
    }

    /**
     * 添加结点
     *
     * 不考虑当前编号，找到当前链表的最后一个节点，最后一个节点为NULL。
     * 将最后这个节点的next 指向新的节点。
     */
    public void insert(HeroNode heroNode){
        //因为头结点不动，我们需要一个辅助遍历
        HeroNode temp = head;

        //遍历链表
        while (true){
            //当temp的next==null 则找到了最后一个节点。
            if (temp.next == null){
                break;
            }
            //若没有找到，就将temp后移下一个节点
            temp = temp.next;
        }
        //退出循环时，temp指向了链表的最后,就可以将这个节点的next，指向新的节点。
        temp.next = heroNode;
    }

    /**
     * 按照no大小按升序序插入节点
     * @param heroNode
     */
    public void insertByOrder(HeroNode heroNode){
        //因为头结点不动，需要借助一个辅助，来帮助找到合适添加位置
        //单链表，temp是位于添加位置的前一个结点，否则插入失败， 因为我们可以根据上一个结点找到下一个节点位置，但是不能根据下一个节点找到上一个结点位置。
        HeroNode temp = head;
        // 添加no是否存在，默认为false
        boolean flag = false;

        while (true){
            // 找到链表结尾
            if (temp.next == null){
                break;
            }
            // 找到插入位置，就在temp的后面
            if (temp.next.no > heroNode.no){
                break;
            }else if (temp.next.no == heroNode.no){ //要添加的no已经存在
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }

        if (flag){
            throw new RuntimeException("待插入的编号："+ heroNode.no + "，已经存在，插入失败。");
        }else {
            //将结点插入到链表，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }


    /**
     * 根据结点的编号no来修改结点data信息
     * @param newHeroNode
     */
    public void update(HeroNode newHeroNode){


        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        //找到需要修改修改的结点
        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为true找到该结点，修改结点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        }else {
            throw  new RuntimeException("当前链表没有结点no = "+ newHeroNode.no);
        }
    }

    /**
     * 删除结点
     * 比较的时候，是temp.next.no 和需要删除结点的no
     * @param no 待删除结点no
     */
    public void delete(int no){
        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            //找到了结点最后位置，依旧没有找到该元素
            if (temp.next == null){
                break;
            }
            //找到待删除结点的前一个结点temp
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag){
            System.out.println("成功删除结点："+ temp.next);
            temp.next = temp.next.next;
        }
    }


    /**
     * 获取到链表结点的个数(如果是带头结点的链表，不统计头结点)
     * @param head 链表的头结点
     * @return
     */
    public int listLength(HeroNode head){
        //空链表 返回0
        if (head.next == null){
            return 0;
        }
        int length = 0;
        //定义一个辅助变量，不统计头结点
        HeroNode  cur = head.next;
        while (cur != null){
            length++;
            cur = cur.next;//遍历，指向下一个节点。
        }
        return length;
    }


    /**
     * 查找单链表中倒数第K个结点
     * @param head 头结点
     * @param location 第N个
     * @return
     */
    public HeroNode locateElem(HeroNode head,int location){
        //链表为空，找不到 返回null
        if (isEmpty()){
            return null;
        }
        //第一次遍历，获取链表个数
        int length = listLength(head);
        //第二次遍历 length - location 就是倒数的第K个结点
        if (location <= 0 || location > length){
            return null;
        }
        //定义一个辅助变量，遍历
        HeroNode cur = head.next;
        for (int i = 0; i < length - location; i++) {
            cur = cur.next;
        }
        return cur;
    }

    /**
     * 遍历链表
     */
    public void show(){
        //通过一辅助遍历 遍历整个链表。
        //判断链表是否为空
        if (isEmpty()){
            System.out.println("链表当前没有元素");
            return;
        }
        HeroNode temp = head.next;
        while (true){
            // 是否到了最后一个节点
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

    /**
     * 链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return head.next == null;
    }

}


/**
 * 定义HeroNode 每个HeroNode 对象就是一个节点
 */
class HeroNode{
    /**
     * 编号
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 昵称
     */
    public String nickName;
    /**
     * 指向下一个节点
     */
    public HeroNode next;

    /**
     * 构造器
     * @param no 编号
     * @param name 名字
     * @param nickName 昵称
     */
    public HeroNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

}

输出结果
在这里插入图片描述

单链表单转

在这里插入图片描述
在这里插入图片描述

package LinkList;

import java.awt.image.BufferStrategy;
import java.beans.beancontext.BeanContext;

/**
 * 单链表
 */
public class SingleLinkListTest {

    public static void main(String[] args) {
        SingleLinkList singleLinkList = new SingleLinkList();
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(6,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(5,"鲁智深","花和尚");
        HeroNode heroNode4 = new HeroNode(4,"杨志","青面兽");
        HeroNode heroNode5 = new HeroNode(2,"吴用","智多星");

       /* singleLinkList.insert(heroNode1);
        singleLinkList.insert(heroNode2);
        singleLinkList.insert(heroNode3);*/

        //测试按照编号升序插入
        singleLinkList.insertByOrder(heroNode1);
        singleLinkList.insertByOrder(heroNode2);
        singleLinkList.insertByOrder(heroNode3);
        singleLinkList.insertByOrder(heroNode4);
        singleLinkList.insertByOrder(heroNode5);
        //测试修改
/*        HeroNode heroNode6 = new HeroNode(2,"吴用","大笨蛋");
        singleLinkList.update(heroNode6);

        singleLinkList.delete(2);

        singleLinkList.show();

        System.out.println("有效元素个数：" + singleLinkList.listLength(singleLinkList.getHead()));

        System.out.println("倒数第三个元素：" + singleLinkList.locateElem(singleLinkList.getHead(),3));*/

        //测试反转
        System.out.println("原始单链表：");
        singleLinkList.show();

        singleLinkList.reverseList(singleLinkList.getHead());
        System.out.println("反转后的单链表：");
        singleLinkList.show();

    }
}

/**
 * 定义SingleLinkList管理 管理节点
 */
class SingleLinkList{

    /**
     * 初始化一个头结点,不存放具体的数据。
     */
    private HeroNode head = new HeroNode(0,"","");

    /**
     *
     * @return 头结点
     */
    public HeroNode getHead() {
        return head;
    }

    /**
     * 添加结点
     *
     * 不考虑当前编号，找到当前链表的最后一个节点，最后一个节点为NULL。
     * 将最后这个节点的next 指向新的节点。
     */
    public void insert(HeroNode heroNode){
        //因为头结点不动，我们需要一个辅助遍历
        HeroNode temp = head;

        //遍历链表
        while (true){
            //当temp的next==null 则找到了最后一个节点。
            if (temp.next == null){
                break;
            }
            //若没有找到，就将temp后移下一个节点
            temp = temp.next;
        }
        //退出循环时，temp指向了链表的最后,就可以将这个节点的next，指向新的节点。
        temp.next = heroNode;
    }

    /**
     * 按照no大小按升序序插入节点
     * @param heroNode
     */
    public void insertByOrder(HeroNode heroNode){
        //因为头结点不动，需要借助一个辅助，来帮助找到合适添加位置
        //单链表，temp是位于添加位置的前一个结点，否则插入失败， 因为我们可以根据上一个结点找到下一个节点位置，但是不能根据下一个节点找到上一个结点位置。
        HeroNode temp = head;
        // 添加no是否存在，默认为false
        boolean flag = false;

        while (true){
            // 找到链表结尾
            if (temp.next == null){
                break;
            }
            // 找到插入位置，就在temp的后面
            if (temp.next.no > heroNode.no){
                break;
            }else if (temp.next.no == heroNode.no){ //要添加的no已经存在
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }

        if (flag){
            throw new RuntimeException("待插入的编号："+ heroNode.no + "，已经存在，插入失败。");
        }else {
            //将结点插入到链表，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }


    /**
     * 根据结点的编号no来修改结点data信息
     * @param newHeroNode
     */
    public void update(HeroNode newHeroNode){


        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        //找到需要修改修改的结点
        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为true找到该结点，修改结点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        }else {
            throw  new RuntimeException("当前链表没有结点no = "+ newHeroNode.no);
        }
    }

    /**
     * 删除结点
     * 比较的时候，是temp.next.no 和需要删除结点的no
     * @param no 待删除结点no
     */
    public void delete(int no){
        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            //找到了结点最后位置，依旧没有找到该元素
            if (temp.next == null){
                break;
            }
            //找到待删除结点的前一个结点temp
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag){
            System.out.println("成功删除结点："+ temp.next);
            temp.next = temp.next.next;
        }
    }


    /**
     * 获取到链表结点的个数(如果是带头结点的链表，不统计头结点)
     * @param head 链表的头结点
     * @return
     */
    public int listLength(HeroNode head){
        //空链表 返回0
        if (head.next == null){
            return 0;
        }
        int length = 0;
        //定义一个辅助变量，不统计头结点
        HeroNode  cur = head.next;
        while (cur != null){
            length++;
            cur = cur.next;//遍历，指向下一个节点。
        }
        return length;
    }


    /**
     * 查找单链表中倒数第K个结点
     * @param head 头结点
     * @param location 第N个
     * @return
     */
    public HeroNode locateElem(HeroNode head,int location){
        //链表为空，找不到 返回null
        if (isEmpty()){
            return null;
        }
        //第一次遍历，获取链表个数
        int length = listLength(head);
        //第二次遍历 length - location 就是倒数的第K个结点
        if (location <= 0 || location > length){
            return null;
        }
        //定义一个辅助变量，遍历
        HeroNode cur = head.next;
        for (int i = 0; i < length - location; i++) {
            cur = cur.next;
        }
        return cur;
    }

    /**
     * 反转单链表
     * @param head 头结点
     */
    public void reverseList(HeroNode head){
        //单链表为空或者只有一个节点，直接返回
        if (head.next == null || head.next.next == null){
            return;
        }
        //定义一个辅助变量，帮助我们遍历原来的链表
        HeroNode cur = head.next;
        //指向当前节点的下一个结点
        HeroNode next = null;
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表。遍历每一个结点，就将其取出，并放在新的链表reverseHead的前端。
        while (cur != null){
            //暂时保留当前节点的下一个节点，因为后面需要使用
            next = cur.next;
            //将cur的下一个结点指向新链表的最前端
            cur.next = reverseHead.next;
            //将cur连接到新的链表
            reverseHead.next = cur;
            //cur指向下一个节点 cur后移
            cur = next;
        }
        //head.next 指向reverseHead.next,实现反转。
        head.next = reverseHead.next;
    }

    /**
     * 遍历链表
     */
    public void show(){
        //通过一辅助遍历 遍历整个链表。
        //判断链表是否为空
        if (isEmpty()){
            System.out.println("链表当前没有元素");
            return;
        }
        HeroNode temp = head.next;
        while (true){
            // 是否到了最后一个节点
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

    /**
     * 链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return head.next == null;
    }

}


/**
 * 定义HeroNode 每个HeroNode 对象就是一个节点
 */
class HeroNode{
    /**
     * 编号
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 昵称
     */
    public String nickName;
    /**
     * 指向下一个节点
     */
    public HeroNode next;

    /**
     * 构造器
     * @param no 编号
     * @param name 名字
     * @param nickName 昵称
     */
    public HeroNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

}

输出结果
在这里插入图片描述

从尾带头打印单链表

两种方式：1、反向遍历。2、Stack 栈
在这里插入图片描述

package LinkList;

import com.sun.xml.internal.bind.v2.model.core.ID;

import java.awt.image.BufferStrategy;
import java.beans.beancontext.BeanContext;
import java.util.Stack;

/**
 * 单链表
 */
public class SingleLinkListTest {

    public static void main(String[] args) {
        SingleLinkList singleLinkList = new SingleLinkList();
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(6,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(5,"鲁智深","花和尚");
        HeroNode heroNode4 = new HeroNode(4,"杨志","青面兽");
        HeroNode heroNode5 = new HeroNode(2,"吴用","智多星");

       /* singleLinkList.insert(heroNode1);
        singleLinkList.insert(heroNode2);
        singleLinkList.insert(heroNode3);*/

        //测试按照编号升序插入
        singleLinkList.insertByOrder(heroNode1);
        singleLinkList.insertByOrder(heroNode2);
        singleLinkList.insertByOrder(heroNode3);
        singleLinkList.insertByOrder(heroNode4);
        singleLinkList.insertByOrder(heroNode5);
        //测试修改
/*        HeroNode heroNode6 = new HeroNode(2,"吴用","大笨蛋");
        singleLinkList.update(heroNode6);

        singleLinkList.delete(2);

        singleLinkList.show();

        System.out.println("有效元素个数：" + singleLinkList.listLength(singleLinkList.getHead()));

        System.out.println("倒数第三个元素：" + singleLinkList.locateElem(singleLinkList.getHead(),3));*/

        //测试反转
/*        System.out.println("原始单链表：");
        singleLinkList.show();

        singleLinkList.reverseList(singleLinkList.getHead());
        System.out.println("反转后的单链表：");
        singleLinkList.show();*/

        //测试逆序打印
        System.out.println("原始单链表：");
        singleLinkList.show();
        
        System.out.println("逆序输出单链表：");
        singleLinkList.reversePrint(singleLinkList.getHead());


    }
}

/**
 * 定义SingleLinkList管理 管理节点
 */
class SingleLinkList{

    /**
     * 初始化一个头结点,不存放具体的数据。
     */
    private HeroNode head = new HeroNode(0,"","");

    /**
     *
     * @return 头结点
     */
    public HeroNode getHead() {
        return head;
    }

    /**
     * 添加结点
     *
     * 不考虑当前编号，找到当前链表的最后一个节点，最后一个节点为NULL。
     * 将最后这个节点的next 指向新的节点。
     */
    public void insert(HeroNode heroNode){
        //因为头结点不动，我们需要一个辅助遍历
        HeroNode temp = head;

        //遍历链表
        while (true){
            //当temp的next==null 则找到了最后一个节点。
            if (temp.next == null){
                break;
            }
            //若没有找到，就将temp后移下一个节点
            temp = temp.next;
        }
        //退出循环时，temp指向了链表的最后,就可以将这个节点的next，指向新的节点。
        temp.next = heroNode;
    }

    /**
     * 按照no大小按升序序插入节点
     * @param heroNode
     */
    public void insertByOrder(HeroNode heroNode){
        //因为头结点不动，需要借助一个辅助，来帮助找到合适添加位置
        //单链表，temp是位于添加位置的前一个结点，否则插入失败， 因为我们可以根据上一个结点找到下一个节点位置，但是不能根据下一个节点找到上一个结点位置。
        HeroNode temp = head;
        // 添加no是否存在，默认为false
        boolean flag = false;

        while (true){
            // 找到链表结尾
            if (temp.next == null){
                break;
            }
            // 找到插入位置，就在temp的后面
            if (temp.next.no > heroNode.no){
                break;
            }else if (temp.next.no == heroNode.no){ //要添加的no已经存在
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }

        if (flag){
            throw new RuntimeException("待插入的编号："+ heroNode.no + "，已经存在，插入失败。");
        }else {
            //将结点插入到链表，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }


    /**
     * 根据结点的编号no来修改结点data信息
     * @param newHeroNode
     */
    public void update(HeroNode newHeroNode){


        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        //找到需要修改修改的结点
        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为true找到该结点，修改结点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        }else {
            throw  new RuntimeException("当前链表没有结点no = "+ newHeroNode.no);
        }
    }

    /**
     * 删除结点
     * 比较的时候，是temp.next.no 和需要删除结点的no
     * @param no 待删除结点no
     */
    public void delete(int no){
        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            //找到了结点最后位置，依旧没有找到该元素
            if (temp.next == null){
                break;
            }
            //找到待删除结点的前一个结点temp
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag){
            System.out.println("成功删除结点："+ temp.next);
            temp.next = temp.next.next;
        }
    }


    /**
     * 获取到链表结点的个数(如果是带头结点的链表，不统计头结点)
     * @param head 链表的头结点
     * @return
     */
    public int listLength(HeroNode head){
        //空链表 返回0
        if (head.next == null){
            return 0;
        }
        int length = 0;
        //定义一个辅助变量，不统计头结点
        HeroNode  cur = head.next;
        while (cur != null){
            length++;
            cur = cur.next;//遍历，指向下一个节点。
        }
        return length;
    }


    /**
     * 查找单链表中倒数第K个结点
     * @param head 头结点
     * @param location 第N个
     * @return
     */
    public HeroNode locateElem(HeroNode head,int location){
        //链表为空，找不到 返回null
        if (isEmpty()){
            return null;
        }
        //第一次遍历，获取链表个数
        int length = listLength(head);
        //第二次遍历 length - location 就是倒数的第K个结点
        if (location <= 0 || location > length){
            return null;
        }
        //定义一个辅助变量，遍历
        HeroNode cur = head.next;
        for (int i = 0; i < length - location; i++) {
            cur = cur.next;
        }
        return cur;
    }

    /**
     * 反转单链表
     * @param head 头结点
     */
    public void reverseList(HeroNode head){
        //单链表为空或者只有一个节点，直接返回
        if (head.next == null || head.next.next == null){
            return;
        }
        //定义一个辅助变量，帮助我们遍历原来的链表
        HeroNode cur = head.next;
        //指向当前节点的下一个结点
        HeroNode next = null;
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表。遍历每一个结点，就将其取出，并放在新的链表reverseHead的前端。
        while (cur != null){
            //暂时保留当前节点的下一个节点，因为后面需要使用
            next = cur.next;
            //将cur的下一个结点指向新链表的最前端
            cur.next = reverseHead.next;
            //将cur连接到新的链表
            reverseHead.next = cur;
            //cur指向下一个节点 cur后移
            cur = next;
        }
        //head.next 指向reverseHead.next,实现反转。
        head.next = reverseHead.next;
    }


    /**
     * 逆序打印链表
     * @param head 头结点
     */
    public void reversePrint(HeroNode head){
        //空链表不打印
        if (head.next == null){
            return;
        }
        //创建一个栈，将各个节点入栈
        Stack<HeroNode> heroNodeStack = new Stack<>();
        HeroNode cur = head.next;
        while (cur != null){
            heroNodeStack.push(cur);
            cur = cur.next;
        }
        //出栈
        while (heroNodeStack.size() > 0){
            System.out.println(heroNodeStack.pop());//先进后出
        }
    }

    /**
     * 遍历链表
     */
    public void show(){
        //通过一辅助遍历 遍历整个链表。
        //判断链表是否为空
        if (isEmpty()){
            System.out.println("链表当前没有元素");
            return;
        }
        HeroNode temp = head.next;
        while (true){
            // 是否到了最后一个节点
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

    /**
     * 链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return head.next == null;
    }

}


/**
 * 定义HeroNode 每个HeroNode 对象就是一个节点
 */
class HeroNode{
    /**
     * 编号
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 昵称
     */
    public String nickName;
    /**
     * 指向下一个节点
     */
    public HeroNode next;

    /**
     * 构造器
     * @param no 编号
     * @param name 名字
     * @param nickName 昵称
     */
    public HeroNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

}

合并两个有序的单链表

在这里插入图片描述

/**
 * 单链表
 */
public class SingleLinkListTest {

    public static void main(String[] args) {
        SingleLinkList singleLinkList = new SingleLinkList();
        SingleLinkList singleLinkList1 = new SingleLinkList();
        SingleLinkList singleLinkList3 = new SingleLinkList();
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(4,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(7,"鲁智深","花和尚");
        HeroNode heroNode4 = new HeroNode(2,"杨志","青面兽");
        HeroNode heroNode5 = new HeroNode(5,"吴用","智多星");
        HeroNode heroNode6 = new HeroNode(8,"周通","小霸王");

        //测试按照编号升序插入
        singleLinkList.insertByOrder(heroNode1);
        singleLinkList.insertByOrder(heroNode2);
        singleLinkList.insertByOrder(heroNode3);
        singleLinkList1.insertByOrder(heroNode4);
        singleLinkList1.insertByOrder(heroNode5);
        singleLinkList1.insertByOrder(heroNode6);
 
        System.out.println("原始单链表1：");
        singleLinkList.show();
        System.out.println("原始单链表2：");
        singleLinkList1.show();

        System.out.println("合并后");
        SingleLinkList.twoLinkedList(singleLinkList.getHead(),singleLinkList1.getHead(),singleLinkList3.getHead());
        singleLinkList3.show();
    }
}


/**
 * 定义SingleLinkList管理 管理节点
 */
class SingleLinkList{

    /**
     * 初始化一个头结点,不存放具体的数据。
     */
    private HeroNode head = new HeroNode(0,"","");

    /**
     *
     * @return 头结点
     */
    public HeroNode getHead() {
        return head;
    }

    /**
     * 添加结点
     *
     * 不考虑当前编号，找到当前链表的最后一个节点，最后一个节点为NULL。
     * 将最后这个节点的next 指向新的节点。
     */
    public void insert(HeroNode heroNode){
        //因为头结点不动，我们需要一个辅助遍历
        HeroNode temp = head;

        //遍历链表
        while (true){
            //当temp的next==null 则找到了最后一个节点。
            if (temp.next == null){
                break;
            }
            //若没有找到，就将temp后移下一个节点
            temp = temp.next;
        }
        //退出循环时，temp指向了链表的最后,就可以将这个节点的next，指向新的节点。
        temp.next = heroNode;
    }

    /**
     * 按照no大小按升序序插入节点
     * @param heroNode
     */
    public void insertByOrder(HeroNode heroNode){
        //因为头结点不动，需要借助一个辅助，来帮助找到合适添加位置
        //单链表，temp是位于添加位置的前一个结点，否则插入失败， 因为我们可以根据上一个结点找到下一个节点位置，但是不能根据下一个节点找到上一个结点位置。
        HeroNode temp = head;
        // 添加no是否存在，默认为false
        boolean flag = false;

        while (true){
            // 找到链表结尾
            if (temp.next == null){
                break;
            }
            // 找到插入位置，就在temp的后面
            if (temp.next.no > heroNode.no){
                break;
            }else if (temp.next.no == heroNode.no){ //要添加的no已经存在
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }

        if (flag){
            throw new RuntimeException("待插入的编号："+ heroNode.no + "，已经存在，插入失败。");
        }else {
            //将结点插入到链表，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }


    /**
     * 遍历链表
     */
    public void show(){
        //通过一辅助遍历 遍历整个链表。
        //判断链表是否为空
        if (isEmpty()){
            System.out.println("链表当前没有元素");
            return;
        }
        HeroNode temp = head.next;
        while (true){
            // 是否到了最后一个节点
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

    /**
     * 链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return head.next == null;
    }

    /**
     * 合并两个有序链表
     * @param head1 头结点1
     * @param head2 头结点2
     * @param newHeroNode 空头结点
     */
    public static void twoLinkedList(HeroNode head1, HeroNode head2,HeroNode newHeroNode) {

        // 如果两个链表均为空，则无需合并，直接返回
        if (head1.next == null && head2.next == null) {
            return;
        }
        // 如果链表1为空，则将head3.next指向head2.next，实现链表2中的节点连接到链表3
        if (head1.next == null) {
            newHeroNode.next = head2.next;
        } else {
            // 将head3.next指向head1.next，实现链表1中的节点连接到链表3
            newHeroNode.next = head1.next;
            // 定义一个辅助的指针（变量），帮助我们遍历链表2
            HeroNode cur2 = head2.next;
            // 定义一个辅助的指针（变量），帮助我们遍历链表3
            HeroNode cur3 = newHeroNode;
            HeroNode next = null;
            // 遍历链表2，将其节点按顺序连接至链表3
            while (cur2 != null) {
                // 链表3遍历完毕后，可以直接将链表2剩下的节点连接至链表3的末尾
                if (cur3.next == null) {
                    cur3.next = cur2;
                    break;
                }
                // 在链表3中，找到第一个大于链表2中的节点编号的节点
                // 因为是单链表，找到的节点是位于添加位置的前一个节点，否则无法插入
                if (cur2.no <= cur3.next.no) {
                    next = cur2.next;  // 先暂时保存链表2中当前节点的下一个节点，方便后续使用
                    cur2.next = cur3.next;  // 将cur2的下一个节点指向cur3的下一个节点
                    cur3.next = cur2;  // 将cur2连接到链表3上
                    cur2 = next;  // 让cur2后移
                }
                // 遍历链表3
                cur3 = cur3.next;
            }
        }
    }




}


/**
 * 定义HeroNode 每个HeroNode 对象就是一个节点
 */
class HeroNode{
    /**
     * 编号
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 昵称
     */
    public String nickName;
    /**
     * 指向下一个节点
     */
    public HeroNode next;

    /**
     * 构造器
     * @param no 编号
     * @param name 名字
     * @param nickName 昵称
     */
    public HeroNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

}

完整代码

package LinkList;

import com.sun.xml.internal.bind.v2.model.core.ID;

import java.awt.image.BufferStrategy;
import java.beans.beancontext.BeanContext;
import java.util.Stack;

/**
 * 单链表
 */
public class SingleLinkListTest {

    public static void main(String[] args) {
        SingleLinkList singleLinkList = new SingleLinkList();
        SingleLinkList singleLinkList1 = new SingleLinkList();
        SingleLinkList singleLinkList3 = new SingleLinkList();
        HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
        HeroNode heroNode2 = new HeroNode(4,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(7,"鲁智深","花和尚");
        HeroNode heroNode4 = new HeroNode(2,"杨志","青面兽");
        HeroNode heroNode5 = new HeroNode(5,"吴用","智多星");
        HeroNode heroNode6 = new HeroNode(8,"周通","小霸王");

       /* singleLinkList.insert(heroNode1);
        singleLinkList.insert(heroNode2);
        singleLinkList.insert(heroNode3);*/

        //测试按照编号升序插入
        singleLinkList.insertByOrder(heroNode1);
        singleLinkList.insertByOrder(heroNode2);
        singleLinkList.insertByOrder(heroNode3);
        singleLinkList1.insertByOrder(heroNode4);
        singleLinkList1.insertByOrder(heroNode5);
        singleLinkList1.insertByOrder(heroNode6);
        //测试修改
/*        HeroNode heroNode6 = new HeroNode(2,"吴用","大笨蛋");
        singleLinkList.update(heroNode6);

        singleLinkList.delete(2);

        singleLinkList.show();

        System.out.println("有效元素个数：" + singleLinkList.listLength(singleLinkList.getHead()));

        System.out.println("倒数第三个元素：" + singleLinkList.locateElem(singleLinkList.getHead(),3));*/

        //测试反转
/*        System.out.println("原始单链表：");
        singleLinkList.show();

        singleLinkList.reverseList(singleLinkList.getHead());
        System.out.println("反转后的单链表：");
        singleLinkList.show();*/

        //测试逆序打印
/*        System.out.println("原始单链表：");
        singleLinkList.show();

        System.out.println("逆序输出单链表：");
        singleLinkList.reversePrint(singleLinkList.getHead());*/

        System.out.println("原始单链表1：");
        singleLinkList.show();
        System.out.println("原始单链表2：");
        singleLinkList1.show();


        System.out.println("合并后");
        SingleLinkList.twoLinkedList(singleLinkList.getHead(),singleLinkList1.getHead(),singleLinkList3.getHead());
        singleLinkList3.show();
    }
}

/**
 * 定义SingleLinkList管理 管理节点
 */
class SingleLinkList{

    /**
     * 初始化一个头结点,不存放具体的数据。
     */
    private HeroNode head = new HeroNode(0,"","");

    /**
     *
     * @return 头结点
     */
    public HeroNode getHead() {
        return head;
    }

    /**
     * 添加结点
     *
     * 不考虑当前编号，找到当前链表的最后一个节点，最后一个节点为NULL。
     * 将最后这个节点的next 指向新的节点。
     */
    public void insert(HeroNode heroNode){
        //因为头结点不动，我们需要一个辅助遍历
        HeroNode temp = head;

        //遍历链表
        while (true){
            //当temp的next==null 则找到了最后一个节点。
            if (temp.next == null){
                break;
            }
            //若没有找到，就将temp后移下一个节点
            temp = temp.next;
        }
        //退出循环时，temp指向了链表的最后,就可以将这个节点的next，指向新的节点。
        temp.next = heroNode;
    }

    /**
     * 按照no大小按升序序插入节点
     * @param heroNode
     */
    public void insertByOrder(HeroNode heroNode){
        //因为头结点不动，需要借助一个辅助，来帮助找到合适添加位置
        //单链表，temp是位于添加位置的前一个结点，否则插入失败， 因为我们可以根据上一个结点找到下一个节点位置，但是不能根据下一个节点找到上一个结点位置。
        HeroNode temp = head;
        // 添加no是否存在，默认为false
        boolean flag = false;

        while (true){
            // 找到链表结尾
            if (temp.next == null){
                break;
            }
            // 找到插入位置，就在temp的后面
            if (temp.next.no > heroNode.no){
                break;
            }else if (temp.next.no == heroNode.no){ //要添加的no已经存在
                flag = true; //说明编号存在
                break;
            }
            temp = temp.next;
        }

        if (flag){
            throw new RuntimeException("待插入的编号："+ heroNode.no + "，已经存在，插入失败。");
        }else {
            //将结点插入到链表，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }


    /**
     * 根据结点的编号no来修改结点data信息
     * @param newHeroNode
     */
    public void update(HeroNode newHeroNode){


        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        //找到需要修改修改的结点
        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为true找到该结点，修改结点
        if (flag){
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        }else {
            throw  new RuntimeException("当前链表没有结点no = "+ newHeroNode.no);
        }
    }

    /**
     * 删除结点
     * 比较的时候，是temp.next.no 和需要删除结点的no
     * @param no 待删除结点no
     */
    public void delete(int no){
        if (isEmpty()){
            throw  new RuntimeException("当前链表为空");
        }
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            //找到了结点最后位置，依旧没有找到该元素
            if (temp.next == null){
                break;
            }
            //找到待删除结点的前一个结点temp
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }

        if (flag){
            System.out.println("成功删除结点："+ temp.next);
            temp.next = temp.next.next;
        }
    }


    /**
     * 获取到链表结点的个数(如果是带头结点的链表，不统计头结点)
     * @param head 链表的头结点
     * @return
     */
    public int listLength(HeroNode head){
        //空链表 返回0
        if (head.next == null){
            return 0;
        }
        int length = 0;
        //定义一个辅助变量，不统计头结点
        HeroNode  cur = head.next;
        while (cur != null){
            length++;
            cur = cur.next;//遍历，指向下一个节点。
        }
        return length;
    }


    /**
     * 查找单链表中倒数第K个结点
     * @param head 头结点
     * @param location 第N个
     * @return
     */
    public HeroNode locateElem(HeroNode head,int location){
        //链表为空，找不到 返回null
        if (isEmpty()){
            return null;
        }
        //第一次遍历，获取链表个数
        int length = listLength(head);
        //第二次遍历 length - location 就是倒数的第K个结点
        if (location <= 0 || location > length){
            return null;
        }
        //定义一个辅助变量，遍历
        HeroNode cur = head.next;
        for (int i = 0; i < length - location; i++) {
            cur = cur.next;
        }
        return cur;
    }

    /**
     * 反转单链表
     * @param head 头结点
     */
    public void reverseList(HeroNode head){
        //单链表为空或者只有一个节点，直接返回
        if (head.next == null || head.next.next == null){
            return;
        }
        //定义一个辅助变量，帮助我们遍历原来的链表
        HeroNode cur = head.next;
        //指向当前节点的下一个结点
        HeroNode next = null;
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原来的链表。遍历每一个结点，就将其取出，并放在新的链表reverseHead的前端。
        while (cur != null){
            //暂时保留当前节点的下一个节点，因为后面需要使用
            next = cur.next;
            //将cur的下一个结点指向新链表的最前端
            cur.next = reverseHead.next;
            //将cur连接到新的链表
            reverseHead.next = cur;
            //cur指向下一个节点 cur后移
            cur = next;
        }
        //head.next 指向reverseHead.next,实现反转。
        head.next = reverseHead.next;
    }


    /**
     * 逆序打印链表
     * @param head 头结点
     */
    public void reversePrint(HeroNode head){
        //空链表不打印
        if (head.next == null){
            return;
        }
        //创建一个栈，将各个节点入栈
        Stack<HeroNode> heroNodeStack = new Stack<>();
        HeroNode cur = head.next;
        while (cur != null){
            heroNodeStack.push(cur);
            cur = cur.next;
        }
        //出栈
        while (heroNodeStack.size() > 0){
            System.out.println(heroNodeStack.pop());//先进后出
        }
    }

    /**
     * 遍历链表
     */
    public void show(){
        //通过一辅助遍历 遍历整个链表。
        //判断链表是否为空
        if (isEmpty()){
            System.out.println("链表当前没有元素");
            return;
        }
        HeroNode temp = head.next;
        while (true){
            // 是否到了最后一个节点
            if (temp == null){
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将next后移
            temp = temp.next;
        }
    }

    /**
     * 链表是否为空
     * @return
     */
    public boolean isEmpty(){
        return head.next == null;
    }


    /**
     * 合并两个有序链表
     * @param head1 头结点1
     * @param head2 头结点2
     * @param newHeroNode 空头结点
     */
    public static void twoLinkedList(HeroNode head1, HeroNode head2,HeroNode newHeroNode) {

        // 如果两个链表均为空，则无需合并，直接返回
        if (head1.next == null && head2.next == null) {
            return;
        }
        // 如果链表1为空，则将head3.next指向head2.next，实现链表2中的节点连接到链表3
        if (head1.next == null) {
            newHeroNode.next = head2.next;
        } else {
            // 将head3.next指向head1.next，实现链表1中的节点连接到链表3
            newHeroNode.next = head1.next;
            // 定义一个辅助的指针（变量），帮助我们遍历链表2
            HeroNode cur2 = head2.next;
            // 定义一个辅助的指针（变量），帮助我们遍历链表3
            HeroNode cur3 = newHeroNode;
            HeroNode next = null;
            // 遍历链表2，将其节点按顺序连接至链表3
            while (cur2 != null) {
                // 链表3遍历完毕后，可以直接将链表2剩下的节点连接至链表3的末尾
                if (cur3.next == null) {
                    cur3.next = cur2;
                    break;
                }
                // 在链表3中，找到第一个大于链表2中的节点编号的节点
                // 因为是单链表，找到的节点是位于添加位置的前一个节点，否则无法插入
                if (cur2.no <= cur3.next.no) {
                    next = cur2.next;  // 先暂时保存链表2中当前节点的下一个节点，方便后续使用
                    cur2.next = cur3.next;  // 将cur2的下一个节点指向cur3的下一个节点
                    cur3.next = cur2;  // 将cur2连接到链表3上
                    cur2 = next;  // 让cur2后移
                }
                // 遍历链表3
                cur3 = cur3.next;
            }
        }
    }




}


/**
 * 定义HeroNode 每个HeroNode 对象就是一个节点
 */
class HeroNode{
    /**
     * 编号
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 昵称
     */
    public String nickName;
    /**
     * 指向下一个节点
     */
    public HeroNode next;

    /**
     * 构造器
     * @param no 编号
     * @param name 名字
     * @param nickName 昵称
     */
    public HeroNode(int no,String name,String nickName){
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }

}
我叫向同学
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构顺序表和链表（超详细）
08-14
此压缩包为1、无头+单向+非循环链表增删查改实现// 动态申请一个结点// 单链表打印// 单链表尾插// 单链表的头插// 单链表的尾删// 单链表头删// 单链表查找// 单链表在pos位置之后插入x// 单链表删除pos位置之后的...
单链表基本操作【超全】
03-13
单链表基本操作【超全】
【数据结构】单链表（带图详解）
Z1tai的博客
05-12 9017
概念：链表是一种物理存储结构上非连续非顺序的存储结构，但链表在逻辑上是连续的，顺序的，而数据元素的逻辑顺序是通过链表中的指针连接次序实现的。
数据结构——单链表
2301_77179941的博客
05-04 3263
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) +指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。 ​
单链表(图解以及分析)
qq_54469537的博客
09-16 4550
（单向非循环不带头节点）
数据结构之单链表非常详细介绍(适合小白）
m0_74438843的博客
08-22 3885
数据结构深度学习之单链表非常详解解读~~~一万多字详解
数据结构——单链表的实现
weixin_46024145的博客
06-08 1136
一、单链表的定义 template <typename DataType> class LinkList { public: LinkList(); //建立只有头结点的单链表； LinkList(DataType a[], int n); //建立n个元素的单链表； ~LinkList(); //析构函数； int Length(); //求单链表的长度； DataType Get(int i); //按位查找，查找第i个结点的元素值； int Locate
数据结构-单向链表的操作（详细思路和实例）
m0_65835264的博客
07-30 959
对单向链表的一系列操作的集合（增删改查等16个函数），用详细的思路、图解、实例、验证，使学习单向链表更加通俗易懂。
C#数据结构之单链表(LinkList)实例详解
东方猫的博客
06-03 4827
本文实例讲述了C#数据结构之单链表(LinkList)实现方法。分享给大家供大家参考，具体如下：这里我们来看下“单链表(LinkList)”。在上一篇《C#数据结构之顺序表(SeqList)实例详解》的最后，我们指出了：顺序表要求开辟一组连续的内存空间，而且插入/删除元素时，为了保证元素的顺序性，必须对后面的元素进行移动。如果你的应用中需要频繁对元素进行插入/删除，那么开销会很大。而链表结构正好相...
单链表应用实例
jefferyfg的博客
09-25 2568
在学习单链表之前，先简单了解一下链表 链表是有序的链表，但它在内存中是存储如下 链表是以节点的方式来存储的，是链式存储 每个节点包含data域、next域：指向下一个节点 链表的各个节点不一定是连续存储 链表分带头节点的链表和没有头结点的列表，根据实际需求来定 单链表（带头结点）逻辑结构示意图如下： 单链表的应用实例： 使用带head头节点的单向链表实现水浒英雄人物的增删改查操作 ， 1....
【数据结构】 之 单链表（含实例）
10-12 2961
笔者现大三，这篇博文及后面的几篇博文都是对大二所做的题目一些总结，哈哈，感觉自己那时候学的还可以，希望自己这点笔记能对你们有点帮助吧，加油！！！其实数据结构也没传说中的那么难，并且以后在我们面试的时候，数据结构可是面试官的法宝，对吧，咱们不能输在起跑线线上，好了，废话不多说，现在让我们来学习最简单链表——单链表。我先把老师给我们出的题目给大家看看吧，不知道我们是不是一样的（纯洁的微笑），题目如下：
数据结构-单链表(c++)超全超详细（csdn）————程序.pdf
12-05
数据结构-单链表(c++)超全超详细（csdn）————程序
设计一个基于链表的数据结构
11-18
课题：设计一个基于链表的数据结构，实现一个简单的学生信息管理系统。 1. 确定课程目标和内容：本课题的目标是让学生掌握链表数据结构的基本原理和应用，培养学生的编程能力和逻辑思维能力。课程内容包括链表的...
经典数据结构算法c语言实现代码（大全）
04-01
16进制10进制.txt 32.txt asm.txt Crctable.txt ... 单链表的处理全集.txt 双链表正排序.txt 反出字符.txt 叠代整除.txt 各种排序法.txt 哈夫曼算法.txt 哈慢树.txt 四分砝码.txt 四塔1.txt
【数据结构】二叉树（带图详解）
最新发布
Z1tai的博客
04-27 1546
链表和数组都是线性结构，而树是非线性的结构。树是依靠分支关系定义出的一种层次结构。社会亲缘关系和组织结构图都可以用树来形象地表示。
数据结构系列-二叉树之前序遍历
in_seattle的博客
04-26 508
这篇文章，我们主要的内容是对二叉树当中的前历的算法进行讲解，二叉树中的算法所要求实现的是 从根到左子树再到右子树的遍历顺序，可能这样不太好理解，我们拿一张图片进行解释，我们先来分析一下这个的实现逻辑是什么，按照根节点，左子树，右子树的顺序，我们先来判断一下这个应该实现的结果是什么。在这里，我们将空也表现了出来，那下面，我们就讲解一下怎么用代码实现这个过程。假设在这个二叉树当中，我们要实现二叉树遍历当中的前历，我们应该怎么做呢。这些代码我们在前面就详细的进行了展开，在这里我们就不进行详细的讲解。
【数据结构】第二章 线性数据结构.线性表.顺序表
KX_52517的博客
04-26 1348
线性数据结构章节
【数据结构】图（Graph）
2201_75475240的博客
04-24 1305
本文章介绍数据结构中的图的基本知识，包括概念、邻接表、邻接矩阵、深度遍历和广度遍历，且还包含408习题（附有解析）。此外，含有关于邻接表和两种遍历全部具体实现代码。
数据结构练习：链表扩容
2301_80369371的博客
04-25 337
一：创建一个新链表，遍历原链表的同时，将原链表的值复制给新链表。二：将新链表插入到原链表中（大致如下）3.*&是c++的写法，等同于c中的*2.记得malloc后要free。1.头结点是不存有数据的。
数据结构单链表详细介绍自己代码
05-19
单链表是一种常见的数据结构，它由多个节点组成。每个节点包含两个部分：数据域和指针域。数据域用于存储节点中的数据，指针域用于指向下一个节点的地址。通过指针，多个节点可以组成一个链表，形成一种线性结构。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值