单向、双向链表

最新推荐文章于 2024-07-29 17:54:45 发布
最新推荐文章于 2024-07-29 17:54:45 发布
阅读量2.8k 收藏 27
点赞数 3
分类专栏： 数据结构+算法 文章标签： 链表 数据结构 单向链表 双向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43521890/article/details/121802020
版权

链表

一、介绍

1、介绍

​ 链表是一种非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点（链表中每一个元素称为节点）组成，节点可以在运行时动态生成。每个节点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域

（1）单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针

（2）双向链表(双链表)是链表的一种。和单链表一样，双链表也是由节点组成，它的每个数据节点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个节点开始，都可以很方便地访问它的前驱节点和后继节点

2、图解

（1）单向链表

在这里插入图片描述

（2）双向链表

在这里插入图片描述

二、单向链表

1、存于节点的User实体
package com.dashu.linear_structure.linked_list;

public class User {

    /**
     * 姓名
     */
    private String name;

    /**
     * 年龄
     */
    private int age;


    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }


    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
2、单向节点
public class Node {

    /**
     * 编号
     */
    private int no;

    /**
     * 用户
     */
    private User user;

    /**
     * 下一个节点
     */
    private Node next;


    public Node(int no, User user) {
        this.no = no;
        this.user = user;
    }


    public int getNo() {
        return no;
    }

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

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}
3、带头节点的单向链表
package com.dashu.linear_structure.linked_list;

import java.util.Stack;

/**
 * @Author: dashu
 * @Description: 包含头节点的链表
 * @Date: 2021/12/6 23:55
 * @Version: 1.0
 */
public class HeadLinkedList {

    /**
     * 初始化头节点
     */
    private Node headNode = new Node(0, new User("", 0));


    /**
     * 末尾添加节点
     *
     * @param node
     */
    public void add(Node node) {

        /**
         * 获取头节点
         */
        Node temp = headNode;

        /**
         * 循环遍历节点
         */
        while (true) {


            /**
             * 节点后的下一个节点为null,则链表遍历结束，退出循环
             */
            if (temp.getNext() == null) {
                break;
            }

            /**
             * 节点向后移一位
             */
            temp = temp.getNext();

        }

        /**
         * 添加节点
         */
        temp.setNext(node);

    }


    /**
     * 有序添加节点
     *
     * @param node
     */
    public void addByOrderly(Node node) {

        /**
         * 获取头节点
         */
        Node temp = headNode;


        /**
         * 循环遍历节点
         */
        while (true) {


            /**
             * 节点后的下一个节点为null,则链表遍历结束，退出循环
             */
            if (temp.getNext() == null) {
                break;
            }

            /**
             * 获取遍历节点的下一个节点的编号，判断是否与添加节点的编号相等
             *
             * 若相等的话，则可知，节点已经存在于链表
             *
             * 不可以在添加
             *
             * 抛出异常信息
             *
             */
            if (temp.getNext().getNo() == node.getNo()) {
                throw new RuntimeException("元素已存在，请勿重复添加");
            }


            /**
             * 获取遍历节点的下一个节点的编号，判断是否大于添加节点的编号
             *
             * 若大于的话，则可知，节点不存在于链表
             *
             * 且节点应该添加到当前节点的下一个节点
             *
             * 退出循环
             *
             */
            if (temp.getNext().getNo() > node.getNo()) {
                break;
            }


            /**
             * 节点向后移一位
             */
            temp = temp.getNext();

        }

        /**
         * 添加节点的下一个节点为当前节点的下一个节点
         */
        node.setNext(temp.getNext());

        /**
         * 当前节点的下一个节点为添加的节点
         */
        temp.setNext(node);

    }


    /**
     * 节点修改
     *
     * @param node
     */
    public void update(Node node) {

        /**
         * 判断头节点后的下一个节点是否为空，为空，说明链表没有数据
         */
        if (headNode.getNext() == null) {
            System.out.println("链表为空，修改失败");
            return;
        }

        /**
         * 获取头节点的下一个节点
         */
        Node temp = headNode.getNext();


        /**
         * 用于判断节点是否在链表
         */
        boolean flag = false;

        /**
         * 循环遍历节点
         */
        while (true) {


            /**
             * 节点为null,则链表遍历结束，退出循环
             */
            if (temp == null) {
                break;
            }

            /**
             * 判断遍历的节点编号是否于参数节点的编号相等
             *
             *  相等的话，则可判定该节点存在于链表中，flag = true，退出循环
             *
             *  并且修改的节点是 就是temp
             */
            if (temp.getNo() == node.getNo()) {
                flag = true;
                break;
            }


            /**
             * 节点向后移一位
             */
            temp = temp.getNext();
        }


        /**
         *  节点存在于链表
         */
        if (flag) {

            /**
             * 修改节点
             */
            temp.setUser(node.getUser());
        } else {

            /**
             *  节点不存在于链表
             */
            System.out.println("节点不存在，修改失败");
        }

    }

