【数据结构】链表

已于 2022-06-28 08:45:33 修改
阅读量222 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 链表 数据结构
于 2022-06-25 11:27:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/green1997/article/details/125455082
版权

文章目录

1 链表反转

public class Code01_ReverseList {

    public static class Node {
        public int value;
        public Node next;

        public Node(int data) {
            value = data;
        }
    }

    public static class DoubleNode {
        public int value;
        public DoubleNode last;
        public DoubleNode next;

        public DoubleNode(int data) {
            value = data;
        }
    }

    /**
     * 单链表反转
     */
    public static Node reverseLinkedList(Node head) {
        Node pre = null;
        Node next = null;
        while (head != null) {
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }

        return pre;
    }

    /**
     * 双向链表反转
     */
    public static DoubleNode reverseDoubleList(DoubleNode head) {
        DoubleNode pre = null, next = null;
        while (head != null) {
            next = head.next;
            head.next = pre;
            head.last = next;
            pre = head;
            head = next;
        }
        return pre;
    }

    // for test
    public static Node generateRandomLinkedList(int len, int value) {
        int size = (int) (Math.random() * len) + 1;

        size--;
        Node head = new Node((int) (Math.random() * value) + 1);
        Node pre = head;
        while (size != 0) {
            Node cur = new Node((int) (Math.random() * value) + 1);
            pre.next = cur;
            pre = cur;
            size--;
        }
        return head;
    }

    // for test
    public static List<Integer> getLinkedListOriginOrder(Node head) {
        List<Integer> list = new ArrayList<>();
        while (head != null) {
            list.add(head.value);
            head = head.next;
        }
        return list;
    }

    // 单链表对数器
    public static boolean checkLinkedListReversed(List<Integer> list, Node head) {
        for (int i = list.size() - 1; i >= 0; i--) {
            if (!list.get(i).equals(head.value)) {
                return false;
            }

            head = head.next;
        }
        return true;
    }

    // for test
    public static DoubleNode generateRandomDoubleList(int len, int value) {
        int size = (int) (Math.random() * len) + 1;

        size--;
        DoubleNode head = new DoubleNode((int) (Math.random() * value) + 1);
        DoubleNode pre = head;
        while (size != 0) {
            DoubleNode cur = new DoubleNode((int) (Math.random() * value) + 1);
            pre.next = cur;
            cur.last = pre;
            pre = cur;
            size--;
        }
        return head;
    }

    // for test
    public static List<Integer> getDoubleListOriginOrder(DoubleNode head) {
        List<Integer> list = new ArrayList<>();
        while (head != null) {
            list.add(head.value);
            head = head.next;
        }
        return list;
    }

    // 双端链表对数器
    public static boolean checkDoubleListReversed(List<Integer> list, DoubleNode head) {
        DoubleNode end = null;
        for (int i = list.size() - 1; i >= 0; i--) {
            if (!list.get(i).equals(head.value)) {
                return false;
            }

            end = head;
            head = head.next;
        }

        // 尾部
        for (int i = 0; i < list.size(); i++) {
            if (!list.get(i).equals(end.value)) {
                return false;
            }

            end = end.last;
        }

        return true;
    }

    public static void main(String[] args) {
        int len = 50;
        int value = 100;
        int testTime = 100000;

        for (int i = 0; i < testTime; i++) {
            Node node = generateRandomLinkedList(len, value);
            List<Integer> list1 = getLinkedListOriginOrder(node);
            node = reverseLinkedList(node);
            if (!checkLinkedListReversed(list1, node)) {
                System.out.println("Oops1");
            }

            DoubleNode doubleNode = generateRandomDoubleList(len, value);
            List<Integer> list2 = getDoubleListOriginOrder(doubleNode);
            doubleNode = reverseDoubleList(doubleNode);
            if (!checkDoubleListReversed(list2, doubleNode)) {
                System.out.println("Oops2");
            }
        }
    }
}

