数据结构和算法学习第二节 链表

最新推荐文章于 2023-11-03 11:28:07 发布
最新推荐文章于 2023-11-03 11:28:07 发布
阅读量289 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GayFei/article/details/112518034
版权

链表

单链表

单链表概述

    基本介绍
    链表示有序的，但是存储的地址不一定示连续的，存储示意如图下：
在这里插入图片描述
    简要说明，head头指针指向的是 data域a1，a1的next域指向下一个存储的节点，链表存储的数据并不一定是连续的。
    1、链表是以节点的方式存储的
    2、每个节点包含data域(存储数据)、next域指向的下一个存储的节点
    3、链表的各个节点不一定是连续存放的
    4、链表可以有头节点，也可以不包含头节点
    逻辑结构示意图如下
在这里插入图片描述

单链表实现

    实现一个单向链表->完成单链表的增加、删除、修改、查找
在这里插入图片描述
    代码实现

package com.example.data.sparse.linked;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.util.Objects;
import java.util.UUID;

/**
 * @author zjt
 * 单链表实现
 */
public class MineSingleLinkedList<E> {

    // 头节点 不存放具体数组就是表示单链表的头 也不要动 就表示一个链表的头
    Node<E> head = new Node<>(null, null);

    // 新增一个节点到单链表
    // 1、只在链表的尾部增加
    // 2、将最后一个节点的next 指向新的节点
    public void add(E e) {
        // 需要一个临时变量 temp 用于遍历链表，找到最后一个节点
        Node<E> temp = this.head;
        // 遍历链表 找到链表的尾节点
        while (temp.next != null) {
            // 没有找到指针后移
            temp = temp.next;
        }
        temp.next = new Node<>(e);
    }

    // 指定下标插入
    public void add(int index, E e) {
        // 头部节点不动  依旧通过辅助变量temp来帮助找到需要添加的位置
        // 因为是单链表 所以找到的temp是位于 添加位置的钱一个节点 否则添加会出现问题
        Node<E> temp = this.head;
        for (int i = 0; i < index; i++) {
            if ((temp = temp.next) == null) {
                throw new IndexOutOfBoundsException(String.format("Index:%d, Size:%d", index, i));
            }
        }
        // 插入到链表中
        temp.next = new Node<>(e, temp.next);
    }

    // 单链表的修改
    // 这里简单实现根据下标修改
    public void update(int index, E e) {
        if (head.next == null) {
            throw new RuntimeException("链表为空");
        }
        Node<E> temp = head.next;
        for (int i = 0; i < index; i++) {
            if ((temp = temp.next) == null) {
                throw new IndexOutOfBoundsException(String.format("Index:%d, Size:%d", index, i));
            }
        }
        temp.item = e;
    }

    // 删除节点
    // 1、找到待删除节点的前一个节点
    // 2、临时变量 e == temp.next.item
    // 3、被删除的节点 将不会有其它引用指向，会被垃圾回收机制回收
    public void remove(E e) {
        if (head.next == null) {
            throw new RuntimeException("链表为空");
        }
        Node<E> temp = head;
        while (temp.next != null) {
            // 找到待删除节点的前一个节点
            if (e.equals(temp.next.item)) {
                temp.next = temp.next.next;
            } else {
                temp = temp.next;
            }
        }
    }

    // 显示链表
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 头节点不要动 需要一个辅助变量遍历
        Node<E> temp = head.next;
        while (temp != null) {
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移
            temp = temp.next;
        }
    }

    private static class Node<E> { // 静态内部类用于处处数据节点

        E item; // 存储的数据

        Node<E> next; // 下一个节点的引用

        // 构造器
        protected Node(E item, Node<E> next) {
            this.item = item;
            this.next = next;
        }

        public Node(E item) {
            this.item = item;
            this.next = null;
        }

        @Override  // 显示方便
        public String toString() {
            return "Node{" +
                    "item=" + item +
                    '}';
        }
    }

}

@Getter
@Setter
@ToString
//@Data 不使用这个 @Data会重写很多我们不需要的方法 导致调试出现意外
class User {

    private Integer id;

    private String name;

    private String mobile;

    public User(Integer id, String name, String mobile) {
        this.id = id;
        this.name = name;
        this.mobile = mobile;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (!Objects.equals(id, user.id)) return false;
        if (!Objects.equals(name, user.name)) return false;
        return Objects.equals(mobile, user.mobile);
    }

