链表(数据结构)

最新推荐文章于 2022-12-22 18:05:46 发布
最新推荐文章于 2022-12-22 18:05:46 发布
阅读量184 收藏
点赞数
分类专栏： java 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hahayixiao1/article/details/118976427
版权
链表

链表是有序的列表

1.链表是以节点的方式来存储，是链式存储

2.每个节点包含data域，next域指向下一个节点

3.链表的各个节点不一定是连续储存。

4.链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。

添加（创建）

1.先创建一个head的头节点，作用就是表示单链表的头

2.后面我们每添加一个节点，就直接添加到链表的最后

按添加的顺序：

public class SingleLinkedListDemo {
    public static void main(String[] args) {
       //进行一个测试
        //先创建节点
        HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(3,"吴用","智多星");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(heroNode2);
        singleLinkedList.add(heroNode1);
        singleLinkedList.add(heroNode3);
        singleLinkedList.list();
    }
}
//定义SingleLinkedList
class SingleLinkedList{
    //先初始化一个头节点，头节点不要动
    private HeroNode head = new HeroNode(0,"","");
    //添加节点到单向链表
    //1.找到当前链表的最后节点
    //2.将最后这个节点的next指向新的节点
    public void add(HeroNode heroNode){
        //head不能移动，因此需要一个辅助遍历temp
        HeroNode temp=head;
        //遍历链表，找到最后
        while(true){
            if(temp.next==null){
                break;
            }
            //如果没有找到就将temp后移
            temp=temp.next;
        }
        //当退出while循环时，temp就指向链表的最后
        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);
            temp=temp.next;
        }
    }
}

//每个HeroNode对象就是一个节点
class HeroNode{
    public int no;
    public String name;
    public String NickName;
    public HeroNode next;
    public HeroNode(int hNo,String hname,String HNickName){
        this.no=hNo;
        this.name=hname;
        this.NickName=HNickName;
    }

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

                '}';
    }
}

按指定的顺序，如序号：

1.首先要找到新添加节点的位置，是通过辅助变量（指针)，通过遍历来搞定

2.新的节点.next=temp.next

3.temp.next=新的节点

public class SingleLinkedListDemo {
    public static void main(String[] args) {
       //进行一个测试
        //先创建节点
        HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(3,"吴用","智多星");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addByOrder(heroNode2);
        singleLinkedList.addByOrder(heroNode1);
        singleLinkedList.addByOrder(heroNode3);
        singleLinkedList.list();
    }
}
//定义SingleLinkedList
class SingleLinkedList{
    //先初始化一个头节点，头节点不要动
    private HeroNode head = new HeroNode(0,"","");
    //添加节点到单向链表
    //1.找到当前链表的最后节点
    //2.将最后这个节点的next指向新的节点
    public void add(HeroNode heroNode){
        //head不能移动，因此需要一个辅助遍历temp
        HeroNode temp=head;
        //遍历链表，找到最后
        while(true){
            if(temp.next==null){
                break;
            }
            //如果没有找到就将temp后移
            temp=temp.next;
        }
        //当退出while循环时，temp就指向链表的最后
        temp.next=heroNode;

    }
    public void addByOrder(HeroNode heroNode){
        //因为头节点不能动，因此仍然通过一个辅助节点来遍历单链表，找到添加的位置
        //因为单链表，所以temp要位于添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false;//添加的编号是否存在，默认为false
        while(true){
            if(temp.next==null){
                break;
            }
            if(temp.next.no>heroNode.no){
                //位置找到，就在temp的后面插入
                break;
            }else if(temp.next.no== heroNode.no){
                //编号存在
                flag=true;
                break;
            }
            temp=temp.next;//后移遍历当前链表
        }
        //判断flag的值
        if(flag){
            //不能添加说明编号存在
            System.out.printf("准备插入的英雄的编号%d已经存在，不能加入\n",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);
            temp=temp.next;
        }
    }
}

//每个HeroNode对象就是一个节点
class HeroNode{
    public int no;
    public String name;
    public String NickName;
    public HeroNode next;
    public HeroNode(int hNo,String hname,String HNickName){
        this.no=hNo;
        this.name=hname;
        this.NickName=HNickName;
    }

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

                '}';
    }
}

链表的修改：

