单链表

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

我们在Node类中实现单链表的每个节点的内容

public class Node {
    public int value;   //节点的数据
    public Node next;   //节点的引用

    //导入节点数据，next不需要初始化，默认为null
    public Node(int value) {
        this.value = value;
    }
}

为了只有一个头结点，我们在另外一个MylinkedList类中创建一个头结点

public class MyLinkedList {
    public Node head;
}

由于我们要频繁依赖头结点，所以我们在该类中实现单链表的相应方法

头插法

//头插法
    public void addFirst(int value) {
        Node node = new Node(value);
        //若一个数据都没有，直接将node节点设为头结点
        if (this.head == null) {
            this.head = node;
            return;
        }
        //节点连接
        node.next = this.head;
        this.head = node;
    }
  • 不存在头结点

在这里插入图片描述

  • 存在头结点

在这里插入图片描述

尾插法

//尾插法
    public void addLast(int value) {
        Node node = new Node(value);
        //若一个数据都没有，直接将node节点设为头结点
        if (this.head == null) {
            this.head = node;
            return;
        }
        Node cur = this.head;
        //找到尾结点，即节点的引用为null的节点（注意这里必须是cur.next，否则出现错误）
        while (cur.next != null) {
            cur = cur.next;
        }
        //节点连接
        cur.next = node;
    }

在这里插入图片描述

插入数据

//从指定位置插入数据（以0开始计数）
    public void addIndex(int pos, int index) {
        Node node = new Node(index);
        if (pos == 0) {
            addFirst(index);
            return;
        }
        int count = 0;
        //找到pos位置的前一个节点
        Node cur = this.head;
        while (count + 1 != pos) {
            cur = cur.next;
            count++;
        }
        //节点连接
        node.next = cur.next;
        cur.next = node;
    }
  • 一般插入

在这里插入图片描述

  • 在尾结点后面插入数据
    在这里插入图片描述

查找数据