    @Override
    public int hashCode() {
        int result = id != null ? id.hashCode() : 0;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + (mobile != null ? mobile.hashCode() : 0);
        return result;
    }
    
}

class Client {

    public static void main(String[] args) {
        MineSingleLinkedList<User> singleLinkedList = new MineSingleLinkedList<>();
        System.out.println("实现尾节点新增");
        for (int i = 0; i < 4; i++) {
            if (i == 2) {
                continue;
            }
            User user = new User(i, UUID.randomUUID().toString(), "1339890999" + i);
            singleLinkedList.add(user);
        }
        singleLinkedList.list();
        // 插入位置3元素
        System.out.println("实现插入节点新增");
        User user = new User(2, UUID.randomUUID().toString(), "1111");
        singleLinkedList.add(2, user);
        singleLinkedList.list();
        System.out.println("实现指定下标修改");
        singleLinkedList.update(0, user);
        singleLinkedList.list();
        System.out.println("实现equals删除所有");
        singleLinkedList.remove(user);
        singleLinkedList.list();
    }
    
}

     为了使单链表更好用，可以添加更多的额外属性，比如尾节点 tail，链表长度size等属性。

单链表案例

    案例一
    在上述代码中已经实现的单链表，获取单链表的节点的个数，(如果是头节点仅指向下一个节点，没有存放数据，需要不统计头节点)

 // 获取单链表的节点的个数
    public int getListSize() {
        // 这个例子头节点没有存储数据 不能统计这个头节点
        Node<E> temp = head.next;
        if (temp == null) {
            return 0;
        }
        int size = 0;
        while (temp != null) {
            size++;
            temp = temp.next;
        }
        return size;
    }

    案例二
    获取单链表的倒数第n个元素

    // 获取单链表的倒数第n个节点
    // 思路一
    // 1、方法接收一个index 就是倒数n个节点
    // 2、先把链表遍历一遍获取链表的长度size
    // 3、获取到size后，从链表的第一个开始遍历 size - index个就是链表的倒数第n个节点
    // 4、存在节点返回 不存在返回null
    public E getLastIndexNode1(int index) {
        // 获取链表的长度
        assert index > 1;
        int size = this.getListSize();
        if (head.next == null || size < index) {
            return null;
        }
        int nodeIndex = size - index;
        Node<E> temp = head.next;
        for (int i = 0; i < nodeIndex; i++) {
            temp = temp.next;
        }
        return temp.item;
    }

    // 获取单链表的倒数第n个节点
    // 思路二
    // 1、方法接收一个index
    // 2、声明两个临时变量，其中一个遍历index次 第二个变量开始遍历，
    // 3、遍历完成第二个临时变量就是倒数第index个元素
    public E getLastIndexNode2(int index) {
        if (head.next == null) {
            return null;
        }
        assert index > 1; // index 须大于0
        Node<E> temp = head.next;
        Node<E> temp1 = head.next;
        // 分成两个循环写 方便理解
        // 1、先将变量 temp 后移index 次
        for (int i = 0; i < index; i++) {
            if (temp == null) {
                return null;
            } else {
                temp = temp.next;
            }
        }
        // 2、两个变量一起后移 temp后移 直至没有元素
        while (temp != null) {
            temp = temp.next;
            temp1 = temp1.next;
        }
        return temp1.item;
    }

    案例三
    单链表的反转

    // 单链表的反转
    // 思路1 新建链表 头插法实现
    public void reverseList() {
        if (head.next == null || head.next.next == null) {
            // 当前链表为空 或者只有一个节点无需反转
            return;
        }
        // 临时变量
        Node<E> temp = head.next;
        // 清空链表
        head = new Node<>(null);
        while (null != temp) {
            addHeadNode(temp.item);
            temp = temp.next;
        }
    }

    // 链表头插法 每次都新增在链表的第一个位置
    public void addHeadNode(E e) {
        Node<E> temp = head.next;
        head.next = new Node<>(e, temp);
    }

    // 单链表反转
    // 思路二 类似于头插法
    public void reverseList1() {
        if (head.next == null || head.next.next == null) {
            // 当前链表为空 或者只有一个节点无需反转
            return;
        }
        Node<E> current = head.next; // 当前节点 辅助指针 用于遍历链表
        Node<E> next; // 指向当前节点[current]的下一个节点
        Node<E> reverseNode = new Node<>(null); // 设置一个反转的头节点
        // 遍历原来的链表 每遍历一个节点 就将其取出并放在新链表的 reverseNode 的最前端
        while (current != null) {
            next = current.next; // 暂时保存当前节点的下一个节点
            current.next = reverseNode.next; // 将current的下一个节点 指向新的链表的最前端
            reverseNode.next = current; // 将 反转的头节点下一个节点 指向 当前节点 current 连接到新的链表上
            current = next; // 指针后移
        }
        head.next = reverseNode.next;
    }

    案例4
    逆序打印单链表

    // 逆序打印单链表
    // 思路一：根据上面实现的单链表反转方法，先反转再打印。缺点：破坏了原有的链表结构
    // 思路二：利用递归的方式打印 缺点 因为这里头节点仅作为引用 并不实际存放数据 所以打印会将头节点的null 打印出来
    public static <E> void printfListReverseByRecursive(Node<E> head) {
        if (head.next != null) {
            printfListReverseByRecursive(head.next);
        }
        System.out.println(head.item);
    }

    // 思路三 使用栈的特性逆序打印
    public void printfListReverseByStack() {
        // 空链表 不打印
        if (head.next == null) {
            return;
        }
        // 遍历入栈
        Stack<E> stack = new Stack<>();
        Node<E> temp = head.next;
        while (temp != null) {
            stack.push(temp.item);
            temp = temp.next;
        }
        // 出栈
        while (!stack.isEmpty()) {
            System.out.println(stack.pop());
        }
    }

