[单向链表与双向链表的实现]

最新推荐文章于 2022-03-12 21:25:40 发布
最新推荐文章于 2022-03-12 21:25:40 发布
阅读量633 收藏
点赞数 1
分类专栏： 算法刷题 文章标签： 链表 数据结构
版权声明：本文为CSDN博主小智RE0-李智青-原创文章,转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MrTumnus/article/details/122071968
版权

文章目录

学过Java基础集合的话,就知道链表啊;它增删比较快,查询较慢;
它是物理存储单元上非连续、非顺序的存储结构
在这里插入图片描述

比如我要给这个链表的14和6之间增加新节点56;将预备添加位置的前一个结点指针指向到它即可;

在这里插入图片描述

那么这里准备删除节点节点8呢,操作差不多,指针指向调整一下,它就完美脱离链表了;

在这里插入图片描述

链表这块的话,其实就是在操作它的指针指向;不要觉得非常难哦

单向链表

每个结点都由数据域和指针域组成，头结点的数据域不存储数据，
数据域:真实存储数据，指针域:存储后继结点。

在这里插入图片描述

package com.xiaozhi.day03linkedlist;


import java.util.Iterator;

/**
 * @author by @CSDN 小智RE0
 * @date 2021-12-21 17:20
 * 单向链表;
 */
//为达到遍历,Iterable接口
public class OneDirectionLinked<T> implements Iterable<T> {

    //链表的节点;
    class ListNode {
        //节点元素;
        T data;
        //下一个;
        ListNode next;

        //初始化;
        public ListNode(T data, ListNode next) {
            this.data = data;
            this.next = next;
        }
    }

    //头结点;
    ListNode head;
    //节点个数;
    int size;

    //初始化;
    public OneDirectionLinked() {
        this.head = new ListNode(null, null);
        this.size = 0;
    }

    //判断是否为空;
    public boolean isEmpty() {
        return this.size == 0;
    }

    //链表长度;
    public int getLength() {
        return this.size;
    }

    //清空链表;
    public void clearList() {
        //将头结点下一个节点置为空;
        head.next = null;
        size = 0;
    }

    //获取指定位置的元素;
    public T findDataByIndex(int index) {
        ListNode node = head.next;
        for (int i = 0; i < index; i++) {
            node = node.next;
        }
        return node.data;
    }

    //尾部添加节点;
    public void addNodeLast(T ele) {
        //首先找到尾部;
        ListNode ope = head;
        while (ope.next != null) {
            ope = ope.next;
        }
        //然后创建新节点;
        ListNode newNode = new ListNode(ele, null);
        //接到尾部;
        ope.next = newNode;
        //长度递增;
        this.size += 1;
    }

    //指定位置添加节点;
    public void addNodeByPosition(int po, T ele) {
        //先找到这个指定位置的前一个位置;
        ListNode opNode = head;
        for (int i = 0; i <= po - 1; i++) {
            opNode = opNode.next;
        }

        //新节点将会挂接到这个操作结点下一个节点的后面;
        ListNode insertNext = opNode.next;
        //新节点接到他前面位置的节点即可;
        ListNode newNode = new ListNode(ele, insertNext);
        opNode.next = newNode;
        this.size++;
    }

    //删除指定位置的节点;且返回这个结点值;
    public T removeNodeByPosition(int po) {
        //同样,首先找到这个待删除结点的前一个位置结点;
        ListNode opNode = head;
        for (int i = 0; i <= po - 1; i++) {
            opNode = opNode.next;
        }

        //删除节点;
        ListNode removeNode = opNode.next;
        //删除节点的后一个结点;
        ListNode removeNext = removeNode.next;
        opNode.next = removeNext;
        this.size--;

        return removeNode.data;
    }

    //查询第一个出现的节点位置;若没有就返回-1;
    public int getNodeIndexOf(T ele) {
        ListNode opNode = head;
        //遍历链表,
        for (int index = 0; opNode.next != null; index++) {
            opNode = opNode.next;
            if (opNode.data.equals(ele)) {
                return index;
            }
        }
        return -1;
    }

    //遍历的方法;
    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    //定义一个内部类实现迭代接口;
    public class MyIterator implements Iterator<T> {
        ListNode node;

        //初始化;
        public MyIterator() {
            this.node = head;
        }

        //是否有下一个节点;
        @Override
        public boolean hasNext() {
            return this.node.next != null;
        }

        //得到下一个节点的值;
        @Override
        public T next() {
            node = node.next;
            return node.data;
        }
    }
}

