Java单链表头插法和尾插法以及增删改查方法

已于 2022-01-19 00:55:51 修改
阅读量1.9k 收藏 8
点赞数 3
分类专栏： 数据结构和算法 文章标签： java 链表 数据结构
于 2022-01-17 15:18:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38568503/article/details/122536652
版权

目录

一、单链表的头插法：

头插法原理图：
在这里插入图片描述

代码演示头插法：

package com.fan.linkedlist;

public class SingleLInkedListDemo3 {
    public static void main(String[] args) {
        SingleLInkedList3 singlelist3 = new SingleLInkedList3();
        System.out.println(singlelist3.headInsert(1));
        System.out.println(singlelist3.headInsert(2));
        System.out.println(singlelist3.headInsert(3));
        System.out.println("显示链表：");
        singlelist3.show();
        //测试尾插法1：向单链表增加数据
        System.out.println("\n测试尾插法1：");
        SingleLInkedList3 singlelist4 = new SingleLInkedList3();
        System.out.println(singlelist4.tailInsert1(4));
        System.out.println(singlelist4.tailInsert1(5));
        System.out.println(singlelist4.tailInsert1(6));
        singlelist4.show();
        //测试尾插法2：向单链表增加数据
        System.out.println("\n测试尾插法2：");
        SingleLInkedList3 singlelist5 = new SingleLInkedList3();
        System.out.println(singlelist5.tailInsert2(7));
        System.out.println(singlelist5.tailInsert2(8));
        System.out.println(singlelist5.tailInsert2(9));
        singlelist5.show();
    }
}
//2.创建链表类，并初始化头结点/尾结点，设置其的指针域为空.
class SingleLInkedList3{//链表带泛型
    //一个单链表是由多个节点构成的。这里我们设置头节点和尾部节点
    //声明头节点,并设置其指针域为空即headNode --->  null
     Node3 headNode = new Node3();
     //声明尾部节点，用来演示尾插法而设置的变量
     Node3 tailNode = new Node3();


    public Node3 getHeadNode() {
        return headNode;
    }

    public void setHeadNode(Node3 headNode) {
        this.headNode = headNode;
    }

    public Node3 getTailNode() {
        return tailNode;
    }

    public void setTailNode(Node3 tailNode) {
        this.tailNode = tailNode;
    }

    //使用空的构造方法创建单链表,当一个空链表创建好了之后就要有头或者尾节点
    //此构造方法很重要
    public SingleLInkedList3() {
        //初始化头节点的next指针域为空,并设置其指针域为空即headNode --->  null
        headNode.setNext(null);//一个空链表的头节点是指向null的
        //初始化尾节点的next指针域也为空,采用头插法就没必要设置tailNode
        tailNode.setNext(null);
        //headNode永远存储第一个节点的地址，tailNode永远存储最后一个节点的地址
        headNode = tailNode ;//也为了show方法的遍历
    }
    //头插法，即头节点不动，其后的指针每次进行拆散，并将新节点插入到头节点紧邻后边
    /*头插法一般也用于单链表模拟栈，我们用头插法能实现先入后出*/
    /*向单链表增加数据*/
    public boolean headInsert(Object obj){
        Node3 newNode = new Node3(obj);//将数据封装成一个新节点
        newNode.setNext(headNode.getNext());//设置新节点的后驱节点为 头节点的下一个节点
        headNode.setNext(newNode);//设置新节点的前驱节点为 头节点，即头节点不动
        //如果头节点紧邻后是新节点，证明头插入成功
        return headNode.getNext() == newNode;
    }
    //尾插法  ====第一种实现：使用从头节点遍历找尾节点并插入===
    /*向单链表增加数据*/
    public boolean tailInsert1(Object obj){
        Node3 newNode = new Node3(obj);
        Node3 curr = headNode;//临时节点从头节点开始遍历，
        while(true){
            if(curr.getNext() == null){
                break;//到了链表结尾
            }
            curr = curr.getNext();//临时节点后移
        }//end-while
        //出循环后就证明到了链表结尾，直接添加新节点,curr此时指向了最后一个有效节点
       curr.setNext(newNode);
        newNode.setNext(null);
       return newNode.getNext() == null;
    }
    //尾插法====第二种实现，使用尾节点移动来实现
    public boolean tailInsert2(Object obj){

        Node3 newNode = new Node3(obj);
        //1.将尾指针的指针域指向 刚刚插入的新节点newNode
        tailNode.setNext(newNode);
        //刷新尾节点，现在newNode变成了最后一个元素了，也就是新的尾节点
        //2.tailNode永远存储最后一个节点
        tailNode = newNode;//尾节点指向新添加的节点，即尾节点后移，类似于i++
        //将最终的尾节点指针域赋值为空
        tailNode.setNext(null);

        return tailNode.getNext()==null;
    }
    //链表元素的显示
    public void show(){
        //定义一个临时变量curr来遍历链表，不能使用头节点，因为头节点不能动
        Node3 curr = headNode.getNext();//curr指向头节点下一个，或者说将头节点地址赋值给curr临时节点
        while(true){
            if(curr == null){//下一个有效元素位空，则到了链表的结尾
                break;
            }
            System.out.print(curr+"\t-->");//打印当前有效节点
            curr = curr.getNext();//指针后移，相当于i++
        }
    }