单向链表解决约瑟夫问题

    约瑟夫问题，假设编号1，2，3 …n个人，约定号码k(1<=k<=n)的数字，从k的位置开始数，数到m的人出列，下一个人从1开始数，依此类推直到所有人出列，产生一个出队编号。
    假定 n =5 有5个人,k=1 第一个位置开始,m=2 每数到2的人出列。
在这里插入图片描述
    出圈顺序是 2 -> 4 -> 1 -> 5 -> 3
    构建一个环形单向链表思路
    1、先创建第一个节点，让head指向该节点，并形成环形
    2、后面每当我们新增一个节点，就把该节点加入到已有的环形链表中。
    遍历环形链表
    1、借助辅助遍历temp 指向head节点，然后通过while循环遍历环形链表，temp == head 结束。
    约瑟夫问题代码实现

package com.example.data.sparse.linked;

/**
 * @author zjt
 * 约瑟夫问题
 */
public class Joseph {

    public static void main(String[] args) {
        RingLinkedList<Integer> list = new RingLinkedList<>();
        for (int i = 1; i <= 125 ; i++) {
            list.add(i);
        }
        System.out.println();
        list.getJoseph(10,20);
    }

}

class RingLinkedList<E> {

    // 头节点
    Node<E> head;

    // 尾节点
    Node<E> tail;

    // 链表的节点个数
    int size = 0;

    // 使用尾插法新增数据
    // 形成一个环状，让尾节点的next 指向头节点这样就形成一个环状
    public void add(E e) {
        // 当前的尾节点
        Node<E> t = this.tail;
        Node<E> newNode = new Node<>(e, null);
        // 将新节点作为尾节点
        tail = newNode;
        if (t == null) { // 新增时链表是空的
            // 赋值头节点
            head = newNode;
        } else {
            // 不是空链表
            // 将之前的尾节点的next 指向新的节点
            t.next = newNode;
        }
        size++;
        // 让尾节点的next 指向头节点
        tail.next = head;
    }

    // 遍历当前循环链表
    public void show() {
        Node<E> temp = this.head;
        if (temp == null) {
            System.out.println("空链表");
            return;
        }
        while (true) {
            System.out.println(temp.toString());
            if (temp.next == head) {
                break;
            }
            temp = temp.next;

        }
    }

