数据结构与算法之链表

最新推荐文章于 2023-06-21 23:29:28 发布
最新推荐文章于 2023-06-21 23:29:28 发布
阅读量273 收藏 1
点赞数 2
文章标签： 链表 数据结构 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62734392/article/details/127345588
版权

1.  链表的概念及结构

       链表是一种 物理存储结构上非连续 存储结构，数据元素的 逻辑顺序 是通过链表中的 引用链接 次序实现的 。
实际中链表的结构非常多样，以下情况组合起来就有 8 种链表结构：
1. 单向或者双向
2. 带头或者不带头
3. 循环或者非循环
那么组合起来就有8种结构, 虽然有这么多的链表的结构，但是我们重点掌握两种: 无头单向非循环链表 ,无头双向链表

2. 链表的实现

// 1、无头单向非循环链表实现
public class SingleLinkedList {
//头插法
public void addFirst(int data);
//尾插法
public void addLast(int data);
//任意位置插入,第一个数据节点为0号下标
public boolean addIndex(int index,int data);
//查找是否包含关键字key是否在单链表当中
public boolean contains(int key);
//删除第一次出现关键字为key的节点
public void remove(int key);
//删除所有值为key的节点
public void removeAllKey(int key);
//得到单链表的长度
public int size();
//打印整个链表
public void display();
//清空整个链表
public void clear();
}

1. 创建一个链表

static class ListNode {
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }

public void createList(){
        ListNode listNode1 = new ListNode(12);
        ListNode listNode2 = new ListNode(23);
        ListNode listNode3 = new ListNode(34);
        ListNode listNode4 = new ListNode(45);
        ListNode listNode5 = new ListNode(56);
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        listNode4.next = listNode5;
        this.head = listNode1;

    }

 2. 打印链表的所有元素:

    public void display(){
        if (this.head == null) {
            return ;
        }
        ListNode ret = this.head;
        while (ret != null){
            System.out.println(ret.val+" ");
            ret = ret.next;
        }
    }

 

3. 输出链表的长度

public int size(){
        int usedsize = 0;
        ListNode ret = this.head;
        while (ret != null){
            usedsize ++;
            ret = ret.next;
        }
        return usedsize;
    }

 

 4. 查找是否包含关键字key在单链表中

 public boolean contains(int key){
        ListNode ret = this.head;
        while (ret != null){
            if (ret.val == key) {
                return true;
            }
            ret = ret.next;
        }
        return false;
    }

 5. 头插法插数据元素

 public void addFirst(int data){
        ListNode node = new ListNode(data);//给一个节点
        if (this.head == null) {//空链表
            this.head = node;
        }else {
            node.next = this.head;
            head = node;
        }
    }

 6.尾插法插入数据元素

 public void addLast(int data){
        ListNode node = new ListNode(data);
        ListNode ret = this.head;
        if (this.head == null){
            this.head = node;
        }
        while (ret.next != null){
            ret = ret.next;
        }
        ret .next = node;
    }

 7. 任意位置插入节点

    //任意位置插入
    public void addIndex(int index,int data) {
        if (index < 0 || index > size()) {
            System.out.println("index 不合法!");
            throw new IndexWrongFullExcept("index 位置不合法!");
        }
        if (index == 0) {//相当于头插法
            addFirst(data);
            return;
        }
        if (index == size()) {//相当于尾插法
            addLast(data);
            return;
        }
        //插入节点
        ListNode ret = findIndexSubOne(index);
        ListNode node = new ListNode(data);
        node.next = ret.next;
        ret.next = node;
    }
    //先走index-1步,找到ret
    private ListNode findIndexSubOne(int index){
        ListNode ret = this.head;
        while (index - 1 != 0){
            ret = ret.next;
            index --;
        }
        return ret;
    }

 8. 删除第一次出现的key的节点

     public void remove(int key) {
        if (this.head == null) {
            return;
        }
        if (this.head.val == key) {
            this.head = head.next;
            return;
        }
        ListNode ret = findPrevOfKey(key);
        ListNode del = ret.next;
        if (ret == null) {
            System.out.println("没有找到要删除的数字!");
            return;
        } else {
            ret.next = del.next;
        }
    }
    //找到要删除的节点的前一个节点
    private ListNode findPrevOfKey(int key){
        ListNode ret = this.head;
        while (ret.next != null){
            if (ret.next.val == key) {
                return ret;
            }
            ret = ret.next;
        }
        return null;
    }

9. 删除所有值为key的节点

 //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNode ret = this.head.next;
        ListNode prev = this.head;
        while (ret != null){
            if (ret.val == key){
                prev.next = ret.next;
                ret = ret.next;
            }
            else {
                prev = ret;
                ret = ret.next;
            }
        }
        if (this.head.val == key){
            this.head = head.next;
        }
    }

 

10. 清空整个链表

这个很简单 我们让我们的头节点直接变成空的,是不是就清空了

  //清空整个链表
    public void clear(){
        this.head = null;

    }

 3. 自己实现一个链表的全部代码

