带头与不带头节点单链表

最新推荐文章于 2023-09-23 18:24:10 发布
最新推荐文章于 2023-09-23 18:24:10 发布
阅读量2.1k 收藏 9
点赞数 2
分类专栏： Java 基础知识
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44501074/article/details/102526270
版权

一、链表与顺序表区别
二、链表的结构
1、带头节点
2、不带头节点
三、实现一个带头节点的链表
方法：
1、增加（头插、尾插）
2、删除某个节点
3、输出链表
4、得到链表指定位置节点
5、逆置链表
6、得到链表长度
四、不带头结点链表
方法：
1、增加（头插、尾插）
2、删除某个节点
3、输出链表
4、得到链表指定位置节点
5、逆置链表
6、得到链表长度
7、查找链表倒数第k个节点
8、合并两个有序链表
9、逆序输出链表
10、不允许遍历链表，在 pos 前插入一个节点

一、链表与顺序表区别
顺序表：
底层实现是数组，是一段连续的内存空间；
遍历和查找元素比较容易，插入删除比较复杂；
数组的大小确定后，要更改需要花费较大的代价。

链表：
对于每一个链表来说，都有一个数据域和一个引用域，这个引用域是链表下一个节点的引用；
对于链表来说，插入删除元素容易，遍历链表相对顺序表来说困难；
同时，链表的物理位置不确定，可能是一段连续的内存空间、也可能不是一块连续的内存空间，由每个节点的引用域确定。

二、链表的结构
这里有一个技巧，也就是设计链表时用到的一个名叫头节点的东西–>head。
在带头节点的链表中，头节点的意义是：在单链表的第一个结点之前附设的一个结点
不带头节点的链表中，头节点仅仅只是标记着链表中第一个元素的位置。
1、带头节点
在这里插入图片描述
2、不带头节点
在这里插入图片描述
三、实现一个带头节点的链表

class linkedListWithHead<T> {
    // head 是指向链表中第一个节点的引用
    protected Node<T> head;

    class Node<E> {

        protected E element;//数据域
        protected Node<E> next;//引用域

        public Node(E element) {
            this.element = element;
        }

    }
	//为 head 开辟空间
    public linkedListWithHead() {
        head = new Node<>((T) new Object());
    }

    //头插
    public void addHead(T data) {
        //创建一个新节点
        Node<T> newNode = new Node<>(data);
        //绑定新节点
        newNode.next = head.next;
        head.next = newNode;
    }

    //尾插
    public void addTail(T data) {
        //创建一个新节点
        Node<T> newNode = new Node<>(data);
        Node<T> temp = head;
        //先遍历，找到最后一个节点
        while (temp.next != null) {
            temp = temp.next;
        }
        //绑定新节点
        temp.next = newNode;
    }

    //输出链表  重写 toString()方法
    public String toString() {
        StringBuilder sbr = new StringBuilder();
        Node<T> temp = head;
        while (temp.next != null) {
            sbr.append(temp.next.element + " ");
            temp = temp.next;
        }
        return sbr.toString();
    }

    //删除某个值
    public boolean delete(T data) {
        if (head.next == null) return false;
        //判断头节点是不是要被删除的元素
        if (head.element == data) {
            head = head.next;
            return true;
        }
        Node<T> temp = head;
        //在普通节点里面寻找要被删除的元素
        while (temp.next != null) {
            if (temp.next.element == data) {
                temp.next = temp.next.next;
                return true;
            }
            temp = temp.next;
        }
        return false;
    }

    //逆置链表  以头插的方式完成
    /*
    用 temp 指向链表中第一个数的引用，从第一个数开始挪
    temp = head.next;   head.next = null;
    将 temp 的后面的数即链表中第二个数先保存 tempNext = temp.next
    此时链表分为头节点、链表中第一个数、第二个数及其后的数
    此时 temp 已经孤立，可以对其操作
    把 temp 以头插的方式插入到链表中
    以此类推...
     */
    public void reverseMineLikeInsertHead() {
        //空链表则返回
        if (head.next == null) return;
        Node<T> temp = head.next;
        head.next = null;
        while (temp != null) {
            Node<T> tempNext = temp.next;
            temp.next = head.next;
            head.next = temp;
            temp = tempNext;
        }
    }