2 链表实现队列和栈

public class Code02_LinkedListToQueueAndStack {

    public static class Node<V> {
        public V value;
        public Node<V> next;

        public Node(V v) {
            value = v;
            next = null;
        }
    }

    public static class MyQueue<V> {
        Node<V> head;
        Node<V> tail;
        int size;

        public int size() {
            return size;
        }

        public boolean isEmpty() {
            return size == 0;
        }

        public void offer(V value) {
            Node<V> cur = new Node<>(value);
            if (tail == null) {
                head = cur;
                tail = cur;
            } else {
                tail.next = cur;
                tail = cur;
            }
            size++;
        }

        public V poll() {
            if (head == null) {
                return null;
            }

            size--;
            V value = head.value;
            head = head.next;
            // 最后一个节点
            if (head == null) {
                tail = null;
            }
            return value;
        }

        public V peek() {
            return head == null ? null : head.value;
        }
    }

    public static class MyStack<V> {
        Node<V> head;
        int size;

        public int size() {
            return size;
        }

        public boolean isEmpty() {
            return size == 0;
        }

        public void push(V value) {
            Node<V> cur = new Node<>(value);

            if (head == null) {
                head = cur;
            } else {
                cur.next = head;
                head = cur;
            }
            size++;
        }

        public V pop() {
            if (head == null) {
                return null;
            }

            size--;
            V value = head.value;
            head = head.next;
            return value;
        }

        public V peek() {
            return head == null ? null : head.value;
        }
    }

    // 对数器测试
    public static void testQueue() {
        MyQueue<Integer> myQueue = new MyQueue<>();
        Queue<Integer> testQueue = new LinkedList<>();

        int testTime = 5000000;
        int maxValue = 200000000;
        System.out.println("队列测试开始！！");

        for (int i = 0; i < testTime; i++) {
            if (myQueue.size != testQueue.size()) {
                System.out.println("Oops");
                break;
            }

            double random = Math.random();
            if (random < 0.33) {
                int value = (int) (Math.random() * maxValue);
                myQueue.offer(value);
                testQueue.offer(value);
            } else if (random < 0.66) {
                if (!myQueue.isEmpty()) {
                    if (!myQueue.poll().equals(testQueue.poll())) {
                        System.out.println("Oops");
                        break;
                    }
                }
            } else {
                if (!myQueue.isEmpty()) {
                    if (!myQueue.peek().equals(testQueue.peek())) {
                        System.out.println("Oops");
                        break;
                    }
                }
            }
        }

        if (myQueue.size != testQueue.size()) {
            System.out.println("Oops");
            return;
        }

        while (!myQueue.isEmpty()) {
            if (!myQueue.poll().equals(testQueue.poll())) {
                System.out.println("Oops");
                break;
            }
        }

        System.out.println("队列测试结束！！");
    }

    // 对数器测试
    public static void testStack() {
        MyStack<Integer> myStack = new MyStack<>();
        Stack<Integer> testStack = new Stack<>();

        int testTime = 5000000;
        int maxValue = 200000000;
        System.out.println("栈测试开始！！");

        for (int i = 0; i < testTime; i++) {
            if (myStack.size != testStack.size()) {
                System.out.println("Oops");
                break;
            }

            double random = Math.random();
            if (random < 0.33) {
                int value = (int) (Math.random() * maxValue);
                myStack.push(value);
                testStack.push(value);
            } else if (random < 0.66) {
                if (!myStack.isEmpty()) {
                    if (!myStack.pop().equals(testStack.pop())) {
                        System.out.println("Oops");
                        break;
                    }
                }
            } else {
                if (!myStack.isEmpty()) {
                    if (!myStack.peek().equals(testStack.peek())) {
                        System.out.println("Oops");
                        break;
                    }
                }
            }
        }

        if (myStack.size != testStack.size()) {
            System.out.println("Oops");
            return;
        }

        while (!myStack.isEmpty()) {
            if (!myStack.pop().equals(testStack.pop())) {
                System.out.println("Oops");
                break;
            }
        }

        System.out.println("栈测试结束！！");
    }