    // 约瑟夫环出队问题  1 <= K <= this.size 表示从第几个开始 m 表示数几次出圈
    public void getJoseph(int k, int m) {
        if (head == null || k < 0 || k > size) {
            return;
        }
        // 创建临时变量 辅助约出圈问题
        Node<E> helper = head; // 指向头节点
        Node<E> temp = tail; // 指向尾节点 它的下一个节点是头节点
        // 出圈报数前先根据需求后移k-1次
        // 例如后移2
        for (int i = 0; i < k - 1; i++) {
            helper = helper.next;
            temp = temp.next;
        }
        // 当元素报数时，temp 和 helper需要后移 m-1次 然后出圈
        while (true) {
            if (helper == temp) { // 说明圈中仅有一个节点
                break;
            }
            for (int i = 0; i < m - 1; i++) {
                temp = temp.next;
                helper = helper.next;
            }
            // 此时temp 指向的节点 就是需要出圈的节点
            System.out.println("出圈的节点为：" + helper.item);
            // 将temp 指向的节点出圈
            helper = helper.next;
            temp.next = helper;
        }
        System.out.println("最后留在圈中的节点:" + helper.item);

    }


    private static class Node<E> {

        E item;

        Node<E> next;

        public Node(E item, Node<E> next) {
            this.item = item;
            this.next = next;
        }

        @Override
        public String toString() {
            return "Node{" +
                    "item=" + item +
                    '}';
        }
    }
}

    
    
    
    
    
    

双向链表

概述

    基本介绍：
    1、双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。
    与单向链表对比
    1、单向链表的查找方向智能从头到尾的方向查找，而双向链表可以从任意一个节点向前或者向后查找。
    2、单向链表不能自我删除，需要依靠一个辅助节点（总是需要找到辅助节点的前一个节点来删除），而双向链表可以进行自我删除。
在这里插入图片描述
    双向链表添加、修改、删除、遍历思路分析
    添加(创建) 插尾法
    1、先找到双向链表的最后一个节点
    2、temp.next = newNode
    3、newNode.prev = temp
    修改：思路与单向链表基本一致
    删除：
    1、双向链表可以实现自我删除某个节点
    2、直接找到需要删除的节点 delNode
    3、delNode.prev.next = delNode.next
    4、delNode.next.prev= delNode.prev
    遍历：思路与单向链表一致，但是可以向前、向后遍历

package com.example.data.sparse.linked;

import java.util.UUID;

/**
 * @author zjt
 * 双向链表
 * 没有考虑线程安全问题
 */
public class MineBothWayLinkedList<E> {

    // 声明一个头节点 跟上面的单链表有所区别 头节点存储数据
    Node<E> head;

    // 声明一个尾节点 目的是使用起来更加方便
    Node<E> tail;

    // 这里新增时使用 ++ 删除时使用-- 没有考虑线程安全问题
    int size = 0;

    public MineBothWayLinkedList() { // 构造器
    }

    // 尾插法新增节点
    public void addTail(E e) {
        // 取出尾一个节点
        Node<E> t = tail;
        // 新建节点
        Node<E> newNode = new Node<>(t, e, null);
        // 将新节点作为尾节点
        tail = newNode;
        if (t == null) { // 新增时链表是空的
            // 赋值头节点
            head = newNode;
        } else {
            // 不是空链表
            // 将之前的尾节点的next 指向新的节点
            t.next = newNode;
        }
        size++;
    }

    // 头插法新增节点
    public void addHead(E e) {
        // 取出头节点
        Node<E> h = head;
        // 新建节点
        Node<E> newNode = new Node<>(null, e, h);
        // 新节点作为头节点
        head = newNode;
        if (h == null) { // 头节点为空 证明是空链表
            tail = newNode; // 赋值尾节点
        } else {
            h.prev = newNode; // 将之前的头节点的 前驱节点指向 新的头节点
        }
        size++;
    }

    //指定下标新增节点
    public void addByIndex(int index, E e) {
        if (index > size) {
            // 指定下标大于链表长度 抛出异常
            throw new IndexOutOfBoundsException(String.format("Size %d; index %d", size, index));
        }
        if (index == 0) { // 新增头节点
            addHead(e);
        } else if (index == size) { // 新增尾节点
            addTail(e);
        } else {
            // 找到需要新增节点 的前一个节点（前驱节点）
            Node<E> temp = this.head;
            // 链表的遍历 性能不高，这里为了省事 就直接循环遍历了 可以优化
            for (int i = 1; i < index; i++) {
                temp = temp.next;
            }
            // 新增节点的前驱节点就是 临时变量 temp 后继节点 是 temp.next
            Node<E> newNode = new Node<>(temp, e, temp.next);
            // 后继节点的 前驱节点 要变更尾 新节点
            temp.next.prev = newNode;
            // 前驱节点的 后继节点 是新节点
            temp.next = newNode;
            size++;
        }
    }