    //得到指定位置的节点元素  下标：0 1 2 3 4
    public T getIndexValue(int index) {
        //链表为空则返回
        if (head.next == null || index < 0) return null;
        Node<T> temp = head;
        while (temp.next != null && index-- > 0) {
            temp = temp.next;
        }
        if (index <= 0) {
            return temp.next.element;
        }
        //下标：0, 1, 2, 3
        return null;
        //return temp.element, 下标：1, 2, 3, 4
    }

    //得到链表长度
    public int getLength() {
        //链表为空则返回
        if (head.next == null) return -1;
        int size = 0;
        Node<T> temp = head;
        while (temp.next != null) {
            size++;
            temp = temp.next;
        }
        return size;
    }
}

四、不带头结点链表

class LinkedListWithoutHead<T extends Comparable<T>> {

    class Node<E> {

        public E element;
        public Node<E> next;

        public Node(E data) {
            this.element = data;
        }
    }

    //head 标记着链表的第一个元素
    public Node<T> head;

    public LinkedListWithoutHead() {
        head = null;
    }

    //头插
    public void addHead(T data) {
        //第一次创建的时候，newNode 是第一个节点, head是链表中第一个节点的标记
        //第二次
        Node<T> newNode = new Node<>(data);
        //当前链表中已有节点,让 head 只作为链表中第一个元素的标记
        if (head != null) {
            //此时 newNode 是第二个节点，它的 next 域是链表中第一个节点，这个节点用 head 标记
            newNode.next = head;//把 head 的引用赋给第二个节点的 next 域
            //以此类推...
        }
        //当前链表中没有节点，让 head 做标记
        //已有，更新 head
        head = newNode;
    }

    //尾插
    public void addTail(T data) {
        Node<T> newNode = new Node<>(data);
        //仍然判断链表是否为空
        if (head != null) {
            //head 是链表中第一个元素的标记，不能随便搞
            Node<T> temp = head;
            //遍历链表，找到链表中最后一个元素
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = newNode;
            //有 return 语句不用 else 语句
//            return;
        } else {//链表为空，让 head 做链表第一个元素的标记
            head = newNode;
        }
    }

    //删除
    public boolean delete(T value) {
        if (head == null) return false;
        if (value == head.element) {
            head = head.next;
            return true;
        }
        Node<T> temp = head;
        while (temp.next != null) {
            if (value == temp.next.element) {
                temp.next = temp.next.next;
            }
            temp = temp.next;
        }
        return false;
    }

    //在指定位置添加一个节点
    public boolean addInGivenPosition(T data, int pos) {
        if (pos < 0 || pos > getLength() + 1 || head == null) return false;
        Node<T> newNode = new Node<>(data);
        if (pos == 0) {
            newNode.next = head;
            head = newNode;
            return true;
        }
        Node<T> temp = head;
        //大于 1 可以添加在指定下标
        while (temp.next != null && pos-- > 1) {
            temp = temp.next;
        }
        Node<T> tempNode = temp.next;
        temp.next = newNode;
        newNode.next = tempNode;
        return true;

    }

    //以头插的方式逆置链表
    public void reverseLikeInsertHead() {
        //链表为空或只有一个节点，不用逆置
        if (head == null || head.next == null) return;
        if (head.next != null) {
            Node<T> temp = head.next;
            head.next = null;
            while (temp != null) {
                Node<T> tempNext = temp.next;
                temp.next = head;
                head = temp;
                temp = tempNext;
            }
        }
    }

    //打印链表   toString
    public String toString() {
        StringBuilder sbr = new StringBuilder();
        //此时head 指向链表中第一个元素
        Node<T> temp = head;
        while (temp != null) {
            sbr.append(temp.element + " ");
            temp = temp.next;
        }
        return sbr.toString();
    }

    //打印链表  循环
    public void showLink() {
        Node<T> temp = head;
        while (temp != null) {
            System.out.print(temp.element + " ");
            temp = temp.next;
        }
        System.out.println();
    }

    //链表长度
    public int getLength() {
        int size = 0;
        Node<T> temp = head;
        while (temp != null) {
            size++;
            temp = temp.next;
        }
        return size;
    }