    /**
     * 根据编号删除节点
     *
     * @param no
     */
    public void delete(int no) {


        /**
         * 判断头节点后的下一个节点是否为空，为空，说明链表没有数据
         */
        if (headNode.getNext() == null) {
            System.out.println("链表为空，删除失败");
            return;
        }

        /**
         * 获取头节点
         */
        Node temp = headNode;

        /**
         * 用于判断节点是否在链表
         */
        boolean flag = false;

        /**
         * 循环遍历节点
         */
        while (true) {


            /**
             * 节点后的下一个节点为null,则链表遍历结束，退出循环
             */
            if (temp.getNext() == null) {
                break;
            }

            /**
             * 判断节点下一个节点的编号，是否与参数no相等
             *
             *  相等的话，则可判定该节点存在于链表中，flag = true，退出循环
             *
             *  并且节点是 temp 后的下一个节点
             */
            if (temp.getNext().getNo() == no) {
                flag = true;
                break;
            }

            /**
             * 节点向后移一位
             */
            temp = temp.getNext();

        }

        /**
         *  节点存在于链表
         */
        if (flag) {

            /**
             * 删除节点
             */
            temp.setNext(temp.getNext().getNext());

        } else {

            /**
             *  节点不存在于链表
             */
            System.out.println("节点不存在，删除失败");
        }

    }


    /**
     * 打印链表
     */
    public void print() {

        /**
         * 判断头节点后的下一个节点是否为空，为空，说明链表没有数据
         */
        if (headNode.getNext() == null) {
            System.out.println("链表为空");
            return;
        }

        /**
         * 获取头节点后的第一个节点
         */
        Node temp = headNode.getNext();

        /**
         * 循环遍历
         */
        while (true) {

            /**
             * 节点为null,链表遍历结束，退出循环
             */
            if (temp == null) {
                break;
            }

            /**
             * 打印
             */
            System.out.println("[编号：" + temp.getNo() + "用户名：" + temp.getUser().getName() + "年龄：" + temp.getUser().getAge() + "]");

            /**
             * 节点向后移一位
             */
            temp = temp.getNext();

        }

    }


    /**
     * 获取链表有效节点数（包含头节点）
     *
     * @return
     */
    public int size(Node headNode) {

        /**
         * 获取头节点
         */
        Node temp = headNode;

        /**
         * 有效节点数
         */
        int i = 0;

        /**
         * 循环遍历节点
         */
        while (true) {

            /**
             * 节点为null,则链表遍历结束，退出循环
             */
            if (temp == null) {
                break;
            }
            /**
             * 有效节点数+1
             */
            i++;

            /**
             * 节点向后移一位
             */
            temp = temp.getNext();

        }


        return i;

    }

    /**
     * 查询单链表倒数第n个节点
     *
     * @param n
     * @return
     */
    public Node getNodeByReverse(int n) {

        /**
         * 判断头节点后的下一个节点是否为空，为空，说明链表没有数据
         */
        if (headNode.getNext() == null) {
            System.out.println("链表为空，查询失败");
            return null;
        }

        /**
         * 获取链表有效节点数
         */
        int size = size(headNode);


        /**
         * 判断输入值是否大于有效节点数，如果大于，则无法取到节点
         */
        if (n < 0 || n > size) {

            System.out.println("输入值大于链表有效为节点数");
            return null;

        }

        /**
         * 有效节点数减去输入值倒序n
         * 得到的n就是正序n
         *
         */
        n = size - n;

        /**
         * 代表节点的位置
         */
        int i = 0;


        /**
         * 获取头节点
         */
        Node temp = headNode;


        /**
         * 循环遍历节点
         */
        while (true) {

            /**
             * i 等于  n,则得到查询的节点
             */
            if (i == n) {
                return temp;
            }

            /**
             * 节点位置 + 1
             */
            i++;


            /**
             * 节点向后移一位
             */
            temp = temp.getNext();

        }


    }