    // 删除节点
    public void remove(E e) {
        if (head == null || e == null) {// 空链表无法移除
            return;
        }
        Node<E> temp = this.head;
        while (temp != null) {
            if (e.equals(temp.item)) {
                // 准备删除该节点
                Node<E> prev = temp.prev; //前驱节点
                Node<E> next = temp.next; // 后继节点
                if (prev == null) { // 前驱节点为空 删除的节点是头节点
                    head = next; // 当前节点的后继节点作为头节点
                } else { // 前驱节点不为空
                    prev.next = next; // 前驱节点的后继节点指向 当前节点的后继节点
                    temp.prev = null; // 当前节点与前驱节点断开连接
                }

                if (next == null) { // 尾节点
                    tail = prev; // 删除的是尾节点 将当前节点的前驱节点 设置为尾节点
                } else {
                    next.prev = prev;// 后继节点的前驱节点 修改为当前节点的前驱节点
                    temp.next = null; // 当前节点与后继节点断开连接
                }
                size--;
                temp.item = null; // 移除与具体元素的引用
            }
            temp = temp.next;
        }
    }

    // 根据下标修改链表元素
    public void update(int index, E e) {
        if (null == head) { // 空链表 啥也不干
            return;
        }
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException(String.format("Size %d; index %d", size, index));
        }
        Node<E> temp = this.head;
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        temp.item = e;
    }

    // 显示链表
    public void show() {
        if (head == null) {
            System.out.println("链表为空");
            return;
        }
        // 需要一个辅助变量遍历
        Node<E> temp = head;
        while (temp != null) {
            // 输出节点的信息
            System.out.println(temp);
            // 将temp后移
            temp = temp.next;
        }
    }

    public int getSize() {
        return size;
    }


    private static class Node<E> { // 静态内部类用于处处数据节点

        E item; // 存储的数据

        Node<E> next; // 下一个节点的引用

        Node<E> prev;// 上一个节点的引用

        // 构造器
        protected Node(Node<E> prev, E item, Node<E> next) {
            this.prev = prev;
            this.item = item;
            this.next = next;
        }

        @Override  // 显示方便
        public String toString() {
            return "Node{" +
                    "item=" + item +
                    '}';
        }
    }

}

class Client2 {