    //返回指定节点
    public T getIndexValue(int index) {
        if (head == null || index < 0) return null;
        Node<T> temp = head;
        while (temp != null && index-- > 0) {
            temp = temp.next;
        }
        if (index <= 0) {
            return temp.element;
        }
        return null;
    }

    //返回链表的头
    public Node<T> getHead() {
        return head;
    }

    //设置链表的头
    public void setHead(Node<T> head) {
        this.head = head;
    }

    //合并两个有序列表
    public Node<T> mergeMyLink(Node<T> head1, Node<T> head2) {
        if (head1 == null) return head2;
        if (head2 == null) return head1;
        Node<T> curHead;
        if (head1.element.compareTo(head2.element) < 0) {
            curHead = head1;
            head1 = head1.next;
        } else {
            curHead = head2;
            head2 = head2.next;
        }
        Node<T> temp = curHead;
        while (head1 != null && head2 != null) {
            if (head1.element.compareTo(head2.element) <= 0) {
                temp.next = head1;
                head1 = head1.next;
                temp = temp.next;
            } else {
                temp.next = head2;
                head2 = head2.next;
                temp = temp.next;
            }
        }
        if (head1 == null) {
            temp.next = head2;
        } else if (head2 == null) {
            temp.next = head1;
        }
        head = curHead;
        return head;
    }

    //逆序输出单链表
    public  <T> void reversePrintList(Node<T> head){
        //递归终止条件
        if(head == null){
            return;//处理办法
        }
        //提取重复逻辑，缩小问题规模
        reversePrintList(head.next);
        System.out.print(head.element + " ");
    }

    //查找单链表中倒数第K个元素
    public T findReverseValue(LinkedListWithoutHead<T> list,int k){
        if (k <= 0 || k > list.getLength()) return null;
        //倒数第 k 个不就是 list.getLength() - k 
        int index = list.getLength() - k;
        Node<T> temp = head;
        while (temp != null && index-- >0){
            temp = temp.next;
        }
        if (index <= 0){
            return temp.element;
        }
        return null;
    }

	//查找链表倒数第k个元素  高效算法
	public Node<T> findElem(Node<T> head, int k) {
        if(k < 1 || head == null) {
            return null;
        }
        Node<T> front = head;
        Node<T> behind = head;
        /*
		搞一个快引用，一个慢引用
		让快引用先走它个 k-1 米
		当它还可以继续给后走
		快、慢一起做运动
		当快引用走到最后一个时
		慢引用恰好走到倒数第 k 个
		努力运动、好好 keep 哦
 		*/
        for(int i=0; i<k-1; i++){
            if(front.next != null){
                front = front.next;
            }else{
                return null;
            }
        }
        while(front.next != null){
            front = front.next;
            behind = behind.next;
        }
        return behind;
    }