public class SingleLinkedListDemo {
    public static void main(String[] args) {
       //进行一个测试
        //先创建节点
        HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(3,"吴用","智多星");
        HeroNode heroNode4 = new HeroNode(3,"无用","智多星");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addByOrder(heroNode2);
        singleLinkedList.addByOrder(heroNode1);
        singleLinkedList.addByOrder(heroNode3);
        singleLinkedList.list();
        singleLinkedList.update(heroNode4);
        singleLinkedList.list();
    }
}
//定义SingleLinkedList
class SingleLinkedList{
    //先初始化一个头节点，头节点不要动
    private HeroNode head = new HeroNode(0,"","");
    //添加节点到单向链表
    //1.找到当前链表的最后节点
    //2.将最后这个节点的next指向新的节点
    public void add(HeroNode heroNode){
        //head不能移动，因此需要一个辅助遍历temp
        HeroNode temp=head;
        //遍历链表，找到最后
        while(true){
            if(temp.next==null){
                break;
            }
            //如果没有找到就将temp后移
            temp=temp.next;
        }
        //当退出while循环时，temp就指向链表的最后
        temp.next=heroNode;

    }
    public void addByOrder(HeroNode heroNode){
        //因为头节点不能动，因此仍然通过一个辅助节点来遍历单链表，找到添加的位置
        //因为单链表，所以temp要位于添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false;//添加的编号是否存在，默认为false
        while(true){
            if(temp.next==null){
                break;
            }
            if(temp.next.no>heroNode.no){
                //位置找到，就在temp的后面插入
                break;
            }else if(temp.next.no== heroNode.no){
                //编号存在
                flag=true;
                break;
            }
            temp=temp.next;//后移遍历当前链表
        }
        //判断flag的值
        if(flag){
            //不能添加说明编号存在
            System.out.printf("准备插入的英雄的编号%d已经存在，不能加入\n",heroNode.no);

        }else{
            //插入到链表中，temp后面
            heroNode.next=temp.next;
            temp.next=heroNode;
        }


    }

    public void update(HeroNode heroNode){
        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==heroNode.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            temp.name= heroNode.name;
            temp.NickName= heroNode.NickName;

        }else{
            System.out.printf("没有找到编号为%d的节点\n",heroNode.no);
        }
    }
    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);
            temp=temp.next;
        }
    }
}

//每个HeroNode对象就是一个节点
class HeroNode{
    public int no;
    public String name;
    public String NickName;
    public HeroNode next;
    public HeroNode(int hNo,String hname,String HNickName){
        this.no=hNo;
        this.name=hname;
        this.NickName=HNickName;
    }

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

                '}';
    }
}

链表的删除：

主要实现代码temp.next=temp.next.next;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
       //进行一个测试
        //先创建节点
        HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode heroNode3 = new HeroNode(3,"吴用","智多星");
        HeroNode heroNode4 = new HeroNode(3,"无用","智多星");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addByOrder(heroNode2);
        singleLinkedList.addByOrder(heroNode1);
        singleLinkedList.addByOrder(heroNode3);
        singleLinkedList.list();
        singleLinkedList.delete(2);
        singleLinkedList.update(heroNode4);
        singleLinkedList.list();
    }
}
//定义SingleLinkedList
class SingleLinkedList{
    //先初始化一个头节点，头节点不要动
    private HeroNode head = new HeroNode(0,"","");
    //添加节点到单向链表
    //1.找到当前链表的最后节点
    //2.将最后这个节点的next指向新的节点
    public void add(HeroNode heroNode){
        //head不能移动，因此需要一个辅助遍历temp
        HeroNode temp=head;
        //遍历链表，找到最后
        while(true){
            if(temp.next==null){
                break;
            }
            //如果没有找到就将temp后移
            temp=temp.next;
        }
        //当退出while循环时，temp就指向链表的最后
        temp.next=heroNode;

    }
    public void addByOrder(HeroNode heroNode){
        //因为头节点不能动，因此仍然通过一个辅助节点来遍历单链表，找到添加的位置
        //因为单链表，所以temp要位于添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false;//添加的编号是否存在，默认为false
        while(true){
            if(temp.next==null){
                break;
            }
            if(temp.next.no>heroNode.no){
                //位置找到，就在temp的后面插入
                break;
            }else if(temp.next.no== heroNode.no){
                //编号存在
                flag=true;
                break;
            }
            temp=temp.next;//后移遍历当前链表
        }
        //判断flag的值
        if(flag){
            //不能添加说明编号存在
            System.out.printf("准备插入的英雄的编号%d已经存在，不能加入\n",heroNode.no);

        }else{
            //插入到链表中，temp后面
            heroNode.next=temp.next;
            temp.next=heroNode;
        }


    }