    //链表元素的显示

}
//1.创建节点类,也可以将此类设置成内部类
class Node3{
    //数据域，可以是多个数据如name,id,age等
    private Object object;//
    //指针域,单链表有数据域和next指针这两项
    private Node3 next;//指向下驱节点

    public Node3(Object object) {
        this.object = object;
    }

    public Node3() {
    }

    public Object getObject() {
        return object;
    }

    public void setObject(Object object) {
        this.object = object;
    }

    public Node3 getNext() {
        return next;
    }

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

    @Override
    public String toString() {
        return "Node3{" +
                "object=" + object +
                '}';
    }
}

测试结果：
在这里插入图片描述

二、单链表的尾插法：

尾插法： 尾插法相对于头插法有些许不同 因为要返回头 头不能动 所以需要一个tailNode来记录最后一个值 tailNode右移

尾插法原理图：
开始tailNode–>null是指向null的。

在这里插入图片描述
代码：

   //尾插法  ====第一种实现：使用从头节点遍历找尾节点并插入===
    /*向单链表增加数据*/
    public boolean tailInsert1(Object obj){
        Node3 newNode = new Node3(obj);
        Node3 curr = headNode;//临时节点从头节点开始遍历，
        while(true){
            if(curr.getNext() == null){
                break;//到了链表结尾
            }
            curr = curr.getNext();//临时节点后移
        }//end-while
        //出循环后就证明到了链表结尾，直接添加新节点,curr此时指向了最后一个有效节点
       curr.setNext(newNode);
        newNode.setNext(null);
       return newNode.getNext() == null;
    }
    //尾插法====第二种实现，使用尾节点移动来实现
    public boolean tailInsert2(Object obj){

        Node3 newNode = new Node3(obj);
        //1.将尾指针的指针域指向 刚刚插入的新节点newNode
        tailNode.setNext(newNode);
        //刷新尾节点，现在newNode变成了最后一个元素了，也就是新的尾节点
        //2.tailNode永远存储最后一个节点
        tailNode = newNode;//尾节点指向新添加的节点，即尾节点后移，类似于i++
        //将最终的尾节点指针域赋值为空
        tailNode.setNext(null);

        return tailNode.getNext()==null;
    }

测试代码：

public class SingleLInkedListDemo3 {
    public static void main(String[] args) {
        SingleLInkedList3 singlelist3 = new SingleLInkedList3();
        System.out.println(singlelist3.headInsert(1));
        System.out.println(singlelist3.headInsert(2));
        System.out.println(singlelist3.headInsert(3));
        System.out.println("显示链表：");
        singlelist3.show();
        //测试尾插法1：向单链表增加数据
        System.out.println("\n测试尾插法1：");
        SingleLInkedList3 singlelist4 = new SingleLInkedList3();
        System.out.println(singlelist4.tailInsert1(4));
        System.out.println(singlelist4.tailInsert1(5));
        System.out.println(singlelist4.tailInsert1(6));
        singlelist4.show();
        //测试尾插法2：向单链表增加数据
        System.out.println("\n测试尾插法2：");
        SingleLInkedList3 singlelist5 = new SingleLInkedList3();
        System.out.println(singlelist5.tailInsert2(7));
        System.out.println(singlelist5.tailInsert2(8));
        System.out.println(singlelist5.tailInsert2(9));
        singlelist5.show();
    }
}