    //不允许遍历链表，在 pos 前插入 data
    /*
    先把新节点放到 pos 后，
    把 pos.element 赋值给新的节点
    再把 data 赋值给 pos.element
    偷天换日，假装插到了 pos 前
     */
       public void NoCycleInsertBeforePos(LinkedListWithoutHead<T> list, Node<T> pos, T data){
        if (list.head == null || pos == null) return;
        Node<T> newNode = new Node<>(data);
        newNode.next = pos.next;
        pos.next = newNode;
        newNode.element = pos.element;
        pos.element = data;
    }


}
穆煲汤
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
带头结点和不带头结点的循环链表
11-24
这学期学数据结构，写了带头结点和不带头结点的循环链表，供其他在校学生参考学习，体会在链表中带头结点和不带头结点的差别
带头结点单链表、不带头结点单链表（头指针单链表）
weixin_50539337的博客
12-01 9671
1、头结点和头指针实现的区别 1.1记录链表的类型不同： 头指针是一个4字节的指针，记录第一个存储数据的结点的地址。 头结点是一个结构体变量，使用这个变量的next域来记录第一个存储数据的结点的地址，头结点的data域可以使用联合体的方式记录链表的长度。 1.2各个操作方法的定义不同 如果是头指针实现，则方法中国接受这个链表的类型必须是二级指针。 头指针实现使用一级指针就OK。 2、单链表 链表和顺序表的区别： （1）链表在逻辑存储上是连续的，在物理存储上是不连续的。 （2）单链表属于链表中的一种，每一个存
单链表：带头结点和不带头结点 总结
热门推荐
现从事游戏开发领域 | 团队项目be_with开发进行中 web方向感兴趣者私 ——We can do all things.
03-25 1万+
写在前面：        一直以来，带头结点和不带头节点的单链表的操作实现困扰着我。在没有理解和实现之前，光凭思考真的是很难理解清楚 1.两者之间代码的差异； 2.带不带头结点的区别； 3.带头结点之后，什么情况下形参必须传二级指针（或者一级指针的引用）；       ...
带头结点与不带头结点的单链表-LinkList
知行合一，止于至善
05-04 6276
1.辅助文件包Assistance.h#ifndef __ASSISTANCE_H__ // 如果没有定义__ASSISTANCE_H__ #define __ASSISTANCE_H__ // 那么定义__ASSISTANCE_H__// 辅助软件包// ANSI C++标准库头文件 #include <cstring>
数据结构-单链表（带头结点与不带头结点表示）
Yyan7777的博客
02-13 3754
单链表是线性表的链式存取结构；是用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的；
不带头节点的单链表倒置算法
10-08
本题目要求实现一个不带头节点的单链表倒置的算法，这是一个典型的链表操作问题，旨在考察对链表的基本操作和逻辑思维能力。这里我们将详细讲解如何实现这个算法，并使用C++语言进行编码。 首先，我们需要定义链表...
链表-使用C语言实现带头结点的单链表.zip
最新发布
03-13
带头结点的链表会在链表的开头添加一个特殊的节点，它的数据部分通常不存储实际数据，但用于方便链表操作，如初始化和遍历。 接下来，我们将探讨如何在C语言中定义链表节点。我们可以定义一个结构体类型来表示链表...
c++实现 不带头结点单链表基本操作
11-24
不带头结点的单链表是指链表的第一个节点没有专门的头结点，而是直接由数据节点开始。这种链表的处理在某些特定场景下更方便，但需要特别注意对链表起始位置的处理。下面将详细解释如何用C++实现不带头结点单链表的...
数据结构 不带头结点的单链表代码
12-16
首先，不带头结点的单链表意味着链表的第一个元素就是链表本身，没有额外的节点用于标识链表的起始位置。这与带头结点的链表不同，后者通常有一个特殊的头结点，用于存储链表的相关信息，并指向第一个元素。在不带头...
C++ 实现带头节点的单链表
10-11
在下最近在学数据结构，这是我写的一个单链表操作！希望可以帮到大家！
单链表———带头结点跟不带头结点的区别
weixin_46402351的博客
04-10 1万+
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、单链表：带头结点跟不带头结点二、使用步骤总结 前言 数据结构中单链表的创建 带头结点跟不带头结点的区别 一、单链表：带头结点跟不带头结点 指针：通常使用“头指针”来标识一个链表，如单链表L，头指针为NULL的时表示一个空链表。链表非空时，头指针指向的是第一个结点的存储位置。 头结点：在单链表的第一个结点之前附加一个结点，称为头结点。头结点的Data域可以不设任何信息，也可以记录表长等相关信息。若链表是带有头结点的，则头指.
【考研】分清带头结点和不带头结点的单链表
qq_34438969的博客
10-09 4651
为分清带结点与不带头结点的单链表操作，本文以图文和表格形式描述了两者之间的区别。考研中，数据结构的单链表操作是重要考点，其中，比较常考带头结点的链表操作。本文包含了带头结点的插入、删除、查找、用前插法和后插法创建单链表等基本操作。【考研】数据结构考点——直接插入排序_住在阳光的心里的博客-CSDN博客【考研】单链表相关算法（从基础到真题）_住在阳光的心里的博客-CSDN博客。
数据结构（2）—单链表（带头结点和不带头结点）
qq_61914039的博客
08-31 3050
单链表是通过一组任意的存储单元来存储线性表中的数据元素。每个结点都有data数据域（用来存放数据元素）和next指针域（用来存放后继节点的地址）。对于顺序表，单链表可以解决顺序表需要一整个大量的连续的存储单元的缺点，单链表的元素可以离散地分布在存储空间中，即非随机存取的存储结构，不能直接找到表中某个特定的结点，当查找某个特定的结点时，需要从表头开始一个一个遍历。因为单链表附加了指针域，缺点就是存储空间增大。单链表有带头结点和不带头结点两种类型。引入头结点。
【链表】带头节点和不带头节点单链表的区别
风铃的博客
12-11 8122
目录 ????当链表的结点只包含一个指针域时，叫做单链表 ????不论带不带头节点，所有的链表都要有个头指针！ ????带头结点的链表的头指针指向的是头结点，头结点的指针域指向首元结点 ????不带头结点的头指针直接指向首元结点 ????初始化 ????2.带头节点的初始化 ????不带头节点的初始化 ????判空条件 ????带头节点 ????不带头节点 ????操作上有区别 ????带头节点 ????不带头节点 ????当链表的结点只包含一个指针域时，叫做单链表 ?
数据结构学习笔记——线性表的链式表示（单链表带头结点和不带头结点的基本操作）
小宇y的博客
04-10 8317
目录单链表的相关知识点（一）单链表的定义（二）单链表的初始化和空表判断（三）单链表的建立（四）单链表的输出（五）单链表的逆序输出（六）单链表的插入操作（七）单链表的删除操作（）（） 单链表的相关知识点 单链表是链式存储的，其每个结点除了存放数据元素之外，还存储指向下一个结点的指针；而顺序表是顺序存储的，其每个结点只存放数据元素。【顺序存储结构可以随机存取、顺序存取，而链式存储结构只能顺序存取】 顺序存储结构不仅可用于存储线性结构，还能用于树、图。 若需对表进行频繁的插入、删除操作，此时适合选链式存储。 一
有头结点和没有头结点的单链表
qq_63133045的博客
04-24 2195
在我们遇到的大多数题中，一般都是有头结点的单链表。这里我们可以把没有头结点的单链表看成我们的特殊情况，接下来，我们将从有头结点的单链表和没有头结点的单链表的定义，插入一个元素，删除一个元素等方面进行对比。 有头结点的单链表和没有头结点的单链表的定义： typedef int ElemType; typedef struct LNode { ElemType data; struct LNode* next; }LNode,*LinkList; 带头结点的单链表的按位插入 bool ListI
如何理解链表带头节点和不带头节点
ntr851217的博客
09-23 1584
首先我们要知道什么是链表的头节点和头指针，两者有什么区别，弄清这一点我们才能更好的理解带头指针和不带头节点有什么优势和劣势。头指针什么是头指针？头指针是指向链表中第一个有效节点的指针。它通常是链表的起始点，用于访问链表的第一个元素。头结点什么是头节点？头结点是链表中的第一个节点，但它不存储实际数据，仅用于辅助管理链表。首元节点什么是首元节点？首元结点是链表中存储实际数据的第一个节点。通常，头结点之后的节点是首元结点，但在某些链表中，首元结点也可能是头结点本身。
带头结点单链表 和 不带头结点单链表的区别
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
11-12 1万+
文章目录不带头结点的操作代码①代码②代码③代码④带头结点的操作代码⑤ 下面的代码中，传递链表时，传的是头指针。如果是带头结点的链表，传递链表时，可以传头结点，具体可以看看 C语言实现-线性表的链式存储(单链表) 带头结点单链表 和 不带头结点单链表的区别： 带头结点单链表，在进行插入、删除操作时，不需要改变链表头指针。 不带头结点的单链表，在进行插入、删除操作时，可能会涉及到链表头指针的修改（所以链表作为参数传递时，传递的是头指针的引用，具体可看代码④中head_insert方法中的指针变量带了
C语言——链表（带头节点与不带头节点）
m0_73771309的博客
07-18 1264
链表是一种常见的线性数据结构，它由一系列的节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点可以在内存中不连续地分布，通过指针将它们串联在一起。下面呢，进入正题！！！首先呢，我们先看这张图！这是带头节点，带头节点的链表是在链表头部添加了一个额外的节点，该节点不存储任何数据，只是作为链表的起始位置。带头节点的链表中，头节点的下一个节点才是实际存储数据的第一个节点。
单链表不带头节点的建表
03-21
可以使用如下代码实现单链表不带头节点的建表： ``` #include #include typedef struct Node { int data; struct Node *next; } Node; Node *createList() { Node *head = NULL, *tail = NULL; int x; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值