    /**
     * 链表反转
     */
    public void reversalHeadLinkedList() {

        /**
         * 判断头节点后的下一个节点是否为空，为空，说明链表没有数据
         */
        if (headNode.getNext() == null) {
            System.out.println("链表为空");
            return;
        }


        /**
         * 判断有效节点数是否小于3
         *
         * 小于3的话，则有效节点只有头节点和一个节点，无需反转了
         */
        if (headNode.getNext().getNext() == null) {
            System.out.println("有效节点只有2个(头节点+一个节点)，无需反转");
            return;
        }


        /**
         * 获取第一个节点
         */
        Node temp = headNode.getNext();

        /**
         * 创建一个临时节点
         */
        Node next = null;

        /**
         * 创建一个临时头节点
         */
        Node tempHeadNode = new Node(0, null);


        /**
         * 循环遍历节点
         */
        while (true) {

            /**
             * 节点为null,则链表遍历结束，退出循环
             */
            if (temp == null){
                break;
            }

            /**
             * 获取下一个节点
             */
            next = temp.getNext();


            temp.setNext(tempHeadNode.getNext());


            tempHeadNode.setNext(temp);

            /**
             * 下一个节点赋值
             */
            temp = next;
        }


        /**
         * 头节点的下一个节点设置为临时头节点的下一个节点，完成链表反转
         */
        headNode.setNext(tempHeadNode.getNext());

    }


    /**
     * 逆序打印
     */
    public void printByReverse(){

        Stack<Node> stack = new Stack<>();

        Node temp = headNode.getNext();

        while (true){

            if (temp == null){
                break;
            }

            stack.add(temp);

            temp = temp.getNext();
        }


       while (stack.size() != 0){
            Node node = stack.pop();
            System.out.println("[编号：" + node.getNo() + "用户名：" + node.getUser().getName() + "年龄：" + node.getUser().getAge() + "]");
        }

    }


    /**
     * 两个链表合并，并有序，取出重复的
     * @param headLinkedList
     * @return
     */
    public HeadLinkedList merge(HeadLinkedList headLinkedList){


        Node temp = headNode;

        Node temp2 = headLinkedList.headNode.getNext();

        Node temp3 = null;

        while (true){

            if (temp2 == null){
                break;
            }

            temp3 = temp2.getNext();

            while (true){

                if (temp.getNext() == null || temp2.getNo() < temp.getNext().getNo()){
                    temp2.setNext(temp.getNext());
                    temp.setNext(temp2);
                    temp = headNode;
                    break;
                }


                if (temp2.getNo() == temp.getNext().getNo()){
                    temp = headNode;
                    break;
                }

                temp = temp.getNext();

            }

            temp2 = temp3;


        }


        return this;




    }

}

三、双向链表

1、双向节点
public class BothwayNode {



    /**
     * 编号
     */
    private int no;

    /**
     * 用户
     */
    private User user;


    /**
     * 上一个
     */
    private BothwayNode last;

    /**
     * 下一个节点
     */
    private BothwayNode next;


    /**
     * 构造方法
     * @param no
     * @param user
     */
    public BothwayNode(int no, User user) {
        this.no = no;
        this.user = user;
    }


    public int getNo() {
        return no;
    }

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

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public BothwayNode getLast() {
        return last;
    }

    public void setLast(BothwayNode last) {
        this.last = last;
    }

    public BothwayNode getNext() {
        return next;
    }

    public void setNext(BothwayNode next) {
        this.next = next;
    }
}
2、带头节点的双向链表
public class BothwayHeadLinkedList {


    private BothwayNode headBothwayNode = new BothwayNode(-1, null);


    /**
     * 链表末尾添加
     * <p>
     * 思路：
     * <p>
     * 循环遍历链表，得到的节点x若next为null
     * <p>
     * 退出循环
     * <p>
     * 为x节点的next赋值加入的节点y
     * <p>
     * 为y节点的last赋值x节点
     *
     * @param bothwayNode
     */
    public void add(BothwayNode bothwayNode) {

        /**
         * 临时节点变量
         */
        BothwayNode temp = headBothwayNode;


        /**
         * 循环
         */
        while (true) {

            /**
             * 遍历到末尾，退出循环
             */
            if (temp.getNext() == null) {
                break;
            }

            /**
             * 节点已存在
             */
            if (temp.getNext().getNo() == bothwayNode.getNo()) {
                throw new RuntimeException("节点已存在");
            }

            /**
             * 节点向后移
             */
            temp = temp.getNext();

        }

        /**
         * 为next为null的temp赋值添加的节点
         */
        temp.setNext(bothwayNode);

        /**
         * 为添加的节点的last赋值temp
         */
        bothwayNode.setLast(temp);

    }