测试结果：
在这里插入图片描述

总结头插法和尾插法：

在这里插入图片描述

三、单链表顺序添加：

需求，我们有一批购房的摇号者，我们让摇号者的编号小的越先获取购房资格，请乱序添加5个摇号者的编号，添加到链表中后是从小到大排好序的。

分析：单链表的按照次序添加，区别于头插法和尾插法:

  //按照编号顺序添加
    public void addByOrder(ConsumerNode newNode){
        ConsumerNode curr = headNode;//头节点不能动，所以设置临时节点
        boolean flag = false;//默认编号不存在
        while(true){
            //遍历到链表结尾的时候
            if(curr.getNext() == null){
                break;
            }
            //判断编号的插入位置
            if(newNode.getNo() < curr.getNext().getNo()){
                break;//头插
            }else if(newNode.getNo() == curr.getNext().getNo()){
                flag = true;//编号相同的特殊情况，单独处理
                break;
            }
            curr = curr.getNext();
        }
        if(!flag){//当编号不存在的时候我们才添加
            newNode.setNext(curr.getNext());
            curr.setNext(newNode);
        }else{
            System.out.println("编号相同，不能插入---");
        }
    }

四、按照值查找节点：

//根据数据域编号查找该节点的所有信息
    public void findByNo(Integer key){
        ConsumerNode curr =headNode;
        boolean flag =false;
        while(true){
            if(curr.getNext() == null){//到链表结尾，退出循环
                break;
            }
            if(curr.getNext().getNo() == key){
                flag = true;//找到查找的节点了，退出
                break;
            }
            curr = curr.getNext();//临时节点后移进行遍历
        }
        if(flag){
            System.out.println(curr.getNext());
        }else{
            System.out.println("没有找到要查找的节点信息----");
        }
    }

五、删除节点：

//删除某一个节点，按照编号
    public void delByNo(Integer no){
        ConsumerNode curr = headNode;
        boolean flag = false;//设置是否找到要删除的节点
        while(true){
            //需要判断是否到链表的结尾处
            if(curr.getNext() == null){
                break;
            }
            if(curr.getNext().getNo() == no){
                flag = true;

                break;
            }
            curr = curr.getNext();//没有找到的话，后移继续找
        }
        if(flag){
            curr.setNext(curr.getNext().getNext());
        }else{
            System.out.println("没有此节点要删除---");
        }
    }

六、修改节点：

    //修改某一个节点，根据节点编号，修改
    public void update(ConsumerNode newNode){
        //思路，就是替换编号 相同的节点，即插入新节点
        ConsumerNode curr = headNode;
        boolean flag = false;//设置是否找到要修改的节点
        while(true){
            //需要先判断是否到链表的结尾处
            if(curr.getNext() == null){
                break;//到链表的结尾
            }

            if(curr.getNext().getNo()== newNode.getNo()  ){
                flag = true;
                break;
            }
            curr = curr.getNext();
        }
        if(flag){
            newNode.setNext(curr.getNext().getNext());
            curr.setNext(newNode);
        }else{
            System.out.println("输入的编号没找到对应节点---");
        }

    }

七、求单链表的表长：

//获取链表的长度
    public int getSize(){
        int count = 0;
        ConsumerNode curr = headNode;

        while(true){
            if(curr.getNext() == null){
                break;
            }
            count++;
            curr = curr.getNext();
        }
        return count;
    }

最后的总代码：

package com.fan.linkedlist;