public class MySingleList {
    //内部类表示一个节点
    static class ListNode {
        public int val;
        public ListNode next;

        public ListNode(int val) {
            this.val = val;
        }
    }

    public ListNode head;//头节点

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);//给一个节点
        if (this.head == null) {//空链表
            this.head = node;
        } else {
            node.next = this.head;
            head = node;
        }
    }

    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        ListNode ret = this.head;
        if (this.head == null) {
            this.head = node;
        }
        while (ret.next != null) {
            ret = ret.next;
        }
        ret.next = node;
    }

    //任意位置插入
    public void addIndex(int index, int data) {
        if (index < 0 || index > size()) {
            System.out.println("index 不合法!");
            throw new IndexWrongFullExcept("index 位置不合法!");
        }
        if (index == 0) {//相当于头插法
            addFirst(data);
            return;
        }
        if (index == size()) {//相当于尾插法
            addLast(data);
            return;
        }
        //插入节点
        ListNode ret = findIndexSubOne(index);
        ListNode node = new ListNode(data);
        node.next = ret.next;
        ret.next = node;
    }

    //先走index-1步,找到ret
    private ListNode findIndexSubOne(int index) {
        ListNode ret = this.head;
        while (index - 1 != 0) {
            ret = ret.next;
            index--;
        }
        return ret;
    }


    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key) {
        ListNode ret = this.head;
        while (ret != null) {
            if (ret.val == key) {
                return true;
            }
            ret = ret.next;
        }
        return false;
    }

    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        if (this.head == null) {
            return;
        }
        if (this.head.val == key) {
            this.head = head.next;
            return;
        }
        ListNode ret = findPrevOfKey(key);
        ListNode del = ret.next;
        if (ret == null) {
            System.out.println("没有找到要删除的数字!");
            return;
        } else {
            ret.next = del.next;
        }
    }
    //找到要删除的节点的前一个节点
    private ListNode findPrevOfKey(int key){
        ListNode ret = this.head;
        while (ret.next != null){
            if (ret.next.val == key) {
                return ret;
            }
            ret = ret.next;
        }
        return null;
    }

    //删除所有值为key的节点
    public void removeAllKey(int key){
        ListNode ret = this.head.next;
        ListNode prev = this.head;
        while (ret != null){
            if (ret.val == key){
                prev.next = ret.next;
                ret = ret.next;
            }
            else {
                prev = ret;
                ret = ret.next;
            }
        }
        if (this.head.val == key){
            this.head = head.next;
        }
    }

    //得到单链表的长度
    public int size(){
        int usedsize = 0;
        ListNode ret = this.head;
        while (ret != null){
            usedsize ++;
            ret = ret.next;
        }
        return usedsize;
    }
    //打印列表当中的元素
    public void display(){
        if (this.head == null) {
            return ;
        }
        ListNode ret = this.head;
        while (ret != null){
            System.out.print(ret.val+" ");
            ret = ret.next;
        }
    }
    //清空整个链表
    public void clear(){
        this.head = null;

    }
    //创建链表
    public void createList(){
        ListNode listNode1 = new ListNode(12);
        ListNode listNode2 = new ListNode(12);
        ListNode listNode3 = new ListNode(34);
        ListNode listNode4 = new ListNode(12);
        ListNode listNode5 = new ListNode(12);
        listNode1.next = listNode2;
        listNode2.next = listNode3;
        listNode3.next = listNode4;
        listNode4.next = listNode5;
        this.head = listNode1;

    }
}

那么本次链表的分享就到此结束了,下次再见