    public void delete(int no){
        HeroNode temp = head;
        boolean flag = false;//标识是否找到待删除节点的
        while(true){
            if(temp.next==null){
                break;
            }
            if (temp.next.no==no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            temp.next=temp.next.next;
        }else{
            System.out.printf("没有找到要删除的节点%d\n",no);
        }


    }

    public void update(HeroNode heroNode){
        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==heroNode.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            temp.name= heroNode.name;
            temp.NickName= heroNode.NickName;

        }else{
            System.out.printf("没有找到编号为%d的节点\n",heroNode.no);
        }
    }
    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);
            temp=temp.next;
        }
    }
}

//每个HeroNode对象就是一个节点
class HeroNode{
    public int no;
    public String name;
    public String NickName;
    public HeroNode next;
    public HeroNode(int hNo,String hname,String HNickName){
        this.no=hNo;
        this.name=hname;
        this.NickName=HNickName;
    }

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

                '}';
    }
}

单向链表的缺点：

1.查找方向只能是一个方向，而双向链表可以向前或者向后查找

2.单向链表不能自我删除，需要靠辅助节点，而双向链表可以进行自我删除

双向链表

next指向下一个节点

pre指向上一个节点

1.遍历方向和单链表一样，只是可以向前，也可以向后查找

2.添加（默认添加到双向链表的最后）

（1）.先找到双向链表的最后这个节点

（2）.temp.next=newHeroNode;

（3）.newHeroNode.pre=temp;

3.修改思路和原来的单向链表一样

4.删除

（1）.因为是双向链表，因此可以实现自我删除的某个节点

（2）.直接找到要删除的这个节点，比如heroNode；

heroNode.pre.next=heroNode.next;

heroNode.next.pre=heroNode.pre;

class DoubleLinkedList{
    private HeroNode2 head=new HeroNode2(0,"","");
    public HeroNode2 getHead(){
        return head;
    }
    public void list(){
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        //头节点不能动，因此我们需要一个辅助变量来遍历
        HeroNode2 temp=head.next;
        while(true){
            //判断是否到链表最后
            if(temp==null){
                break;
            }
            System.out.println(temp);
            temp=temp.next;
        }
    }
    public void add(HeroNode2 heroNode){
        //head不能移动，因此需要一个辅助遍历temp
        HeroNode2 temp=head;
        //遍历链表，找到最后
        while(true){
            if(temp.next==null){
                break;
            }
            //如果没有找到就将temp后移
            temp=temp.next;
        }
        //当退出while循环时，temp就指向链表的最后
        temp.next=heroNode;
        heroNode.pre=temp;

    }
    public void delete(int no){
        HeroNode2 temp = head.next;
        boolean flag = false;//标识是否找到待删除节点的
        while(true){
            if(temp==null){
                break;
            }
            if (temp.no==no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            temp.pre.next=temp.next;
            if(temp.next!=null){
                temp.next.pre=temp.pre;    
            }
            

        }else{
            System.out.printf("没有找到要删除的节点%d\n",no);
        }


    }
    public void update(HeroNode2 heroNode){
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        HeroNode2 temp = head.next;
        boolean flag=false;
        while(true){
            if(temp==null){
                break;
            }
            if(temp.no==heroNode.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            temp.name= heroNode.name;
            temp.NickName= heroNode.NickName;

        }else{
            System.out.printf("没有找到编号为%d的节点\n",heroNode.no);
        }
    }

}
//每个HeroNode对象就是一个节点
class HeroNode2{
    public int no;
    public String name;
    public String NickName;
    public HeroNode2 next;//指向后一个节点，默认为null
    public HeroNode2 pre;//指向前一个节点，默认为null
    public HeroNode2(int hNo,String hname,String HNickName){
        this.no=hNo;
        this.name=hname;
        this.NickName=HNickName;
    }

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

                '}';
    }
单向环形链表（约瑟夫环）Josephu：
public class CircleLinkedDemo {
    public static void main(String[] args) {
         //构建环形链表和遍历
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);
        circleSingleLinkedList.showBoy();
    }
}
class CircleSingleLinkedList{
    private Boy first=new Boy(0);
    //添加小孩节点构建环形链表
    public void addBoy(int nums){
        if(nums<1){
            System.out.println("输入不合法");
            return;
        }
        Boy  curBoy =null;//辅助指针
        for (int i=1;i<=nums;i++){
            //根据编号创建小孩节点
            Boy boy=new Boy(i);
            if(i==1){
                first=boy;
                first.setNext(first);//构成一个环状
                curBoy=first;//让curBoy指向第一个小孩
            }else{
                curBoy.setNext(boy);
                boy.setNext(first);
                curBoy=boy;
            }
        }
    }
    public void showBoy(){
        if(first==null){
            System.out.println("没有任何小孩——");
        }
            //因为first不能东，因此我们任然使用一个辅助指针完成遍历
            Boy curBoy =first;
            while(true){
                System.out.printf("小孩的编号%d\n",curBoy.getNo());
                if(curBoy.getNext()==first){
                    System.out.println("已经遍历完毕");
                    break;
                }
                curBoy=curBoy.getNext();

        }
    }
}
class Boy{
    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }

    private int no;
    private Boy next;
    public Boy(int no){
          this.no=no;
    }

    @Override
    public String toString() {
        return "Boy{" +
                "no=" + no +
                '}';
    }
}

Ha ha, a smile
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
链表-使用Python实现链表数据结构.zip
03-13
链表 链表_使用Python实现链表数据结构
【数据结构】链表
knous
03-13 6万+
链表
C语言链表超详解
热门推荐
k666499436的博客
05-17 10万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
数据结构之链表
喜欢捣鼓各种技术
01-18 3836
数据结构之链表
数据结构之——链表
xqx_999的博客
10-06 4107
链表的介绍，单链表和双向链表的接口实现。
C语言数据结构——链表
zcxmjw的博客
12-22 1万+
大家好，本篇文章主要带领大家了解一下什么是链表，链表的两个主要结构，以及链表和顺序表的差别。
链表-使用JAVA语言实现链表数据结构.zip
03-13
链表 链表_使用JAVA语言实现链表数据结构
链表数据结构
02-20
链表数据结构该软件包的描述。
C语言 链表数据结构 动态管理数据
06-20
底层C语言软件实现数据结构List.c及list/h文件，通过链表结构实现对数据的动态管理，但需要Malloc函数的配合。实际项目使用多年，数据稳定。
JavaScript实现的链表数据结构实例
10-24
主要介绍了JavaScript实现的链表数据结构实例,本文直接给出实现代码,需要的朋友可以参考下
数据结构课设报告，城市链表
08-09
将若干城市的信息，存入一个带头结点的单链表。 结点中的城市信息包括：城市名，城市的位置坐标。 要求能够利用城市名和位置坐标进行有关查找、插入、删除、更新等操作。
使用C++实现链表数据结构之单链表.zip
03-13
链表 使用C++实现链表数据结构之单链表
Java模拟单链表和双端链表数据结构的实例讲解
09-02
主要介绍了Java模拟单链表和双端链表数据结构的实例,注意这里的双端链表不是双向链表,是在单链表的基础上保存有对最后一个链接点的引用,需要的朋友可以参考下
C#模拟链表数据结构的实例解析
12-31
模块化编程是大多数初学者必经之路，然后可能你走向了结构化编程，链表是一种典型结构模式，它的出现克服了数组必须预先知道大小的缺陷，听不懂?你只需要记住，链表结构非常牛叉就可以了，学习这种结构对我们的逻辑...
链表-使用PHP实现的循环链表数据结构.zip
03-13
链表 链表_使用PHP实现的循环链表数据结构
链表-使用PHP实现的双向链表数据结构.zip
03-13
链表 链表_使用PHP实现的双向链表数据结构
动态数组链表数据结构.docx
05-30
动态数组链表数据结构.docx
C语言实现链表数据结构（源码+例子）
最新发布
03-13
这个程序首先定义了一个Node结构体来表示链表节点，包含整数数据和指向下一个节点的指针。然后提供了一系列函数来操作链表，包括创建新节点、在链表末尾插入节点、打印链表内容。在main函数中，演示了如何使用这些...
链表数据结构C代码.zip
02-26
链表的基本程序，单链表，双链表的C代码，包括链表的定义，各种操作。
sdut链表数据结构
09-19
sdut链表数据结构是一个循环链表的实现，具体实现过程如下: 1. 首先，在程序中定义了一个结构体node，其中包含了一个整型数据data和一个指向下一个结点的指针next。 2. 然后，通过函数str(int n)创建一个头结点head...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值