    public static void main(String[] args) {
        testQueue();

        System.out.println("-----------------------------");

        testStack();
    }
}

3 双端队列

public class Code03_DoubleLinkedListToDeque {

    public static class Node<V> {
        public V value;
        public Node<V> last;
        public Node<V> next;

        public Node(V v) {
            value = v;
            last = null;
            next = null;
        }
    }

    public static class MyDeque<V> {
        Node<V> head;
        Node<V> tail;
        int size;

        public int size() {
            return size;
        }

        public boolean isEmpty() {
            return size == 0;
        }

        public void offerTail(V value) {
            Node<V> cur = new Node<>(value);
            if (tail == null) {
                head = cur;
                tail = cur;
            } else {
                tail.next = cur;
                cur.last = tail;
                tail = cur;
            }
            size++;
        }

        public V pollHead() {
            if (head == null) {
                return null;
            }

            size--;
            V value = head.value;
            if (head == tail) {
                head = null;
                tail = null;
            } else {
                head = head.next;
                head.last = null;
            }
            return value;
        }

        public V peekHead() {
            return head == null ? null : head.value;
        }

        public void offerHead(V value) {
            Node<V> cur = new Node<>(value);
            if (head == null) {
                head = cur;
                tail = cur;
            } else {
               cur.next = head;
               head.last = cur;
               head = cur;
            }
            size++;
        }

        public V pollTail() {
            if (tail == null) {
                return null;
            }

            size--;
            V value = tail.value;
            if (head == tail) {
                head = null;
                tail = null;
            } else {
                tail = tail.last;
                tail.next = null;
            }
            return value;
        }

        public V peekTail() {
            return tail == null ? null : tail.value;
        }
    }

    public static void testMyDeque() {
        MyDeque<Integer> myDeque = new MyDeque<>();
        Deque<Integer> testDeque = new LinkedList<>();

        int testTime = 5000000;
        int maxValue = 200000000;
        System.out.println("双端测试开始！");

        for (int i = 0; i < testTime; i++) {
            if (myDeque.size != testDeque.size()) {
                System.out.println("Oops");
                break;
            }

            double random = Math.random();
            if (random < 0.33) {
                int value = (int) (Math.random() * maxValue);

                double rate = Math.random();
                if (rate < 0.5) {
                    myDeque.offerHead(value);
                    testDeque.offerFirst(value);
                } else {
                    myDeque.offerTail(value);
                    testDeque.offerLast(value);
                }

            } else if (random < 0.66) {
                if (!myDeque.isEmpty()) {
                    double rate = Math.random();
                    if (rate < 0.5) {
                        if (!myDeque.pollHead().equals(testDeque.pollFirst())) {
                            System.out.println("Oops");
                            break;
                        }
                    } else {
                        if (!myDeque.pollTail().equals(testDeque.pollLast())) {
                            System.out.println("Oops");
                            break;
                        }
                    }
                }
            } else {
                if (!myDeque.isEmpty()) {
                    double rate = Math.random();
                    if (rate < 0.5) {
                        if (!myDeque.peekHead().equals(testDeque.peekFirst())) {
                            System.out.println("Oops");
                            break;
                        }
                    } else {
                        if (!myDeque.peekTail().equals(testDeque.peekLast())) {
                            System.out.println("Oops");
                            break;
                        }
                    }
                }
            }
        }

        if (myDeque.size != testDeque.size()) {
            System.out.println("Oops");
            return;
        }

        while (!myDeque.isEmpty()) {
            if (!myDeque.pollHead().equals(testDeque.pollFirst())) {
                System.out.println("Oops");
                break;
            }
        }

        System.out.println("双端测试结束！");
    }