public class SingleLinkedlistDemo4 {
    public static void main(String[] args) {
        //创建一个空链表
        ConsumerLinkedlist consumerLinkedlist = new ConsumerLinkedlist();

        /*consumerLinkedlist.addFirst(new ConsumerNode(1,"小一"));
        consumerLinkedlist.addFirst(new ConsumerNode(2,"小二"));
        consumerLinkedlist.addFirst(new ConsumerNode(3,"张三"));*/

        /*consumerLinkedlist.addLast(new ConsumerNode(1,"小一"));
        consumerLinkedlist.addLast(new ConsumerNode(2,"小二"));
        consumerLinkedlist.addLast(new ConsumerNode(3,"张三"));
        consumerLinkedlist.addLast(new ConsumerNode(4,"李四"));*/

        consumerLinkedlist.addByOrder(new ConsumerNode(4,"小一"));
        consumerLinkedlist.addByOrder(new ConsumerNode(2,"小二"));
        consumerLinkedlist.addByOrder(new ConsumerNode(1,"张三"));
        consumerLinkedlist.addByOrder(new ConsumerNode(3,"李四"));
        consumerLinkedlist.addByOrder(new ConsumerNode(5,"李四"));
        System.out.println("显示添加后的顺序链表:");
        consumerLinkedlist.show();
        System.out.println("\n链表长度："+ consumerLinkedlist.getSize());
        //consumerLinkedlist.delByNo(3);
        consumerLinkedlist.delByNo(11);
        System.out.println("删除后显示：");
        consumerLinkedlist.show();
        System.out.println("\n修改节点：===");
        consumerLinkedlist.update(new ConsumerNode(3,"我是大山"));//测试的此编号不存在
        consumerLinkedlist.show();
        System.out.println("\n查找节点========");
        //consumerLinkedlist.findByNo(8);
        consumerLinkedlist.findByNo(3);
    }
}
//链表类
class ConsumerLinkedlist{
    //一个单链表要有头节点或者尾节点
    private ConsumerNode headNode = new ConsumerNode();
    private ConsumerNode tailNode = new ConsumerNode();
    //构造方法
    public ConsumerLinkedlist(){
        headNode.setNext(null);
        tailNode.setNext(null);
        //头节点和尾节点开始时是重合的，都是指向null的
        //headNode永远存储第一个节点的地址，tailNode永远存储最后一个节点的地址
        headNode = tailNode ;//头尾重合，两个指针重合
    }
    //按照标号添加到链表中
    public void addFirst(ConsumerNode newNode){
        //头插法,不需要循环,头节点不动
        //注意，必须先处理新节点的后驱节点
        newNode.setNext(headNode.getNext());
        headNode.setNext(newNode);
    }
    //尾插法，还是头结点不动，尾节点移动
    public void addLast(ConsumerNode newNode){
        //注意，tailNode此时相当于一个临时的节点指针，相当一个指向节点的一个箭头
      /*  if(tailNode.getNext() == null){
            //直接添加新节点到尾节点的后边
            tailNode.setNext(newNode);
            //让尾节点成为最后一个节点
            tailNode = tailNode.getNext();
            //让尾节点的指针为null
            tailNode.setNext(null);
        }*/
        //直接添加新节点到尾节点的后边
        tailNode.setNext(newNode);
        tailNode = tailNode.getNext();//让尾节点成为最后一个节点
        tailNode.setNext(null);//让尾节点指向null
    }