    /**
     * 有序添加
     *
     * @param bothwayNode
     */
    public void addByOrderly(BothwayNode bothwayNode) {

        /**
         * 临时节点变量
         */
        BothwayNode temp = headBothwayNode;

        /**
         * 循环
         */
        while (true) {


            /**
             * 遍历到末尾，退出循环
             */
            if (temp.getNext() == null) {
                break;
            }

            /**
             * 节点已存在
             */
            if (temp.getNext().getNo() == bothwayNode.getNo()) {
                throw new RuntimeException("节点已存在");
            }

            /**
             * 若节点的下一个节点的编号大于加入节点的编号，退出循环。节点应该添加到当前节点的next
             */
            if (temp.getNext().getNo() > bothwayNode.getNo()) {
                break;
            }

            /**
             * 节点向后移
             */
            temp = temp.getNext();

        }


        /**
         * 若temp为链表最后一个节点，则直接将节点添加到末尾
         */
        if (temp.getNext() == null) {

            temp.setNext(bothwayNode);
            bothwayNode.setLast(temp);

        } else {

            /**
             * 修改temp中next的节点向上指向添加的节点
             */
            temp.getNext().setLast(bothwayNode);

            /**
             * 添加的节点下一个指向temp的next节点
             */
            bothwayNode.setNext(temp.getNext());

            /**
             * temp的next指向添加的节点
             */
            temp.setNext(bothwayNode);

            /**
             * 添加的节点指向temp
             */
            bothwayNode.setLast(temp);
        }


    }


    /**
     * 根据编号删除一个节点
     *
     * @param no
     */
    public void delete(int no) {


        /**
         * 临时节点变量
         */
        BothwayNode temp = headBothwayNode.getNext();

        /**
         * 链表为空
         */
        if (temp == null) {
            System.out.println("链表为空");
            return;
        }

        /**
         * 用于判断节点是否存在于链表
         */
        boolean flag = false;

        /**
         * 循环
         */
        while (true) {

            /**
             * 遍历到末尾，退出循环
             */
            if (temp == null) {
                break;
            }

            /**
             * 节点存在，退出循环
             */
            if (temp.getNo() == no) {
                flag = true;
                break;
            }

            /**
             * 节点向后移
             */
            temp = temp.getNext();

        }


        /**
         * 节点存在
         */
        if (flag) {

            /**
             * 节点的上一个节点next指向节点的下一个节点
             */
            temp.getLast().setNext(temp.getNext());

            /**
             * 若该节点不是最后一个节点
             *
             * 则节点的下一个节点last指向节点的上一个节点
             */
            if (temp.getNext() != null) {

                temp.getNext().setLast(temp.getLast());
            }

        } else {
            System.out.println("节点不存在");
        }

    }


    /**
     * 修改节点
     *
     * @param bothwayNode
     */
    public void update(BothwayNode bothwayNode) {

        /**
         * 临时节点变量
         */
        BothwayNode temp = headBothwayNode.getNext();

        /**
         * 链表为空
         */
        if (temp == null) {
            System.out.println("链表为空");
            return;
        }


        /**
         * 用于判断节点是否存在于链表
         */
        boolean flag = false;

        /**
         * 循环
         */
        while (true) {

            /**
             * 遍历到末尾，退出循环
             */
            if (temp == null) {
                break;
            }

            /**
             * 节点存在，退出循环
             */
            if (temp.getNo() == bothwayNode.getNo()) {
                flag = true;
                break;
            }

            /**
             * 节点向后移
             */
            temp = temp.getNext();

        }

        /**
         * 节点存在
         */
        if (flag) {

            /**
             * 修改节点的user属性
             */
            temp.setUser(bothwayNode.getUser());

        } else {
            System.out.println("节点不存在");
        }


    }