Java小白～～
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
从尾到头打印链表 -- java
滕青山博客
10-24 2193
题目描述 输入链表的第一个节点，从尾到头反过来打印出每个结点的值。 链表节点定义如下： public class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } ListNode(){} } 解题思路 使用头插法将链表反转 当链表反转过后，每个节点的值就可以从头到尾输出了。 PS： 在面试中，如果我们打算修改输入的数据，则最好先问面试官是
JavaScript数据结构与算法之链表
11-26
链表是一种常见的数据结构，也属于线性表，但不会按线性的顺序来储存数据。而是在每一个节点中，储存了下一个节点的指针。可以看图理解。(有C语言基础的可能比较好理解)。 使用链表结构可以克服数组需要预先知道数据...
java输出链表的全部内容_输入一个链表，反转链表后，输出链表的所有元素。java实现...
weixin_39916479的博客
02-26 554
反转链表 核心是反转next指针 以下是非递归实现/*public class ListNode {int val;ListNode next = null;ListNode(int val) {this.val = val;}}*/import java.util.*;public class Solution {public ListNode ReverseList(ListNode he...
Java从头到尾打印链表
越努力越幸运~~ Java领域从业者；CSDN新兴创新博主；Java领域优质创作者；书写奋斗者故事;欢迎交流学习进步；
12-08 1183
Java从头到尾打印链表。
JZ6 从尾到头打印链表(Java牛客,三种方式)
qq_62718027的博客
06-21 115
题目。
C++ 自定义单向链表 ListNode
qq_43799400的博客
02-15 1342
直接上代码： #include <iostream> #include <assert.h> #include <vector> #include <algorithm> using namespace std; /* * 链表有两种： * 1、带头结点，头结点存放的是链表的长度，从第二个节点开始存放数据。 * 2、不带头结点，没有存放链表长度的节点，从头结点开始就存放数据。 * 我这里定义的链表是第二种。 */ struct ListNode {
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
Python数据结构与算法之链表定义与用法实例详解【单链表、循环链表】
09-21
循环链表与单链表类似，区别在于最后一个节点的`next`引用指向链表的头节点，形成一个闭合的循环。循环链表在遍历和某些特定算法（如Floyd判圈算法）中有其独特优势。 7. **链表的其他变体** - **双链表**：每个...
数据结构与算法 c语言 线性表-静态链表
最新发布
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
恋上数据结构与算法课件.rar
11-23
数据结构与算法是计算机科学的基础，对于理解和设计高效的软件至关重要。本课程的资源"恋上数据结构与算法课件.rar"涵盖了多个核心概念，旨在...爱数据结构与算法，就立即行动，打开这个压缩包，开始你的学习之旅吧！
《数据结构与算法》课程上机实验二（链表）_链表_fruitd55_C++_数据结构与算法_
10-04
在计算机科学中，数据结构与算法是至关重要的基础，它们直接影响到程序的效率和性能。本次上机实验主要关注的是链表，一种常用的数据结构，它在C++中有着广泛的应用。链表不同于数组，其元素不是连续存储的，而是...
C++数据结构与算法之反转链表的方法详解
08-29
C++数据结构与算法之反转链表的方法详解 本文详细介绍了C++数据结构与算法之反转链表的方法，包括数组法、移动指针法和递归法三种实现方法，并对每种方法进行了详细的分析和比较。同时，文章还提供了完整的代码实现...
Python实现数据结构与算法——反转链表
12-21
反转链表是数据结构与算法领域中的一个经典问题，它要求我们改变链表节点的指向，使得原本顺着一个方向的链表变成逆序。在这个问题中，我们可以采用两种方法来解决：迭代和递归。 首先，让我们详细讲解迭代的解题...
数据结构与算法 实战代码
03-13
数据结构与算法是计算机科学的基础，对于任何编程领域，尤其是软件开发和系统设计，都有着至关重要的作用。在Java编程中，理解和熟练运用数据结构与算法能够显著提高程序的效率和可维护性。以下是对这些核心概念的...
JS数据结构与算法.pdf
11-01
JS 数据结构与算法.pdf 本书主要介绍了 JavaScript 语言的基础知识，包括数据结构和算法。以下是该书的详细知识点： 一、JavaScript 基础知识 * 变量和数据类型 * 运算符和控制结构 * 函数和对象 * 数组和字符串 ...
剑指offer 3. 从头到尾打印链表（ListNode,Stack,ArrayList）
DurianPudding的博客
10-19 1400
题目描述 输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。 思路： 因为不熟悉ListNode，所以看了排名第一的代码。思路是， 就是把链表倒序放入ArrayList，中间使用栈，栈先进后出，就可以自然的倒叙 知识点： ListNode是一个链表。在节点中，存储了两个变量：value 和 next。value 是这个节点的值，next 是指向下一节点的指针，维系链表节点间的关系。...
打印输出list集合
热门推荐
qq_40435659的博客
04-09 7万+
List&lt;String&gt; list = new ArrayList&lt;String&gt;();list.add("薇恩");list.add("伊泽瑞尔");list.add("卡萨丁");list.add("盲僧");list.add("卡特琳娜");//方法1for(int i = 0;i &lt; list.size();i++){    Sys
链表的从尾到头打印（四种方法）
龙跃十二
12-17 7727
一、单链表从尾到头打印的四种方法。 1、正常从尾到头打印。 用一个尾指针指到最后，尾指针每次前移移位，遇到尾指针则打印。void EndToFirstPrintNode(SListNode*ps) //正常从尾到头打印 { SListNode *cur=ps; SListNode *tail=NULL; while (ps != tail) { c
力扣中对常用数据结构ListNode TreeNode 增加打印和创建api
Ackerman2的博客
09-01 465
为方便本地ide调试力扣的链表、树类型的题。拓展增强了ListNode、TreeNode 类的定义 from typing import List class ListNode: def __init__(self, val: int = 0, next_=None): self.val = val self.next = next_ @staticmethod def creatListNode(nums: List[int]):
C++实现数据结构算法：链表与栈
"这个资源是一个C++实现的数据结构与算法的模板库，涵盖了顺序表、单链表、双向链表、循环链表以及顺序栈等基本数据结构的实现。每个数据结构都有对应的头文件（如Seqlist.h、ListNode.h等）和测试文件（如Test.cpp...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Java小白～～

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值