    //按照编号顺序添加
    public void addByOrder(ConsumerNode newNode){
        ConsumerNode curr = headNode;//头节点不能动，所以设置临时节点
        boolean flag = false;//默认编号不存在
        while(true){
            //遍历到链表结尾的时候
            if(curr.getNext() == null){
                break;
            }
            //判断编号的插入位置
            if(newNode.getNo() < curr.getNext().getNo()){
                break;//头插
            }else if(newNode.getNo() == curr.getNext().getNo()){
                flag = true;//编号相同的特殊情况，单独处理
                break;
            }
            curr = curr.getNext();
        }
        if(!flag){//当编号不存在的时候我们才添加
            newNode.setNext(curr.getNext());
            curr.setNext(newNode);
        }else{
            System.out.println("编号相同，不能插入---");
        }
    }
    //删除某一个节点，按照编号
    public void delByNo(Integer no){
        ConsumerNode curr = headNode;
        boolean flag = false;//设置是否找到要删除的节点
        while(true){
            //需要判断是否到链表的结尾处
            if(curr.getNext() == null){
                break;
            }
            if(curr.getNext().getNo() == no){
                flag = true;

                break;
            }
            curr = curr.getNext();//没有找到的话，后移继续找
        }
        if(flag){
            curr.setNext(curr.getNext().getNext());
        }else{
            System.out.println("没有此节点要删除---");
        }
    }
    //修改某一个节点，根据节点编号，修改
    public void update(ConsumerNode newNode){
        //思路，就是替换编号 相同的节点，即插入新节点
        ConsumerNode curr = headNode;
        boolean flag = false;//设置是否找到要修改的节点
        while(true){
            //需要先判断是否到链表的结尾处
            if(curr.getNext() == null){
                break;//到链表的结尾
            }

            if(curr.getNext().getNo()== newNode.getNo()  ){
                flag = true;
                break;
            }
            curr = curr.getNext();
        }
        if(flag){
            newNode.setNext(curr.getNext().getNext());
            curr.setNext(newNode);
        }else{
            System.out.println("输入的编号没找到对应节点---");
        }

    }
    //根据数据域编号查找该节点的所有信息
    public void findByNo(Integer key){
        ConsumerNode curr =headNode;
        boolean flag =false;
        while(true){
            if(curr.getNext() == null){//到链表结尾，退出循环
                break;
            }
            if(curr.getNext().getNo() == key){
                flag = true;//找到查找的节点了，退出
                break;
            }
            curr = curr.getNext();//临时节点后移进行遍历
        }
        if(flag){
            System.out.println(curr.getNext());
        }else{
            System.out.println("没有找到要查找的节点信息----");
        }
    }
    //获取链表的长度
    public int getSize(){
        int count = 0;
        ConsumerNode curr = headNode;

        while(true){
            if(curr.getNext() == null){
                break;
            }
            count++;
            curr = curr.getNext();
        }
        return count;
    }
    //单链表的遍历
    public void show(){
        //判断链表是否为空，只有一个头节点的话直接结束
        if(headNode.getNext() == null){
            System.out.println("链表为空");
            return;
        }
        ConsumerNode curr = headNode.getNext();//从有效节点开始遍历
        while(true){
            if(curr == null){//到链表末尾时退出
               break;
            }
            System.out.print(curr+"-->");
            curr = curr.getNext();
        }
    }
}
//消费者节点，消费者将来需要被叫号排到链表中,可以用lambook
class ConsumerNode {
    //数据域
    private Integer no;
    private String name;
    //指针域,单链表只有一个next指针域，用于指向下一个节点
    private ConsumerNode next;
    //生成构造和set，get等


    public ConsumerNode(Integer no, String name) {
        this.no = no;
        this.name = name;
    }

    public ConsumerNode() {
    }