    public static void main(String[] args) {
        MineBothWayLinkedList<User> singleLinkedList = new MineBothWayLinkedList<>();
        System.out.println("实现尾节点新增");
        for (int i = 0; i < 4; i++) {
            User user = new User(i, UUID.randomUUID().toString(), "1339890999" + i);
            singleLinkedList.addTail(user);
        }
        singleLinkedList.show();
        // 测试头节点新增
        System.out.println("测试头节点新增");
        User user = new User(4, UUID.randomUUID().toString(), "13398909994");
        singleLinkedList.addHead(user);
        singleLinkedList.show();
        // 插入新增
        System.out.println("插入新增");
        User user1 = new User(2001, UUID.randomUUID().toString(), "1339");
        singleLinkedList.addByIndex(3, user1);
        singleLinkedList.show();
        System.out.println(singleLinkedList.getSize());
        System.out.println("删除节点");
        singleLinkedList.remove(user);
        singleLinkedList.show();
        System.out.println(singleLinkedList.getSize());
        System.out.println("删除节点");
        singleLinkedList.remove(user1);
        singleLinkedList.show();
        System.out.println(singleLinkedList.getSize());
        System.out.println("修改节点");
        singleLinkedList.update(3, user1);
        singleLinkedList.show();
        System.out.println(singleLinkedList.getSize());
    }
}
瑾年丶深蓝
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构之单链表（带头节点）
mly15191882818的博客
08-04 2130
今天来聊聊单链表。单链表是以节点存的链式结构，分为带头节点和不带头节点的单链表。单链表中的节点包括data域和next域，data域存储元素的值，next域则存储下一个节点的地址。单链表中的各个节点在内存中不一定是连续存储的，存储形式如下图所示： 从图中可以看出，单链表中的各个节点并不是连续存储的。带头结点的单链表结构图如下图所示： 聊完单链表的基本知识，下面以对明星节点的增删改查操作为案例，实现对单链表的增删改查操作。 先说明节点结构： public class Node { p
数据结构和算法（四）链表--单链表
思想累积的博客
06-01 454
1、链表（Linked List）介绍 链表是有序的列表 链表以节点的方式存储数据，链式存储 每个节点包含 data 域，next 域：指向下一个节点 链表的各个节点不一定是连续存储 链表分为带头节点的链表和没有头结点的链表，head 节点不存放具体数据，表示单链表头 next 在下面的代码中定义 Node 作为链表内每个节点元素 // 定义 Node，每个 Node 对象是一个节点 class Node{ public int no; // 每个 Node 的编号 public Str
数据结构 实验二 单链表（带头结点）
m0_72619231的博客
03-28 635
思路：单链表的每个结点都有数据域data和指针域next;
单链表的查找(按值查找、按位查找)(数据结构与算法)
AII_IIA的博客
11-03 4965
什么是单链表？单链表是一种常见的链式数据结构，用于存储和操作数据元素的集合。它由一系列的节点组成，每个节点包含两个部分：数据域和指针域。单链表的每个节点包含了存储数据的数据域，以及指向下一个节点的指针域。通过这些指针域，节点之间可以按顺序连接起来，形成一个链式结构。链表的最后一个节点通常指向一个特殊的空节点（NULL或nullptr），表示链表的结束。相比于数组，链表的一大优势是它的动态性。在链表中，节点的添加、删除可以通过修改指针的指向来完成，不需要像数组那样进行元素的移动。
设单链表的表头指针为L,结点结构由data和next两个域构成，其中data域为字符型，试设计算法判断该链表的全部n个字符是否中心对称。
qq_44750091的博客
11-08 4801
算法设计： 设单链表的表头指针为L,结点结构由data和next两个域构成，其中data域为字符型，试设计算法判断该链表的全部n个字符是否中心对称。 算法思想： 使用栈来判断链表中的数据是否中心对称。判断n为奇数或偶数，若n为奇数，则有一个中心结点为n%2+1，让链表的前n%2个元素依次进栈，在处理链表的后面元素时，先跳过中心结点，（若n为偶数，则不用直接从n%2+1个元素开始）访问一个链表元素，就从栈中弹出一个元素，两个元素比较，若相等，则将链表中的下一个元素于栈中再弹出的元素比较。直到链表到尾。这时若站
数据结构和算法-2.顺序表与链表
最新发布
08-10
对于希望巩固数据结构基础、提升算法能力的读者来说，这份笔记是不可多得的学习资源。无论你是计算机专业的学生，还是在职的软件开发者，这份笔记都将为你提供深刻的见解和实际的编程技巧，助你在日常开发和面试中...
Java数据结构和算法中文第二版
08-27
通过阅读“Java数据结构和算法中文第二版”，学习者能够系统地了解这些基础知识，并通过实践加深理解。同时，加入特定的编程群组，如文中提到的“524621833”，也有助于获取最新的资源、交流经验和解决实际问题。
Java数据结构和算法中文第二版_Java数据结构_
10-04
《Java数据结构和算法中文第二版》是一本深入探讨Java编程中数据结构和算法的书籍。数据结构是计算机科学的基础，它涉及到如何有效地组织和存储数据，以便在各种操作下高效地访问和修改。算法则是解决问题的具体步骤...
数据结构与算法-顺序表（链表篇）
09-09
在IT领域，数据结构与算法是编程基础的重要组成部分，它们直接影响到程序的效率和设计质量。本主题聚焦于“顺序表”中的“链表”部分，这是一个基础且至关重要的概念，广泛应用于各种软件系统。 链表是一种线性数据...
数据结构与算法分析C++描述（第三版）_数据开发_数据结构与算法分析第三版C++_
10-03
《数据结构与算法分析C++描述（第三版）》是一本深入探讨数据结构和算法的专著，由Mark Allen Weiss撰写。这本书以C++编程语言为载体，详细阐述了数据组织方式和解决问题的有效方法，是计算机科学教育领域的重要教材...
数据结构——链表
Mr_fengzi的博客
07-10 1112
链表 顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行空充时又需要进行数据的搬迁，所以使用起来并不是很灵活。 而链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。 链表的定义： 链表(Linked List)是一种常见的基础数据结构，是一只种类线性表，但是不像顺序表一样连续存储数据，而是在每一个节点(数据存储单元)里存放下一个节点的位置信息(即地址)。链表的每个结...
【考研】单链表相关算法（从基础到真题）
qq_34438969的博客
10-02 2088
本文主要为了掌握单链表基础操作所作的总结，习题部分含408真题或高校真题，以便考研复习。包括但不限于尾插法和前插法建立单链表、“就地逆置”、链式有序表的合并、注意：（1）除非特别说明，本文的单链表操作默认是带头结点的。（2）区分带头结点和不带头结点的单链表的博文，我写了一半，写完就放链接。（如果很久还没放链接，可能博主有事耽搁了，麻烦提醒一下）【考研】线性表的应用之有序表的合并_住在阳光的心里的博客-CSDN博客【考研】《数据结构》知识点总结.pdf_其它文档类资源-CSDN文库目录前言。
数据结构线性表2：链表
maoger_sun的博客
04-11 839
补充：数据结构线性表的优缺点 优点： ①用数组存储数据元素，操作方法简单，容易实现； ②无需为表示结点之间的逻辑关系增加额外的存储开销； ③存储密度高； ④可按照元素位序随机存储结点； 缺点： ①插入或删除操作不方便，除过表尾的位置外，在表的其他位置上进行插入或删除操作都必须移动大量的结点，效率比较低； ②顺序表要求占连续的存储空间，因此需要存储空间要预先进行静态分配。因此表长较大...
数据结构与算法之单链表
Happy_Boy_z的博客
01-04 968
链表链表的介绍单链表(带头节点)添加（创建） 链表的介绍 链表是有序的列表，它在内存中的存储如下 链表是以节点的方式来存储，是链式存储 每个节点包含data域，next域：指向下一个节点 如图: 发现链表的个个节点不一定是连续存储 链表分带头节点的链表和没有头结点的链表，根据需求来确定 单链表(带头节点) 使用一个带head头的单向链表实现排行榜管理 完成对英雄人物的增删改查操作 ...
02-数据结构与算法-单向链表
Kevin-Ding的博客
02-24 348
数据结构与算法中单向链表的介绍，及常见的关于单向链表的面试题
单链表算法题型总结
Mike_honor的博客
07-30 593
链表是一种链式存储的数据结构，用一组地址任意的存储单元存放线性表中的数据结构。单链表中的数据是以结点来表示的，每个结点的构成元素(数据元素的映象)+指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据，即单链表中每个节点都包含data域和next域，如下图所示。......
笔记：第一章作业2--链式存储结构及其操作
LiuLin_Hao的博客
09-09 315
6-2 单链表元素定位 (12分) 本题要求在链表中查找第一个数据域取值为x的节点，返回节点的位序。L是一个带头结点的单链表，函数ListLocate_L(LinkList L, ElemType x)要求在链表中查找第一个数据域取值为x的节点，返回其位序（从1开始），查找不到则返回0。例如，原单链表各个元素节点的元素依次为1,2,3,4，则ListLocate_L(L, 1)返回1，ListLocate_L(L, 3)返回3，而ListLocate_L(L, 100)返回0。 函数接口定义： int
算法与数据结构之带头结点的单链表
谁D了我的BUG
01-01 2776
单链表的定义 #include&amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;malloc.h&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;stdlib.h&amp;amp;amp;amp;gt; typedef struct Node { int data; //数据域 struct
建立一个循环单链表，其节点有 prior，data 和 next 三个域，其中 data 为数 据域，存放元素的有效信息，next 域为指针域，指向后继节点，prior 为指针域，它的 值为 NULL
Shadow_Kerry
05-26 7746
#include &lt;iostream&gt;  #include &lt;cstdlib&gt;  #include &lt;cstdio&gt;    using namespace std;    typedef struct node  {      int data;      struct node *pre;      struct node *next;  } LinkList...
C#数据结构与算法：双向链表和循环链表解析
在软件开发中，数据结构和算法的学习至关重要，尤其是对于专业程序员来说。本文档主要关注链表设计的改进，包括双向链表和循环链表的概念，以及如何在C#语言环境下实现这些改进。同时，文档也强调了C#中的.NET框架库...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值