    public static void main(String[] args) {
        testMyDeque();
    }
}

4 K 个节点组内逆序调整

在这里插入图片描述

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

    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode start = head;
        ListNode end = getKGroupEnd(head, k);
        if (end == null) {
            return head;
        }

        // 第一组
        head = end;
        reverse(start, end);

        // 上一组结尾
        ListNode lastEnd = start;
        while (lastEnd.next != null) {
            // 第二组开始节点
            start = lastEnd.next;
            end = getKGroupEnd(start, k);
            // 不足 k 个直接返回
            if (end == null) {
                return head;
            }
            // 第n-1组
            reverse(start, end);
            // 上一组反转的节点指向当前组反转的起始节点
            lastEnd.next = end;
            // 更新最新的结束节点
            lastEnd = start;
        }

        return head;
    }

    /**
     * 获取 node 开始的第 k 的节点
     */
    public ListNode getKGroupEnd(ListNode start, int k) {
        while (k-- > 0 && start != null) {
            start = start.next;
        }
        return start;
    }

    /**
     * 翻转 start - end 的顺序
     */
    public void reverse(ListNode start, ListNode end) {
        end = end.next;
        ListNode pre = null;
        ListNode cur = start;
        ListNode next = null;
        while (cur != end) {
            next = cur.next;
            // 反转
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        // 指向 end 的后一个节点
        start.next = end;
    }
}

5 两个链表相加

在这里插入图片描述

public class Code05_AddTwoNumbers {

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

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

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

    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        // 分开链表和短链表
        int len1 = getLength(l1);
        int len2 = getLength(l2);

        // l 长链表 s 短链表
        ListNode l, s;
        if (len1 >= len2) {
            l = l1;
            s = l2;
        } else {
            l = l2;
            s = l1;
        }

        ListNode curL = l,
                curS = s,
                lastL = null;
        // 进位
        int carry = 0;
        while (curS != null) {
            int sum = curL.val + curS.val + carry;
            curL.val = sum % 10;
            // 更新进位
            carry = sum / 10;

            lastL = curL;
            curL = curL.next;
            curS = curS.next;
        }

        while (curL != null) {
            int sum = curL.val + carry;
            curL.val = sum % 10;
            // 更新进位
            carry = sum / 10;

            lastL = curL;
            curL = curL.next;
        }

        if (carry != 0) {
            lastL.next = new ListNode(carry);
        }

        return l;
    }

    public int getLength(ListNode node) {
        int len = 0;
        while (node != null) {
            len++;
            node = node.next;
        }
        return len;
    }
}

6 两个有序链表的合并

在这里插入图片描述

public class Code06_MergeTwoSortedLinkedList {

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

    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        if (list1 == null || list2 == null) {
            return list1 == null ? list2 : list1;
        }

        // 找较小的作为返回的节点
        ListNode head = list1.val < list2.val ? list1 : list2;
        // 从下一个节点开始遍历
        ListNode cur1 = head.next;
        ListNode cur2 = head == list1 ? list2 : list1;
        ListNode pre = head;
        while (cur1 != null && cur2 != null) {
            if (cur1.val < cur2.val) {
                // 小的指向大的值
                pre.next = cur1;
                // 下一个几点
                cur1 = cur1.next;
            } else {
                pre.next = cur2;
                cur2 = cur2.next;
            }

            pre = pre.next;
        }

        // 连接较长链表的后续节点
        pre.next = cur1 == null ? cur2 : cur1;
        return head;
    }
}

7 合并 K 个有序链表

在这里插入图片描述

public class Code01_MergeKSortedLists {

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