    public Integer getNo() {
        return no;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public ConsumerNode getNext() {
        return next;
    }

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

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

单链表常见面试题：

在这里插入图片描述

单链表的反转：

在这里插入图片描述

    //单链表的反转，类似于头插法,返回一个新链表的头节点，不影响原链表结构
    public void resver(){
        ConsumerNode curr = headNode.getNext();//用于遍历的指针节点
        ConsumerNode temp = null;//后面用于存储curr的后驱节点的
        ConsumerNode newlinkedHead = new ConsumerNode();
        //循环拆解原链表，并拼接到新链表的头节点上
        if(curr.getNext() == null || curr.getNext().getNext() == null){
            return ;//只有一个节点或者空链表
        }
        while(true){
            if(curr == null){
                break;//到链表结尾
            }
            if(curr != null){
                //先将curr的下一个节点保存起来
                temp = curr.getNext();
                //设置curr的下一个节点不再是原先链表的下一个节点了，而是新链表头节点的下一个节点
                curr.setNext(newlinkedHead.getNext());
                //新节点的下一个节点就是curr
                newlinkedHead.setNext(curr);
                //让curr后移到原先链表的后一个节点
                curr = temp;//这个相当于原先的 curr = curr.getNext();
            }
        }
        //将新链表的所有节点穿到旧链表的头节点上，这样输出旧链表就已经反转了
        headNode.setNext(newlinkedHead.getNext());
    }

测试：

public class SingleLinkedlistDemo4 {
    public static void main(String[] args) {
        //创建一个空链表
        ConsumerLinkedlist consumerLinkedlist = new ConsumerLinkedlist();

        //添加顺序1->2->3->4->5
        consumerLinkedlist.addLast(new ConsumerNode(1,"小一"));
        consumerLinkedlist.addLast(new ConsumerNode(2,"小二"));
        consumerLinkedlist.addLast(new ConsumerNode(3,"张三"));
        consumerLinkedlist.addLast(new ConsumerNode(4,"李四"));
        consumerLinkedlist.addLast(new ConsumerNode(5,"李四"));
     
        System.out.println("\n反转链表：--");
        consumerLinkedlist.resver();
        consumerLinkedlist.show();
    }
}

在这里插入图片描述

对于从尾部到头部打印单链表，可以先反转，后调用show方法即可；

这个名字先用着
关注
专栏目录
java单链表头插法尾插法
qq_54494937的博客
08-21 539
头插法只需要把刚刚新建的节点赋给头节点就行了 下次新建节点next可以直接指向头节点 尾插法 需要记录上次的节点 使next指向新建的节点 节点类 public class LinkNode { int val; LinkNode next; @Override public String toString() { return "LinkNode{" + "val=" + val + ",
【数据结构】线性表：顺序表、单链表、双链表、单循环链表、双循环链表（java实现）
昂萨哈凯尔可真难记啊
11-04 927
目录 顺序表 单链表 双链表 单循环链表 双循环链表 总结 顺序表 package com.list; import java.lang.*; import java.util.*; /** * @author PangWanjia * @date 2020/11/3 14:50 */ /* 顺序表和java的ArrayList类 创建顺序表，顺序表的增删查改都是通过下标和容量实现的 */ class SqListClass<E>{ ..
java单向链表中的头插法与尾插法
hanbingge123的博客
08-07 2287
java单向链表
【Java】链表的头插法和尾插法
最新发布
qq_55846232的博客
07-11 710
尾插法与头插法不同的是，先要找到链表最后面那个节点，所以就要定义一个游标index，index从头结点开始，如果index.next不是null，那么就往后面走，直到找到最后一个节点
java链表的头插法和尾插法
m566666的博客
12-04 5401
链表是由值和地址 头插法看如下代码： public void startAdd(int n) { Listnode listnode=new Listnode(n); listnode.next=head; head=listnode; } 尾插法看如下代码： public void endAdd(int n) { Listnode listnode=new Listnode(n); if(head==null) { head=listnode; return;
Java实现单链表头插法、尾插法
zqq3436的博客
12-01 348
Java模拟单链表的头插法、尾插法，包括有无头引用。
java实现单链表的建立（头插法和尾插法）
unwrapping的博客
09-14 8367
单链表 单链表(Single Linked List)： 单链表是一种链式存取的数据结构，用一组地址任意（可能连续，也可能不连续）的存储单元存放线性表中的数据元素。 链表中的数据是以结点来表示的，每个结点的构成： data域–存放结点值的数据域 next域–存放结点的直接后继的地址的指针域（链域） 链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的 单链表的每个结点只有一个next域 头指针head：单链表中每个结点的存储地址是存放在其前趋结点next域中，而开始结点无前趋，故应设头指针h
数据结构与算法03 单链表
weixin_41931400的博客
02-03 356
单链表基本概念 链表的每个结点由数据域和指针域（指向后继结点的指针）构成。如图： 单链表可分为带头结点和不带头结点的单链表。带头结点的单链表，头指针head指向头结点，头结点的值域不包含任何信息，从头结点之后的结点开始存储信息。 头指针：永远指向链表中第一个结点的位置（如果链表有头结点，头指针指向头结点；否则，头指针指向开始结点）。 单链表示意图如下所示。单链表的最后一个节点的指...
（第5讲）单链表（带头结点和不带头结点）
weiyastory的博客
06-25 3590
最近在看数据结构，刚开始看链表的时候，很迷糊，什么头结点，头指针，首结点的傻傻分不清楚，现在明白啦： 1、只要是链表都有头指针，暂时用head表示；链表中的第一个结点称为首结点，最后一个结点称为尾结点 2、头结点的存在是为了方便操作，针对单链表来说，如果带头结点的话，头指针指向头结点，头结点指向首结点；如果不带头结点的话，头指针指向首结点，如果进行插入和删除操作，必须要注意是否是在链表头进行，
数据结构(Java)---链表
I_am_fine_的博客
08-03 514
数据结构（链表）
搞懂单链表常见面试题
王小六的博客
03-09 3310
搞懂单链表常见面试题 Hello 继上次的 搞懂基本排序算法，这个一星期，我总结了，我所学习和思考的单链表基础知识和常见面试题，这些题有的来自 《剑指 offer》 ,有的来自《程序员代码面试指南》，有的来自 leetCode，不是很全面，但都具有一定代表性，相信大家看完以后一定跟我一样，对面试的时候算法题又多了一份自信。 什么是单链表 链表（Linked list）是一种常...
Java-链表头插法和尾插法（小白教程）
qq_63943166的博客
11-18 501
/ 头插法//设置head的辅助结点，帮助遍历break;
图解java链表基本操作篇一（头插法和尾插法）
m0_46198325的博客
03-27 3653
图解java链表 头插法 尾插法
数据结构：Java实现线性表表中的单链表（头插法，尾插法）
qq_51066068的博客
04-04 1525
链表是最基本的数据结构，其存储的你原理图如下图所示 上面展示的是一个单链表的存储原理图，简单易懂，head为头节点，他不存放任何的数据，只是充当一个指向链表中真正存放数据的第一个节点的作用，而每个节点中都有一个next引用，指向下一个节点，就这样一节一节往下面记录，直到最后一个节点，其中的next指向null。 链表有很多种，比如单链表，双链表等等。我们就对单链表进行学习，其他的懂了原理其实是一样的。 把方法都写在一个类中，封装起来 package LinearTable.Si..
Java 链表 头插法
boyfriend_YU的博客
06-21 1233
Java 链表 头插法 /* 头插法 */ public class Node { private int data；//数据域 private Node next;//指针域 private static Node first = new Node();//生成头结点 public Node(){ this.next = null; //默认无参构造方法 } public Node(int data){ //有参构造方法 t
JAVA实现单链表，使用头插法与尾插法并打印链表
qq_57031340的博客
08-24 1420
单链表是的其中一种基本结构。在结点中数据域用来存储数据元素，指针域用于指向下一个具有相同结构的结点。因为只有一个指针结点，称为单链表。
java 如何实现单链表中的头插法
超烦豆先森
10-16 1747
java 实现头插法
java头插法实现单链表
zhangMY12138的博客
07-25 1706
import java.util.Random; //创建链表类 class MLink{ //当Mlink实例化后形成一个链表的节点对象 //节点对象中的属性 //节点存储的属性 private int data; //存储下一个链表节点地址的属性 private MLink next; /** * 功能：创建一个链表，...
java单链表的头插法和尾插法
m0_62422962的博客
07-22 206
【代码】java单链表的头插法和尾插法。
单链表头插法和尾插法
10-18
单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。单链表有两种插入方式：头插法和尾插法。 头插法是将新节点插入到链表的头部，即新节点的 next 指针指向原来的头节点，然后将新节点设置为头节点。代码实现如下： ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next def insertAtHead(head: ListNode, val: int) -> ListNode: new_node = ListNode(val) new_node.next = head return new_node ``` 尾插法是将新节点插入到链表的尾部，即找到链表的最后一个节点，将其 next 指针指向新节点。代码实现如下： ```python def insertAtTail(head: ListNode, val: int) -> ListNode: new_node = ListNode(val) if not head: return new_node cur = head while cur.next: cur = cur.next cur.next = new_node return head ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值