测试使用

package com.xiaozhi.day03linkedlist;

/**
 * @author by @CSDN 小智RE0
 * @date 2021-12-21 19:37
 */
public class Test {
    //测试
    public static void main(String[] args) {
        OneDirectionLinked<Integer> one = new OneDirectionLinked<>();
        //添加元素;
        one.addNodeLast(12);
        one.addNodeLast(13);
        one.addNodeLast(12);
        one.addNodeLast(14);
        one.addNodeLast(15);
        one.addNodeLast(16);
        //指定位置添加元素
        one.addNodeByPosition(2,123);
        //遍历;
        one.iterator().forEachRemaining(a-> System.out.print(a +"->"));
        System.out.println();
        //删除指定位置的元素;
        System.out.println("删除指定位置元素:"+one.removeNodeByPosition(4));
        one.iterator().forEachRemaining(a-> System.out.print(a +"->"));
        System.out.println();
        System.out.println("123第一次出现的位置:"+one.getNodeIndexOf(123));
    }
}

测试结果

12->13->123->12->14->15->16->
删除指定位置元素:14
12->13->123->12->15->16->
123第一次出现的位置:2

双向链表

在这里插入图片描述

package com.xiaozhi.day03linkedlist.twodirection;

import java.util.Iterator;

/**
 * @author by @CSDN 小智RE0
 * @date 2021-12-21 20:32
 * 双向链表
 */

public class DoubleDirectionLinked<T> implements Iterable<T> {
    //节点类;
    class ListNode {
        //节点数据;
        T data;
        //前置指针;
        ListNode pre;
        //后置指针;
        ListNode next;

        //初始化;
        public ListNode(T data, ListNode pre, ListNode next) {
            this.data = data;
            this.pre = pre;
            this.next = next;
        }
    }

    //头结点;不存储数据;
    ListNode head;
    //尾节点;
    ListNode tail;
    //节点的个数;
    int size;

    //初始化链表;
    public DoubleDirectionLinked() {
        this.head = new ListNode(null, null, null);
        this.tail = null;
        this.size = 0;
    }

    //获取链表的长度;
    public int getLength() {
        return this.size;
    }

    //判断链表是否为空;
    public boolean isEmpty() {
        return this.size == 0;
    }

    //清空链表;
    public void clearList() {
        this.head.pre = null;
        this.head.next = null;
        this.tail = null;
        this.size = 0;
    }

    //尾部添加新节点;
    public void addNodeToLast(T ele) {
        if (isEmpty()) {
            //若链表为空,直接让挂接到头结点后即可;
            ListNode node = new ListNode(ele, head, null);
            this.tail = node;
            this.head.next = tail;
        } else {
            ListNode initTail = this.tail;
            //直接挂接到尾节点;
            ListNode node = new ListNode(ele, initTail, null);
            initTail.next = node;
            tail = node;
        }
        this.size += 1;
    }

    //指定位置添加新节点;
    public void addNodeByPosition(int po, T ele) {
        //首先找到前一个位置的节点;以及当前需要添加节点的位置;
        ListNode preNode = head;
        for (int i = 0; i < po; i++) {
            preNode = preNode.next;
        }

        //要添加的位置;
        ListNode curNode = preNode.next;
        //要添加的新节点;
        ListNode node = new ListNode(ele, preNode, curNode);
        preNode.next = node;
        curNode.pre = node;

        this.size += 1;
    }

    //获取链表第一个节点;
    public T getFirst() {
        if (isEmpty()) return null;

        return head.next.data;
    }

    //获取末尾节点;
    public T getLast() {
        if (isEmpty()) return null;

        return this.tail.data;
    }

    //查询指定位置的元素;
    public T getDataByIndex(int index) {
        ListNode opNode = head.next;
        for (int i = 0; i < index; i++) {
            opNode = opNode.next;
        }
        return opNode.data;
    }

    //查询到节点在链表中第一次出现的位置;找不到则返回-1;
    public int getPositionByData(T ele) {
        ListNode node = head;
        for (int i = 0; node != null; i++) {
            node = node.next;
            if (node.data.equals(ele)) {
                return i;
            }
        }
        return -1;
    }

    //删除指定位置的元素;
    public T removeDataByIndex(int index) {
        //找到删除元素的前一个位置结点;
        ListNode preNode = head;
        for (int i = 0; i < index; i++) {
            preNode = preNode.next;
        }

        //需要删除的节点;
        ListNode curNode = preNode.next;
        //待删除结点的下一个节点;
        ListNode nextNode = curNode.next;
        //更改指向关系;
        preNode.next = nextNode;
        nextNode.pre = preNode;
        //元素个数减少;
        this.size -= 1;

        return curNode.data;
    }