//查找单链表是否包含元素data
    public boolean contains(int data) {
        Node cur = this.head;
        //遍历节点本身
        while (cur != null) {
            if (cur.value == data) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

求链表长度

//链表长度
    public int size() {
        Node cur = this.head;
        int count = 0;
        //遍历节点本身
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

清空单链表

//清空链表（从头结点开始，依次失去被引用的对象，从而实现清空单链表）
    public void clear() {
        this.head = null;
    }

删除第一个指定关键字

//删除单链表第一个关键字key
    public void delete(int key) {
        Node cur = this.head;
        //头结点的数据==key，直接指向头结点的下一个节点
        if (this.head.value == key) {
            this.head = this.head.next;
            return;
        }
        //找到节点数据为key的前一个节点
        while (cur.next != null) {
            if (cur.next.value == key) {
                cur.next = cur.next.next;
                return;
            }
            cur = cur.next;
        }
    }

  • 头结点的数据等于关键字key
    在这里插入图片描述

  • 头结点的数据不等于关键字key
    在这里插入图片描述

  • 当尾结点的数据等于关键字key时，操作与尾结点插入相似，这里不再赘述

删除单链表所有指定关键字

 //删除单链表所有关键字key
    public void deleteAll(int key) {
        Node cur = this.head;
        //因为是cur.next遍历，无法判断头结点，最后补上头结点的判断
        while (cur.next != null) {
            if (cur.next.value == key) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        //判断头结点的数据是否等于key
        if (this.head.value == key) {
            this.head = this.head.next;
        }
    }

注：由于采用了cur.next.value == key这种方式来判断节点的数据是否等于关键字key，而头结点是没有被判断过的，所以在最后面再加上对头结点数据的判断

打印单链表

//打印单链表
    public void print() {
        Node cur = this.head;
        //遍历节点本身
        while (cur != null) {
            System.out.print(cur.value + " ");
            cur = cur.next;
        }
    }
}

下面是代码部分

Node.java类

public class Node {
    public int value;   //节点的数据
    public Node next;   //节点的引用

    //导入节点数据，next不需要初始化，默认为null
    public Node(int value) {
        this.value = value;
    }
}

MyLinkedList类

public class MyLinkedList {
    public Node head;

    //头插法
    public void addFirst(int value) {
        Node node = new Node(value);
        //若一个数据都没有，直接将node节点设为头结点
        if (this.head == null) {
            this.head = node;
            return;
        }
        //节点连接
        node.next = this.head;
        this.head = node;
    }

    //尾插法
    public void addLast(int value) {
        Node node = new Node(value);
        //若一个数据都没有，直接将node节点设为头结点
        if (this.head == null) {
            this.head = node;
            return;
        }
        Node cur = this.head;
        //找到尾结点，即节点的引用为null的节点（注意这里必须是cur.next，否则出现错误）
        while (cur.next != null) {
            cur = cur.next;
        }
        //节点连接
        cur.next = node;
    }

    //从指定位置插入数据（以0开始计数）
    public void addIndex(int pos, int index) {
        Node node = new Node(index);
        if (pos == 0) {
            addFirst(index);
            return;
        }
        int count = 0;
        //找到pos位置的前一个节点
        Node cur = this.head;
        while (count + 1 != pos) {
            cur = cur.next;
            count++;
        }
        //节点连接
        node.next = cur.next;
        cur.next = node;
    }

    //查找单链表是否包含元素data
    public boolean contains(int data) {
        Node cur = this.head;
        //遍历节点本身
        while (cur != null) {
            if (cur.value == data) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    //链表长度
    public int size() {
        Node cur = this.head;
        int count = 0;
        //遍历节点本身
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

    //清空链表（从头结点开始，依次失去被引用的对象，从而实现清空单链表）
    public void clear() {
        this.head = null;
    }

    //删除单链表第一个关键字key
    public void delete(int key) {
        Node cur = this.head;
        if(cur==null){
            return;
        }
        //头结点的数据==key，直接指向头结点的下一个节点
        if (this.head.value == key) {
            this.head = this.head.next;
            return;
        }
        //找到节点数据为key的前一个节点
        while (cur.next != null) {
            if (cur.next.value == key) {
                cur.next = cur.next.next;
                return;
            }
            cur = cur.next;
        }
    }

    //删除单链表所有关键字key
    public void deleteAll(int key) {
        Node cur = this.head;
        if(cur==null){
            return;
        }
        //因为是cur.next遍历，无法判断头结点，最后补上头结点的判断
        while (cur.next != null) {
            if (cur.next.value == key) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        //判断头结点的数据是否等于key
        if (this.head.value == key) {
            this.head = this.head.next;
        }
    }

    //打印单链表
    public void print() {
        Node cur = this.head;
        //遍历节点本身
        while (cur != null) {
            System.out.print(cur.value + " ");
            cur = cur.next;
        }
    }
}
寒霏
关注
专栏目录
数据结构-单链表基本操作-C语言代码
suxiaorui的博客
01-22 6万+
单链表基本操作 1.头插法建立单链表 2.尾插法建立单链表 3.查找结点 3.修改结点 4.插入结点 5.删除结点 本篇只有c语言代码，具体思路讲解请看这篇博客：数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
使用C++实现单链表的基本操作：1、创建单链表2、遍历单链表3、单链表插入4、删除单链表5、判断是否为空6、单链表的
03-27
本文将详细阐述如何使用C++来实现单链表的基本操作，包括创建、遍历、插入、删除、判断空、计算长度以及查找节点。 首先，我们从创建单链表开始。单链表是由一系列节点组成的数据结构，每个节点包含一个数据元素和...
Java数据结构总结
qq_41534115的博客
08-09 311
Java数据结构总结 1.数组 1.1练习题 模拟生活中数据的存储(存储班上每个同学的信息)(增删改查操作).                    1):保存一个同学的信息.                    2):删除一个同学的信息.                    3):更改某一个同学的信息.                    4):查询某一个同学的信息.   ...
手把手教你LRU算法思想，从底层开始写LRU实现
weixin_43878297的博客
11-04 968
在手撕LRU算法之前，我们要先知道LRU算法是什么，思想是什么？ 所谓的LRU算法，就是Least Recently Used，就是最近最少使用算法。算法的思想就是，当我设置的LRU缓存容量为3的时候，在新加入一个容量之前，如果还有剩余容量，则直接加入，如果已经满了，则去掉最近最少使用的，也就是最远的那个。 用队列来说，就是每次我新加入一个对象都是从队头插入的，如果容量充足，则直接加入；如果容量不够了，我就要把一个元素从队尾出队之后，我在将新的元素加入进去。这样就是一个LRU的基本思想。值得注意的是，如果我
[Java]链表的打印，反转与删除
weixin_30649641的博客
06-11 63
class Node{ public int value; public Node next=null; public Node(int value) { this.value=value; } }public class LinkedList { public static void display(Node head) { for(Node cur...
Java学习笔记——泛型（一）
m0_53127728的博客
02-21 1330
概述 泛型即为参数化类型。就是将数据类型参数化，作为一种类型安全机制而产生的。 使用泛型集合时，可以将一个集合中的所有元素限定为一个特定类型，这样集合中就只能存储特定的类型的对象， 这样比较安全；并且获取集合中存储的数据时，编译器也直到这个元素的类型，不需要进行窄化处理，这样使用也比较方便。 为什么使用泛型？ 没有泛型的时候 public class node { public int value;//节点的结果 node next;//下一个连接的节点 public node(){
建立单链表
Dream_begin_的博客
01-11 5447
链表是动态地进行存储分配的一种结构，链表中的数据在内存中不必连续存放，数据之间通过指针链接起来，相比于数组结构，链表的插入和删除操作比较方便。单链表的建立链表：通过自引用结构的指针域，将各结点相互连接。关于链表的基本概念： (1)链表的第一个结点称头指针或头结点，它指向链表在内存中的首地址， (2)其后的结点是通过结点中的链节指针成员访问的。 (3)链表的最后一个结点称为尾节点。尾节点的指针域通常被设置成NULL。 (4)链表中的每一个结点是在需要的时候建立的。 (5)各结点在内存中的存储地址不一
C语言单链表
最新发布
knighthood2001
05-06 1823
int data;} Node;这里我们使用typedef将struct Node命名为Node。当然很多书以及代码中会使用到如下的int data;这里它还定义了一个指向这个结点的指针，当然对于初学者（笔者也是初学者）来说。使用*LinkList后，不太好理解，这里笔者就使用上述Node的版本。
单链表简单实现
南猿北者博客
10-31 2414
单链表逻辑图：单链表同顺序表一样，都是线性表，除了首尾节点之外，任何一个节点都有自己的前驱和后继；但是单链表每个节点在物理上的地址是不连续的或者说是随机的，也就是说单链表的节点是要一个就开一个，不会过多的开辟空间；这一点正是弥补了顺序表的不足；从上面的逻辑图我们就可以看出，每个节点的类型应该是一样的，节点主要分为数据域和指针域，同时对于一串链表来所，最后一个节点的指针域一定是NULL，以此来标记这是链表的结尾；同时我们只需要知道单链表的头节点，就可以很好的管理整个链表；
C++单链表逆序
m0_51380378的博客
07-12 1025
牛客网真题：单链表的逆序 C++的单链表逆序： 创建3个指针，分别指向当前头节点位置，空空。 先将一个指针指向头节点的下一个节点，下一个节点为当前节点的下一个节点，当前节点的下一个节点为前一个节点，前一个结点为当前节点，当前节点为下一个节点。 struct ListNode* ReverseList(struct ListNode* pHead ) { // write code here struct ListNode *pre = NULL; struct Li
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
（2）验证单链表及其基本操作的实现； （3）进一步理解算法与程序的关系，能够将单链表算法转换为对应的程序。 1.2 实验要求： （1）用头插法（或尾插法）建立带头结点的单链表； （2）对已建立的单链表实现插入、...
头歌数据结构单链表的基本操作
05-18
头歌数据结构单链表的基本操作 第1关单链表的插入操作 第2关单链表的删除操作 第3关单链表的按照序号查找值操作 第4关单链表的按照值查找结点位序的操作 第5关单链表的逆置操作 第6关两个有序单链表的合并操作 稳过 ...
用C语言实现单链表的各种操作(一)
12-25
例如，单链表的逆置，单链表的合并，找到单链表的中间节点等的算法实现。下面这个是单链表的结构体的定义： 代码如下:typedef struct LNode{ ElemType data; struct LNode *next;}LinkList;下面的基本的单链表的...
sublime执行java程序
m0_53120156的博客
03-28 1771
sublime上的java程序通过电脑命令执行 我们安装好JDK和基本配置后，我们首先在sublime中写好java程序。 假如我们写的是一个HelloWorld.java的文本文档 如图 我们用sublime打开 并写入以下代码 public class HelloWrold{ public static void main(String[] args){ System.out.println("HelloWrold!"); } } 然后我们让电脑执行相应的命令即可执行代码 我们先输入WIN+R
基于比较的常见排序方式
m0_53120156的博客
09-20 1752
几种常见的基于比较的排序方式 排序简介 交换排序 1.冒泡排序 思想: 两个相邻元素两两比较，依次向后，一趟确定一个元素位置。 说明： 冒泡排序有两层循环，第一层循坏是确定比较趟数，第二层循环确定元素位置，每确定一个元素的位置，检索数组长度减少一位。 实例： 这个数组其实第六趟已经有序了，但是程序还是会继续比较下去，因而可以设置一个状态值来判断数组是否已经有序，读者可以自行编写代码，这里不再展开。 代码： public void bubbleSort(int[] array){ for (int
验证尼科彻斯定理
m0_53120156的博客
08-30 560
验证尼科彻斯定理 尼科彻斯定理：任何一个整数 m 的立方都可以写成 m 个连续奇数之和。 例如： 1^3=1 2^3=3+5 3^3=7+9+11 4^3=13+15+17+19 5^3=21+23+25+27+29 6^3=31+33+35+37+39+41 通过观察我们不难发现： 最中间的数总是 m 的平方，只不过是偶数的话，就向两边取值。 奇数的数量等于 m 的值。 思路： 想到这里，问题就好解决了，就只有一个难点，那就是怎么得到 m 的值，注意由于通过Math类的pow方法，返回的是浮点数，且由
图书管理系统
m0_53120156的博客
06-20 513
图书管理系统 这里我们主要是了解面向对象的思想，功能方面可能不那么如尽人意（如果想要更全面的功能，可自行优化）。 这里实现的图书管理系统分为管理用户端和普通用户端。下面是他们的操作。 管理用户端： 查阅书籍 增加书籍 删除书籍 打印书籍列表 退出 普通用户端： 查询书籍 借阅书籍 归还书籍 退出 图书管理系统要有书，那么我们首先创建一个 Book 类，它存储着一本书的基本信息。 代码如下： package book; public class Book { private String n
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值