    /**
     * 链表打印
     */
    public void print() {

        /**
         * 临时节点变量
         */
        BothwayNode temp = headBothwayNode.getNext();

        /**
         * 链表为空
         */
        if (headBothwayNode.getNext() == null) {
            System.out.println("链表为空...");
            return;
        }


        /**
         * 循环
         */
        while (true) {

            /**
             * 遍历到末尾，退出循环
             */
            if (temp == null) {
                break;
            }

            /**
             * 打印
             */
            System.out.println("[编号：" + temp.getNo() + "用户名：" + temp.getUser().getName() + "年龄：" + temp.getUser().getAge() + "]");


            /**
             * 节点向后移
             */
            temp = temp.getNext();

        }

    }

}
大树下躲雨
关注
  • 3
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
单向链表、双向链表
Dear
07-12 603
单向链表 链表和数组一样，都可以用于存储一系列的元素。链表的每个结点（最后一个结点除外）由一个存储元素本身的结点的数据和一个指向下一个元素的引用（指针）组成。 这有点类似于一个火车，火车的每节车厢都装着自己的东西并连接着下一节车厢（最后一节车厢除外）。 链表通常有一个head 属性（头指针）一直指向第一个结点，最后一个结点指向 null 数组与链表的对比 数组 内存中是一块连续的空间，一般需要提前分配固定的空间大小，空间利用率不高 在数组的起始位置插入和删除数据效率低，改变一个数据需要移动后续所有的数据
单链表和双向链表
南风花海的博客
11-16 1209
目前我们所学到的链表，无论是动态链表还是静态链表，表中各节点中都只包含一个指针（游标），且都统一指向直接后继节点，通常称这类链表为单向链表（或单链表）。 虽然使用单链表能 100% 解决逻辑关系为 "一对一" 数据的存储问题，但在解决某些特殊问题时，单链表并不是效率最优的存储结构。比如说，如果算法中需要大量地找某指定结点的前趋结点，使用单链表无疑是灾难性的，因为单链表更适合 "从前往后" 找，而 "从后往前" 找并不是它的强项。 单链表： 双向链表： ...
深入解析双向链表与单向链表的区别：示例详解
qq_35320456的博客
07-14 876
深入解析双向链表与单向链表的区别：示例详解。。 链表是一种灵活的数据结构，它通过指针连接一系列节点，实现了动态数组的特性。在众多链表类型中，单向链表和双向链表是最为常见的两种。本文将重点探讨这两种链表的区别，并通过示例进行详细说明。
结构与算法(03)：单向链表和双向链表
【积累】，是一个长期持续的过程。
09-18 506
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点组成，节点可以在运行时动态生成，节点包括两个部分一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。...
数据结构（二）：单向链表、双向链表
weixin_42044763的博客
02-11 2338
链表和数组一样，可以用于存储一系列的元素，但是链表和数组的实现机制完全不同。链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（有的语言称为指针或连接）组成。类似于火车头，一节车厢载着乘客（数据），通过节点连接另一节车厢。head属性指向链表的第一个节点；链表中的最后一个节点指向null；当链表中一个节点也没有的时候，head直接指向null；双向链表：既可以从头遍历到尾，又可以从尾遍历到头。
数据结构：单链表和双向链表
Jocab_jl的博客
03-12 2645
1、链表 链表是有序的列表，但是它在内存中是存储如下 小结： 链表是以节点的方，来存储是链式存储 每个节点包含data域，next域：指向下一个节点 如图：发现链表的各个节点不一定是连续存储 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点)逻辑结构示意图如下 2、单链表的应用 使用带head头的单向链表实现-水浒英雄排行榜管理完成对英雄人物的増删改査操作， 第一种方法在添加英雄时，直接添加到链表的尾部 第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
创建双向链表_双向链表_
09-30
双向链表是一种特殊类型的数据结构，与常见的单向链表相比，它具有更丰富的操作能力，可以支持前后两个方向的遍历。本篇文章将深入探讨如何创建双向链表以及其在增加和删除操作中的应用。 双向链表的每个节点不仅...
C++实现双向链表
12-17
双向链表的一个主要优点是它提供了双方向的遍历能力，这在某些场景下比单向链表更高效，比如在需要频繁地进行前后移动节点的操作时。然而，相比于数组或其他线性数据结构，链表的内存分配和访问速度较慢，因为它们...
双向链表 频度
03-26
双向链表相较于单向链表具有更强的灵活性，但也因此消耗更多的内存。 #### 二、双向链表的基本概念 在双向链表中，每个节点由三部分组成：前驱指针`prior`、数据域`data`以及后继指针`next`。此外，本例中还引入了...
lianbiao.rar_双向链表
09-24
双向链表是数据结构中的一种重要类型，它与单向链表有所不同，因为每个节点不仅包含数据，还包含两个指针，一个指向前一个节点，另一个指向后一个节点。这使得在链表中的前向和后向移动都变得非常便捷。在本资料包...
单向链表与双向链表
最新发布
qq_57106106的博客
07-29 847
可以解决顺序表存储空间上限，插入和删除效率低的问题链表：链式存储的线性表链表的组成：由一个个节点组成节点：由数据域和指针域组成数据域：存放数据的区域指针域：存放下一个节点地址的指针单向链表，双向链表，循环链表只能通过头节点或者头指针单向的访问后继节点的链表，称为单向链表。每个节点的指针域只记录其后继节点的地址。（火车结构）头节点结构体格式：int len；//头节点的数据域普通节点结构体格式：int data；//普通节点的数据域unionint len；//头节点的数据域。
单向链表和双向链表
大数据学习与分享的博客
05-08 946
1.单向链表 包含两个域，一个信息域包含当前节点的信息、一个指针域包含下一个节点的地址。这个链接指向表中的下一个节点，而最后一个节点则指向一个空值null。 单向链表只可向一个方向遍历。 查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。也可以提前把一个节点的位置另外保存起来，然后直接访问。 2.双向链表 双向链表有两个指针，分别指向当前节点的上一个节点和下一个节点。第一个节点的"前链接"指向NULL，最后一个"后连接"指向null。 可以从任何一个节点访问前一个节点，也可以访
三、单向链表和双向链表
AsiaLYF
11-07 525
单向链表和双向链表的介绍
数据结构——单向链表-双向链表
ww1106的博客
08-25 480
2、单向链表的反转——非递归方式。1、单向链表按位置修改。
了解数据结构中的单向链表和双向链表
不愿意透露姓名的网友
05-04 629
链表定义：将元素存放在通过连接构造起来的一系列存储块中 一、单链表 定义：每个节点两部分，即元素区elem和链接区next（指向下一个节点的地址） 第一个节点叫头结点 最后一个节点叫尾结点 尾结点的链接区指向空 # 创建一个节点类 class Node(): def __init__(self, elem, next=None): self.elem =...
单向链表及双向链表
苏州向日葵的博客
02-14 426
链表 #include <stdio.h> #include <stdlib.h> typedef int data_t; typedef struct linknode{ data_t data; struct linknode *next; }link_t; link_t *creat_link() { link_t *head; head = malloc(sizeof(link_t)); head->next = NULL; return head;
链表(一) -- 单链表与双向链表
JeremyIverson的博客
02-12 1540
1.1 什么是链表？ 链表是有序的列表，但是它在内存中是存储如下 特点如下： 链表是以节点的方式来存储,是链式存储 每个节点包含 data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点) 逻辑结构示意图如下 1.2 单链表的应用实例 使用带head头的单向链表实现 –水...
40.单向链表和双向链表
Rston's Notes
09-20 1413
40.1.从数组的缺陷说起 40.2.链表是什么样的 40.3.单链表的实现 40.4.单链表的算法之插入节点 40.5.单链表的算法之遍历节点 40.6.单链表的算法之删除节点 40.7.单链表的算法之逆序 40.8.双链表的引入和基本实现 40.9.双链表的算法之遍历节点
单向链表和双向链表的优缺点
03-22
单向链表和双向链表都是常见的链表数据结构，它们在存储和操作数据时有一些不同之处。 单向链表（Singly Linked List）是一种线性数据结构，它由一系列节点组成，每个节点包含一个数据元和一个指向下一个节点的指针。单向链表只能从头节点开始顺序访问，无法反向遍历。单向链表的优点是插入和删除节点的时间复杂度为O(1)，因为只需要修改指针的指向即可。然而，查找某个节点的时间复杂度为O(n)，需要从头节点开始遍历整个链表。 双向链表（Doubly Linked List）在单向链表的基础上增加了一个指向前一个节点的指针。每个节点除了包含数据元素和指向下一个节点的指针外，还包含一个指向前一个节点的指针。这样，双向链表可以从头节点或尾节点开始遍历，可以实现正向和反向遍历。双向链表的优点是在插入和删除节点时，不仅可以修改指针的指向，还可以修改前一个节点的指针，因此插入和删除操作更加灵活。但是，双向链表相对于单向链表需要额外的空间来存储前一个节点的指针。 综上所述，单向链表的优点是插入和删除节点的操作效率高，但查找节点的效率较低；双向链表相对于单向链表在插入和删除节点时更加灵活，并且可以实现正向和反向遍历，但需要额外的空间来存储前一个节点的指针。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大树下躲雨

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

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

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

打赏作者

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

抵扣说明：

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

余额充值