    //实现链表的遍历;
    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }

    //使用自定义内部类完成迭代器功能;
    class MyIterator implements Iterator {
        private ListNode node;

        //初始化;
        public MyIterator() {
            this.node = head;
        }

        //判断是否还有下一个元素;
        @Override
        public boolean hasNext() {
            return node.next != null;
        }

        //得到下一个元素;
        @Override
        public Object next() {
            node = node.next;
            return node.data;
        }
    }
}

测试

public class Test {
    //测试
    public static void main(String[] args) {
        DoubleDirectionLinked<Integer> dou= new DoubleDirectionLinked<>();
        //添加元素;
        dou.addNodeToLast(12);
        dou.addNodeToLast(13);
        dou.addNodeToLast(12);
        dou.addNodeToLast(14);
        dou.addNodeToLast(15);
        dou.addNodeToLast(16);
        //指定位置添加元素
        dou.addNodeByPosition(2,123);
        //遍历;
        dou.iterator().forEachRemaining(a-> System.out.print(a +"->"));
        System.out.println();
        //删除指定位置的元素;
        System.out.println("删除指定位置元素:"+dou.removeDataByIndex(4));
        dou.iterator().forEachRemaining(a-> System.out.print(a +"->"));
        System.out.println();
        System.out.println("123第一次出现的位置:"+dou.getPositionByData(123));
        System.out.println("获取第一个元素-->"+dou.getFirst());
        System.out.println("获取第一个元素-->"+dou.getLast());
    }
}

测试结果