	/**
     * 使用小顶堆实现
     * 1. 将每个链表的头节点放入小顶堆.
     * 2. 从小顶堆弹出第一个节点，连接到新链表最后，并将该节点的下一个节点（非空）放入堆中
     * 3. 重复步骤2，知道堆为空
     */
    public static ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }

        // 使用小顶堆
        PriorityQueue<ListNode> heap = new PriorityQueue<>(Comparator.comparingInt(o -> o.val));

        // 将每个链表的都节点放入堆中
        for (ListNode h : lists) {
            if (h != null) {
                heap.offer(h);
            }
        }

        if (heap.isEmpty()) {
            return null;
        }

        // 头节点
        ListNode head = heap.poll();
        if (head.next != null) {
            heap.add(head.next);
        }

        ListNode pre = head;
        // 非空
        while (!heap.isEmpty()) {
            ListNode cur = heap.poll();
            if (cur.next != null) {
                heap.add(cur.next);
            }

            pre.next = cur;
            pre = cur;
        }

        return head;
    }
}
movYou521
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
lb.rar_数据结构 链表
09-20
本资源"lb.rar_数据结构 链表"提供了一些关于链表的C++实现，对学习数据结构的初学者尤其有帮助。 链表是一种线性数据结构，与数组不同，它的元素并不在内存中连续存储。每个元素（节点）包含两部分：数据域，用于...
pp.zip_数据结构链表实验
09-21
在"pp.zip_数据结构链表实验"中，我们聚焦于一个具体的应用场景——学生信息管理。这个实验旨在帮助学生深入理解链表的运作机制，并能够实际操作链表来解决实际问题。 链表是一种线性数据结构，与数组不同，它的...
数据结构 链表
04-08
数据结构 简单的链表结构 》》》》》》》》》》》
数据结构链表测试
05-02
在本项目“数据结构链表测试”中，我们专注于链表的一种特殊形式：单链表。 单链表是一种线性数据结构，每个节点包含两部分：数据域和指针域。数据域存储实际的数据，而指针域存储指向下一个节点的引用。单链表的...
数据结构(3.3)——栈的链式存储结构
m0_65240792的博客
06-30 232
采用链式存储的栈成为链栈的优点是便于多个栈共享存储空间和提高其效率，且。通常采用单链表实现。
数据结构-线性表的应用
pyc68的博客
07-02 893
本篇文章介绍线性表的应用，分别使用顺序表和单链表实现有序表的合并，最后介绍如何使用单链表实现两个稀疏多项式的相加和相乘。
【数据结构之B树的讲解】
cz88888888666的博客
07-01 394
它的广泛应用于数据库和文件系统中，可以加快数据的访问速度，并且能够适应频繁的数据更新操作。🚀B树是一个多路搜索树，每个节点可以拥有多个子节点。其中，根节点至少有两个子节点，除了根节点和叶节点之外的其他节点至少有。🚀B树通过自平衡操作来保持树的平衡性，保证每个节点存储的键的数量在一定范围内。🚀每个节点中的数据项按照键的排序顺序存储，并且每个数据项都包含一个指向其子节点的指针。🚀B树的所有叶节点都在同一层级，叶节点之间没有指针相连，通常通过根节点进行访问。是一个预先给定的正整数，称为B树的阶。
6-24 数据结构考题 - 顺序查找
Virgo_616的博客
07-01 250
6-24 数据结构考题 - 顺序查找
数据结构之二叉树概念
my_air的博客
07-01 596
主要解释二叉树，B-树的概念
数据结构第07节：队列
hummhumm的专栏
07-04 333
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
数据结构和顺序表
2302_79180171的博客
07-01 258
数据结构是相互之间存在一种或多种特定关系的数据元素的集合。线性表是具有相同数据类型的n(n>=0)个数据元素的有限序列。其中唯一的第一个数据元素称为表头元素唯一的最后一个元素称为表尾元素，除第一个元素外，每个元素有且仅有一个直接前驱，除最后一个元素外，每个元素有且仅有一个直接后继。
【高阶数据结构】B-数、B+树、B*树的原理
稻草人敲代码的博客
07-04 393
B树：有序数组+平衡多叉树B+树：有序数组链表+平衡多叉树B*树：一棵更丰满的，空间利用率更高的B+树。
数据结构--顺序表
LH__1314的博客
06-30 1719
当我们想要使⽤大量使⽤同⼀类型的数据时，通过⼿动定义⼤量的独立的变量对于程序来说，可读性非常差，我们可以借助数组这样的数据结构将⼤量的数据组织在⼀起，结构也可以理解为组织数据的方式。在使用完顺序表后，就要销毁顺序表，因为动态顺序表内存是动态开辟的，所以需要对动态内存进行释放，并将有效数据和空间容量个数置为0；到这里，顺序表的知识就完成了，学完这些，我们也要写顺序表的实践，就是通讯录——在下一篇进行实现。求数组的长度，求数组的有效数据个数，向下标为数据有效个数的位置插入数据（注意：这里是。
【数据结构 - 二叉树】
2302_80393814的博客
06-30 913
在计算机科学中，二叉树是一种重要的数据结构，它由节点（node）组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树的设计灵活性使其在各种应用中都有广泛的用途。通过本文，我们全面介绍了二叉树的基本概念、分类、基本操作和实际应用。二叉树作为一种核心数据结构，不仅在理论计算机科学中占有重要地位，而且在实际应用中有广泛的运用。深入理解二叉树将有助于提升编程能力和解决实际问题的能力。
【408考点之数据结构】顺序查找和折半查找
gygkhd的博客
07-01 417
顺序查找（Sequential Search），也称线性查找，是一种最简单、最直接的查找方法。它从数据集的第一个元素开始，逐个检查每个元素，直到找到目标元素或检查完整个数据集。
数据结构 1.1 数据结构的基本概念
最新发布
2301_80160830的博客
07-04 190
早期计算机只能处理纯数值的问题，如世界第一题计算机ENIAC是用来计算导弹的轨迹方程和原子弹的爆炸方程等。倘若我们用数据元素来描述一下微博的账号，我们把一个账号的信息看做一个数据元素，而昵称，性别生日看做数据项，其中生日由年月日组成，我们把它称为。我们把一个人的财富信息成为一个数据元素，而姓名，财富，财富来源等我们成为数据项。同样的数据元素可以组成相同的数据结构，而不同的数据元素也可以组成相同的数据结构。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的。的数据元素的集合，是。
数据结构速成--图
一个闪现必杀技的博客
06-28 421
BFS就是一口气把和顶点相连的所有顶点遍历，从遍历结果的第二个顶点继续把和第二个顶点相连的所有未遍历的顶点输出。DFS是先遍历和顶点相连的一个顶点，再从这个顶点出发找一个相连的顶点，重读步骤，如果当前顶点和他相连的所有顶点都遍历过了，就看前面的顶点他相连的有没有没遍历的。因此我们也可以根据邻接表/邻接矩阵写出BFS或DFS遍历序列。
数据结构(3.4)——队列的基本概念
m0_65240792的博客
07-01 140
队列(Queue)是只允许在一端进行插入（入队），另一端删除（出队）的线性表(操作受限)特点：先进入队列的元素先出队，先进先出 First In FIrst Out（FIFO），例如食堂打饭，高速公路过站点重要术语：队头，队尾，空队列InitQueue(&Q):初始化队列，构造一个空队列QDestoryQueue(&Q):销毁队列，销毁并释放队列Q所占用的内存空间EnQueue(&Q,x):入队，若队列Q未满，将x加入，使之成为新的队尾DeQueue(&Q,&x):出队，若队列Q非空，删除队头元素，并用x返
数据结构链表操作大全+面向对象封装
09-14
数据结构链表操作大全是一种在面向对象编程中对链表进行操作的封装方法。链表是一种重要的数据结构，它可以动态地存储和处理数据。本文将介绍链表的创建、插入、删除、查找等操作，并在面向对象的方法上进行封装。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值