12->13->123->12->14->15->16->
删除指定位置元素:14
12->13->123->12->15->16->
123第一次出现的位置:2
获取第一个元素-->12
获取第一个元素-->16
小智RE0
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
单向链表改双向链表
宇宙观光巴士站
12-05 2712
单向链表改双向链表 -数据结构题目 （原题来自严蔚敏老师教材习题册2.32） 题目：已知有一个单向循环链表，其每个结点中含三个域：prior,data和next，其中data为数据域，next为指向后继结点的指针域，prior也为指针域，但它的值为空（NULL），试编写算法将此单向循环链表改为双向循环链表，即使prior成为指向前驱结点的指针域。 算法思想：先建立一个单链表，然后写一个函数，将prior指针指向它的前驱元素即可完成修改。 c++代码如下： #include <iostream>
C++实现双向链表的创建，插入，修改，删除
u012782049的专栏
12-20 2501
#include #include using namespace std; struct Node { int value; Node* pre; Node* next; }; class Double_list { private: Node*head; public: Double_list() { head=NULL; } void Create()
双向链表的实现（双向链表与单向链表的简单区别联系和实现）
weixin_47792933的博客
09-04 681
前言单向链表和双向链表的优缺点及使用场景双向链表的简单实现及图示分析 前言 之前写了一些文章简单地介绍顺序表，链表的基础知识，还总结了几道链表的笔试题，今天继续开干，向老铁们简单地介绍一下无头双向循环链表及其代码的实现。 为什么要引入无头双向循环链表呢？？？？？ 我们可以简单地这样去思考，单向链表只能单向地从头节点去访问其他的节点，不能会退的访问其他的节点，也不能循环地访问，与单向链表不同，双向链表在插入删除的时候不需要寻找前驱节点，因为本身就能回到前面一个节点，**查找时，我们可以用二分发的思路，从首节.
单向链表转换为双向循环链表
见习馒头
09-18 3280
1、单向链表转换为双向循环链表 已知 struct lknode{ int data; struct lknode *next; }*lkhead; lkhead是单向链表的头指针； struct dbnode{ int data; struct dbnode *prior, *next; } *dbhead; 需实现的函数接口为struct *dbnode doubleli
单链表改为双向循环链表
Blog
01-11 3517
package Linear; /* * 将单链表（结点有2个域pre，next，pre为空）改为双向循环链表 */ public class I { public static void doubleDirection(Node h) { Node p =h.next; Node pre =h; while (p!=null) { p.pre=pre; p=p.n...
40.单向链表和双向链表
Rston's Notes
09-20 1409
40.1.从数组的缺陷说起 40.2.链表是什么样的 40.3.单链表的实现 40.4.单链表的算法之插入节点 40.5.单链表的算法之遍历节点 40.6.单链表的算法之删除节点 40.7.单链表的算法之逆序 40.8.双链表的引入和基本实现 40.9.双链表的算法之遍历节点
把单循环链表改为双循环链表
进阶的小宋
12-07 1338
单向链表转双向链表.cpp
东哥的博客
01-05 476
/*单向链表转双向链表 * 拆分单向链表中的每一个节点，重新连接，生成双向链表 * */# include using namespace std;//辅助结构体作为链表节点struct Node1 //单向链表节点{ int value; Node1* next;};struct Node2 //双向链表节点{ int value; Node2* prev; Node2* next;};//单
主要集合概述Collection Map 单向链表 双向链表
一李
05-26 714
集合中只能存储引用类型，不能存储基本数据类型 Collection需要掌握的内容以及集合存储元素的特点 Map<Key,Value> 以键值对的形式存储元素，键特点是无序不可重复的 单向链表 单向链表中的每个元素在空间的存储位置上没有规律，顺序，那么在查找每个元素的时候必须从头节点挨着往后找 增删元素因为链表每个元素存储的空间是没有顺序的，删除或者添加某个...
单链表改造之循环+双向
smietao的博客
08-04 2517
循环链表+双向链表——《大话数据结构》摘录
单向链表和双向链表实现
啊奥的博客
07-30 801
/*单向链表*/  typedef struct MySList  {      int data;      struct MySList* next;  }ListSNode;  void  SDList()  {      int i = 0;      ListSNode *head = new ListSNode;//VS2015 C++环境下，如果是用C写的话改为 ListNode *...
单向循环链表改为双向循环链表
qq_40659154的博客
08-20 3103
/* 单项循环链表改双向循环链表 data数据域,next后继结点指针域,prior前驱结点指针域 说明： 这里的链表带头结点 */ #include <iostream> #include <cstdlib> using namespace std; const int flag = -1; typedef struct SiLinkCirList{ int data; struct SiLinkCirList *next, *prior; }*List; //创建单向循环
数据结构：单向链表的增删改查
qq_42128262的博客
04-29 871
单向链表 定义：单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有指针成员变量指向列表中的下一个结点； 数据结构： public class LinkList{ public Integer date; public LinkList next; ...
数据结构：单链表和双向链表
Jocab_jl的博客
03-12 2627
1、链表 链表是有序的列表，但是它在内存中是存储如下 小结： 链表是以节点的方，来存储是链式存储 每个节点包含data域，next域：指向下一个节点 如图：发现链表的各个节点不一定是连续存储 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点)逻辑结构示意图如下 2、单链表的应用 使用带head头的单向链表实现-水浒英雄排行榜管理完成对英雄人物的増删改査操作， 第一种方法在添加英雄时，直接添加到链表的尾部 第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果
剑指[28]_对称的二叉树
从零开始的异世界JAVA学习
11-13 982
题目来源:剑指 Offer 28. 对称的二叉树 题目描述 请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。 例如，二叉树 [1,2,2,3,4,4,3] 是对称的。 1 / \ 2 2 / \ / \ 3 4 4 3 但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的: 1 / \ 2 2 \ \ 3 3 示例 1： 输入：root = [1,2,2
剑指[42]_最大子序列之和(连续子数组的最大和)
从零开始的异世界JAVA学习
11-15 953
题目来源:剑指 Offer 42. 连续子数组的最大和 题目描述: 输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。 要求时间复杂度为O(n)。 示例1: 输入: nums = [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。 示例 2： 输入：nums = [1] 输出：1 示例 3： 输入：nums = [0] 输出：0 示例 4： 输入：nums = [-1] 输出：-1
二分查找算法复习
从零开始的异世界JAVA学习
02-11 818
首先二分查找算法是要基于当前数组为有序数组; 实际就是每次找中心点的值; 若目标数等于中心点了,直接返回即可,若目标数小于中间数,则在中心点的左侧查找,反之则在中心点的右边查找. 在实际的使用中,二分查找可以用不同模板的方式实现,那么具体在判断中心点时的规则就不一样. 从经典的基本问题入手;力扣原题704. 二分查找; class Solution { public int search
单向链表和双向链表的优缺点
最新发布
03-22
单向链表和双向链表都是常见的链表数据结构，它们在存储和操作数据时有一些不同之处。...双向链表相对于单向链表在插入和删除节点时更加灵活，并且可以实现正向和反向遍历，但需要额外的空间来存储前一个节点的指针。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小智RE0

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

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

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

打赏作者

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

抵扣说明：

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

余额充值