简单模拟单/双链表实现 LinkedList作业

已于 2023-10-20 11:03:04 修改
阅读量243 收藏
点赞数 2
分类专栏： 算法学习 文章标签： java 开发语言
于 2023-09-24 18:09:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73065928/article/details/133244898
版权

接口

定义MyLink<E>接口，定义抽象方法。

package mylinkedlist;

public interface MyLink<E>{
    //返回链表的长度
    int size();
    //判断链表是否为空
    boolean isEmpty();
    //默认在链表尾部添加元素
    boolean add(E e);
    //添加到链表第一个
    boolean addFirst(E e);
    //删除链表中的某个元素
    boolean remove(E o);
    //清空链表
    void clear();
    //在链表的某个位置添加元素
    void add(int index, E element);
    //删除链表中某个位置的元素
    boolean remove(int index);
    //返回链表中某个位置的元素
    E get(int index);
    //将链表中某个位置的元素替换为新元素
    boolean set(int index, E element);
    //查找链表中的某个元素
    int indexOf(Object o);
    //返回链表的字符串表示
    String toString();
}

单链表实现

1、定义属性，节点类和构造方法

实现MyLink<E>接口，定义一个单链表节点内部类，和私有属性。（定义为私有，只向外部暴露方法即可）带头节点head和尾节点last。

public class MySingleLinkedList<E> implements MyLink{
    int size = 0;
    private MyNode<E> head;
    private MyNode<E> last;
    private class MyNode<E>{
        E item;
        MyNode<E> next;
        public MyNode(E element, MyNode<E> next) {
            this.item = element;
            this.next = next;
        }
    }
    public MySingleLinkedList() {
        head = new MyNode<>(null,null);
        head.next = last;
    }
}

2、重写抽象方法

 @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return head.next == last;
    }
    //添加到链表尾部
    @Override
    public boolean add(Object o) {
        MyNode preMyNode = head;
        MyNode newNode = new MyNode(o,last);
        while (preMyNode.next != last){
            preMyNode = preMyNode.next;
        }
        preMyNode.next = newNode;
        size++;
        return true;
    }

    @Override
    public boolean addFirst(Object o) {
        MyNode nextMyNode = head.next;
        MyNode newNode = new MyNode(o,nextMyNode);
        head.next = newNode;
        size++;
        return true;

    }

    @Override
    public boolean remove(Object o) {
        MyNode a = head;
        MyNode b = a.next;
        if(indexOf(o) == -1){
            return false;
        }else{
            for(;b != last;a = a.next){
                if(b.item.equals(o)){
                    break;
                }
            }
            a.next = b.next;
            size--;
            return true;
        }

    }



    @Override
    public void clear() {
        head.next = last;
        size = 0;

    }
    //添加到链表的某个位置
    @Override
    public void add(int index, Object element) {
        if (index < 0 || index > size) {
            throw new IndexOutOfBoundsException("IndexOutOfBounds!!!! Index: "+index+", Size: "+size);
        } else if (index == size-1) {
            add(element);
        } else if (index ==0) {
            addFirst(element);
        } else {
            MyNode<E> preMyNode = head;
            for (int i = 0; i < index; i++) {
                preMyNode = preMyNode.next;
            }
            MyNode<E> nextMyNode = preMyNode.next;
            MyNode<E> newNode = new MyNode(element, nextMyNode);
            preMyNode.next = newNode;
            size++;
        }

    }



    @Override
    public boolean remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("IndexOutOfBounds!!!! Index: " + index + ", Size: " + size);
        }else {
            MyNode<E> preMyNode = head;
            for (int i = 0; i < index; i++) {
                preMyNode = preMyNode.next;
            }
            MyNode<E> nextMyNode = preMyNode.next.next;
            preMyNode.next = nextMyNode;
            size--;
            return true;
        }


    }

    @Override
    public Object get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("IndexOutOfBounds!!!! Index: "+index+", Size: "+size);
        }else {
            MyNode<E> preMyNode = head.next;
            for (int i = 0; i < index; i++) {
                preMyNode = preMyNode.next;
            }
            return preMyNode.item;
        }

    }

    @Override
    public boolean set(int index, Object element) {
if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("IndexOutOfBounds!!!! Index: "+index+", Size: "+size);
        }else {
            MyNode<E> preMyNode = head.next;
            for (int i = 0; i < index; i++) {
                preMyNode = preMyNode.next;
            }
            preMyNode.item = (E) element;
            return true;
        }

    }

    @Override
    public int indexOf(Object o) {
        MyNode<E> preMyNode = head.next;
        for (int i = 0; i < size; i++) {
            if (preMyNode.item.equals(o)) {
                return i;
            }
            preMyNode = preMyNode.next;
        }
        return -1;

    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        MyNode<E> preMyNode = head.next;
        for (int i = 0; i < size; i++) {
            if (i == size - 1) {
                sb.append(preMyNode.item);
            } else {
                sb.append(preMyNode.item + ",");
            }
            preMyNode = preMyNode.next;
        }
        sb.append("]");
        return sb.toString();

    }

单链表测试

测试类

package mylinkedlist;

public class MySingleLinkedTest {
    public static void main(String[] args) {
        MySingleLinkedList<Integer> mySingleLinkedList = new MySingleLinkedList<>();
        mySingleLinkedList.add(1);
        mySingleLinkedList.add(2);
        mySingleLinkedList.add(3);
        mySingleLinkedList.add(4);
        mySingleLinkedList.add(5);
        mySingleLinkedList.add(6);
        System.out.println("=======Test add(E e)=======");
        System.out.println(mySingleLinkedList.toString());
        System.out.println("=======Test size()=======");
        System.out.println("size="+mySingleLinkedList.size());
        System.out.println("=======Test remove(E o) index= 2 =======");
        mySingleLinkedList.remove(2);
        System.out.println(mySingleLinkedList.toString());
        System.out.println("=======Test add(int index, E element) index= 3 value = 66=======");
        mySingleLinkedList.add(3,66);
        System.out.println(mySingleLinkedList.toString());
        System.out.println("=======Test remove(int index) index= 3=======");
        mySingleLinkedList.remove(3);
        System.out.println(mySingleLinkedList.toString());
        System.out.println("=======Test get(int index) index= 3=======");
        System.out.println(mySingleLinkedList.get(3));
        System.out.println("=======Test set(int index, E element)index= 3 value = 88=======");
        mySingleLinkedList.set(3,88);
        System.out.println(mySingleLinkedList.toString());
        System.out.println("=======Test indexOf(Object o)index= 3 value = 88=======");
        System.out.println(mySingleLinkedList.indexOf(88));
        System.out.println("=======Test clear()=======");
        mySingleLinkedList.clear();
        System.out.println(mySingleLinkedList.toString());
    }


}

双链表实现

1、定义属性，节点类和构造方法

实现MyLink<E>接口，定义一个双链表节点内部类，和私有属性。（定义为私有，只向外部暴露方法即可），带头节点first和尾节点last。

public class MyLinkedList<E> implements MyLink<E>{
    //头节点和为节点不计入链表的长度，也不计入下标！！！！
    private int size = 0;
    private MyNode<E> first;
    private MyNode<E> last;

    public MyLinkedList() {
        first = new MyNode<>(null,null,null);
        last = new MyNode<>(first,null,null);
        first.next = last;
    }


    private class MyNode<E>{
            E item;
            MyNode<E> next;
            MyNode<E> prev;

            public MyNode(MyNode<E> prev, E element, MyNode<E> next) {
                this.item = element;
                this.next = next;
                this.prev = prev;
            }
     }
}

2、重写抽象方法

 @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return first.next == last ;
    }

    @Override
    public boolean addFirst(E e) {
        MyNode nextMyNode = first.next;
        MyNode newNode = new MyNode(first,e,nextMyNode);
        first.next = newNode;
        nextMyNode.prev = newNode;
        size++;
        return true;

    }

    //添加到链表尾部
    @Override
    public boolean add(Object e) {
         MyNode preMyNode = last.prev;
         MyNode newNode = new MyNode(preMyNode,e,last);
            last.prev = newNode;
            preMyNode.next = newNode;
            size++;
            return true;

    }

    @Override
    public boolean remove(E o) {
         MyNode n = first;
     if(indexOf(o) == -1){
         return false;
        }else{
        for(int i = 0;i<indexOf(o);i++){
            n = n.next;
        }
        MyNode preMyNode = n.prev;
        MyNode nextMyNode = n.next;
        preMyNode.next = nextMyNode;
        nextMyNode.prev = preMyNode;
        size--;
        return true;
     }
    }

    @Override
    public void clear() {
        first.next = last;
        last.prev = first;
        size = 0;
    }

//添加到链表的某个位置
    @Override
    public void add(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("IndexOutOfBounds!!!! Index: " + index + ", Size: " + size);
        } else if (index == 0) {
            addFirst(element);
        } else if (index == size - 1) {
            add(element);
        } else if (index <= size / 2) {
            MyNode n = first;
            for (int i = 0; i <= index; i++) {
                n = n.next;
            }
            MyNode preMyNode = n.prev;
            MyNode newNode = new MyNode(preMyNode, element, n);
            preMyNode.next = newNode;
            n.prev = newNode;
            size++;
        } else if (index > size / 2) {
            MyNode n = last;
            for (int i = size; i > index; i--) {
                n = n.prev;
            }
            MyNode preMyNode = n.prev;
            MyNode newNode = new MyNode(preMyNode, element, n);
            preMyNode.next = newNode;
            n.prev = newNode;
            size++;
        }

    }

    @Override
    public boolean remove(int index) {
         if (index < 0 || index >= size) {
             throw new IndexOutOfBoundsException("IndexOutOfBounds!!!! Index: " + index + ", Size: " + size);
         }else {
             MyNode n = first;
             for(int i = 0;i<=index;i++){
                 n = n.next;
             }
             MyNode preMyNode = n.prev;
             MyNode nextMyNode = n.next;
             preMyNode.next = nextMyNode;
             nextMyNode.prev = preMyNode;
             size--;
             return true;
         }

    }

    @Override
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("IndexOutOfBounds!!!! Index: " + index + ", Size: " + size);
        }else if(index <= size/2){
            MyNode n = first;
            for(int i = 0;i<=index;i++){
                n = n.next;
            }
            return (E) n.item;
        } else if (index > size/2){
            MyNode n = last;
            for(int i = size;i>index;i--){
                n = n.prev;
            }
            return (E) n.item;

        }
        return null;
    }

    @Override
    public boolean set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException("IndexOutOfBounds!!!! Index: " + index + ", Size: " + size);
        }else if(index <= size/2){
            MyNode n = first;
            for(int i = 0;i<=index;i++){
                n = n.next;
            }
            n.item = element;
            return true;
        } else if (index > size/2){
            MyNode n = last;
            for(int i = size;i>index;i--){
                n = n.prev;
            }
            n.item = element;
            return true;

        }
        return false;
    }

    @Override
    public int indexOf(Object o) {
        MyNode n = first.next;
        int index = 0;
        while(n.next != null){
            if(n.item.equals(o)){
                return index;
            }
            n = n.next;
            index++;
        }
        return -1;
    }

    @Override
    public String toString() {
        MyNode n = first.next;
        String str = "[";
        if(first.next == last){
            return "[]";
        }
      for (int i = 1;i<size;i++){
          str += n.item + ",";
          n = n.next;
      }
        str += n.item + "]";
        return str;

    }

双链表测试

测试类

package mylinkedlist;

import org.junit.jupiter.api.Test;

public class MyLinnkedListTest {
    public static void main(String[] args) {
        MyLinkedList<Integer> myLinnkedListTest = new MyLinkedList<>();
        myLinnkedListTest.add(1);
        myLinnkedListTest.add(2);
        myLinnkedListTest.add(3);
        myLinnkedListTest.add(4);
        myLinnkedListTest.add(5);
        myLinnkedListTest.add(6);
        System.out.println("=======Test add(E e)=======");
        System.out.println(myLinnkedListTest.toString());
        System.out.println("=======Test size()=======");
        System.out.println("size="+myLinnkedListTest.size());
        System.out.println("=======Test remove(E o) index= 2 =======");
        myLinnkedListTest.remove(2);
        System.out.println(myLinnkedListTest.toString());
        System.out.println("=======Test add(int index, E element) index= 3 value = 66=======");
        myLinnkedListTest.add(3,66);
        System.out.println(myLinnkedListTest.toString());
        System.out.println("=======Test remove(int index) index= 3=======");
        myLinnkedListTest.remove(3);
        System.out.println(myLinnkedListTest.toString());
        System.out.println("=======Test get(int index) index= 3=======");
        System.out.println(myLinnkedListTest.get(3));
        System.out.println("=======Test set(int index, E element)index= 3 value = 88=======");
        myLinnkedListTest.set(3,88);
        System.out.println(myLinnkedListTest.toString());
        System.out.println("=======Test indexOf(Object o)index= 3 value = 88=======");
        System.out.println(myLinnkedListTest.indexOf(88));
        System.out.println("=======Test clear()=======");
        myLinnkedListTest.clear();
        System.out.println(myLinnkedListTest.toString());


    }
}

作业

作业一

第一题

有一个整数顺序表L。设计一个尽可能高效的算法删除其中所有值为负整数的元素（假设L中值为负整数的元素可能有多个），删除后元素的相对次序不改变。并给出算法的时间和空间复杂度。例如，L=（1，2，-1，-2，3，-3），删除后L=（1，2，3）。

代码实现
@Test
    public void workOne (){
        MyLinkedList<Integer> integerMyLinkedList = new MyLinkedList<>();
        integerMyLinkedList.add(1);
        integerMyLinkedList.add(2);
        integerMyLinkedList.add(-1);
        integerMyLinkedList.add(-2);
        integerMyLinkedList.add(3);
        integerMyLinkedList.add(-3);
        System.out.println("=======before=======");
        System.out.println(integerMyLinkedList);
        System.out.println("=======after=======");
        System.out.println(deleteNegative(integerMyLinkedList));
    }

    public MyLinkedList deleteNegative(MyLinkedList<Integer> integerMyLinkedList){
        MyLinkedList<Integer> integerMyLinkedList1 = new MyLinkedList<>();
        for (int i = 0; i < integerMyLinkedList.size(); i++) {
            if (integerMyLinkedList.get(i) >= 0) {
                integerMyLinkedList1.add(integerMyLinkedList.get(i));
            }
        }
        return integerMyLinkedList1;
    }
复杂度分析

时间复杂度：add方法为O(1),get方法为O（n），所以整体为O（n^n)

空间复杂度O（n）

第二题

有一个整数顺序表L。设计一个尽可能高效的算法删除表中值大于等于x且小于等于y的所有元素（x≤y），删除后元素的相对次序不改变。并给出算法的时间和空间复杂度。例如，L=（4，2，1，5，3，6，4），x=2，y=4，删除后L=（1，5，6）。

代码实现
@Test
    public void workTwo (){
        MyLinkedList<Integer> integerMyLinkedList = new MyLinkedList<>();
        integerMyLinkedList.add(4);
        integerMyLinkedList.add(2);
        integerMyLinkedList.add(1);
        integerMyLinkedList.add(5);
        integerMyLinkedList.add(3);
        integerMyLinkedList.add(6);
        integerMyLinkedList.add(4);
        System.out.println("=======before=======");
        System.out.println(integerMyLinkedList);
        System.out.println("=======after=======");
        System.out.println(deleteOnCondition(integerMyLinkedList,2,4));
    }

    public MyLinkedList deleteOnCondition(MyLinkedList<Integer> integerMyLinkedList,int min,int max){
        MyLinkedList<Integer> integerMyLinkedList1 = new MyLinkedList<>();
        for (int i = 0; i < integerMyLinkedList.size(); i++) {
            if (integerMyLinkedList.get(i) < min || integerMyLinkedList.get(i) > max) {
                integerMyLinkedList1.add(integerMyLinkedList.get(i));
            }
        }
        return integerMyLinkedList1;
    }
复杂度分析

时间复杂度：get方法为O（n），所以整体为O（n^n)

空间复杂度O（n）

作业二

第一题

有一个整数单链表L，设计一个尽可能高效算法将所有负整数的元素移到其他元素的前面。例如，L=（1，2，-1，-2，3，-3，4），移动后L=（-1，-2，-3，1，2，3，4）。

代码实现
 @Test
    public void workOne (){
        MySingleLinkedList<Integer> integerMyLinkedList = new MySingleLinkedList<>();
        integerMyLinkedList.add(1);
        integerMyLinkedList.add(2);
        integerMyLinkedList.add(-1);
        integerMyLinkedList.add(-2);
        integerMyLinkedList.add(3);
        integerMyLinkedList.add(-3);
        integerMyLinkedList.add(4);
        System.out.println("=======before=======");
        System.out.println(integerMyLinkedList);
        System.out.println("=======after=======");
        System.out.println(moveNegativeFoward(integerMyLinkedList));
    }

    private MySingleLinkedList moveNegativeFoward(MySingleLinkedList<Integer> integerMyLinkedList) {
        MySingleLinkedList mySingleLinkedList = new MySingleLinkedList();
        for (int i = 0; i < integerMyLinkedList.size(); i++) {
            if ((int)integerMyLinkedList.get(i) < 0) {
                mySingleLinkedList.addFirst(integerMyLinkedList.get(i));
            }else {
                mySingleLinkedList.add(integerMyLinkedList.get(i));
            }
        }
        return mySingleLinkedList;
    }
复杂度分析

时间复杂度：addFirst方法为O(1),add方法为O(n),get方法为O（n），所以整体为O（n^n)

空间复杂度O（n）

第二题

有两个集合采用整数单链表A、B存储，设计一个算法求两个集合的差集C，C仍然用单链表存储。并给出算法的时间和空间复杂度。例如A=（1，3，2），B=（5，1，4，2），差集C=（3）。

代码实现
 @Test
    public void workTwo (){
        MySingleLinkedList<Integer> integerMyLinkedList1 = new MySingleLinkedList<>();
        MySingleLinkedList<Integer> integerMyLinkedList2 = new MySingleLinkedList<>();
        integerMyLinkedList1.add(1);
        integerMyLinkedList1.add(3);
        integerMyLinkedList1.add(2);
        integerMyLinkedList2.add(5);
        integerMyLinkedList2.add(1);
        integerMyLinkedList2.add(4);
        integerMyLinkedList2.add(2);
        System.out.println("=======before=======");
        System.out.println(integerMyLinkedList1);
        System.out.println(integerMyLinkedList2);
        System.out.println("=======result=======");
        System.out.println(deferenceSet(integerMyLinkedList1,integerMyLinkedList2));
    }

    private MySingleLinkedList deferenceSet(MySingleLinkedList<Integer> integerMyLinkedList1, MySingleLinkedList<Integer> integerMyLinkedList2) {
        MySingleLinkedList mySingleLinkedList = new MySingleLinkedList();
       for (int i = 0;i < integerMyLinkedList1.size;i++){
           for (int j = 0;j < integerMyLinkedList2.size;j++) {
               if (integerMyLinkedList1.get(i) == integerMyLinkedList2.get(j)) {
                   break;
               } else if (j == integerMyLinkedList2.size - 1) {
                   mySingleLinkedList.add(integerMyLinkedList1.get(i));
               }
           }
       }
        return mySingleLinkedList;
    }
复杂度分析

时间复杂度：add方法为O(n),get方法为O（n），所以整体为O（n^n^n)

空间复杂度O（n）

仓库

https://gitee.com/BenChuat/algorithm-exercise.git

BenChuat
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
链表小结
weixin_44014218的博客
12-15 309
LinkedList链表总结前言一、LinkedList（链表）1. 单向链表2. 双向链表3. 循环链表二、LinkedList（链表）相关题型及解法1. 单向链表2. 双向链表3. 循环链表总结 前言 List的两个重要实现类ArrayList和LinkedList各自的特点都是非常明显的。 ArrayList的底层是数组，在逻辑上和物理上来说都是连续的，也就是说数组在内存上是存储在连续的空间里面的，这种存储的优势是通过index（索引）可以实现查找和随机访问，操作复杂度只是O(1)。但是对于插入和
Java 集合类 笔记总结 + 作业
zxcsjf的博客
07-13 248
Java collection 集合类
C++ 手动实现双向链表（作业版）
a1367666195的博客
11-22 740
手动实现双向链表，包含增删查改功能，附源码
【JAVA】LinkedList与链表（Part2）
Xian meng在努力呐-的博客
08-10 151
1. 双向循环链表功能的模拟实现 2. LinkedList的基本方法 3. 相关问答 4. ArrayList和LinkedList的区别（存储+访问+增删查改+应用场景）
数组与链表实现队列
m0_52061250的博客
05-24 452
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、数组二、链表1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、数组 二、链表 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.
操作系统——连续动态内存管理模拟实现
weixin_43774168的博客
12-02 5148
引子 连续动态内存管理，该实验其实就是对双向链表进行操作来模拟内存分配，比起普通链表更细心一点就行。 一、实验目的 1） 理解内存管理相关理论； 2） 掌握连续内存管理理论； 3） 掌握动态连续内存管理理论。 二、实验内容 本实验主要针对操作系统中内存管理相关理论进行实验，要求实验者编写一个程序，该程序管理一块虚拟内存，实现内存分配和回收功能。 1） 模拟管理 64M 的内存块； 2） 设计内存分配函数； 3） 设计内存回收函数； 4） 实现动态分配和回收操作； 5） 可动态显示每个内存块信息。 三、实验原
剑指Offer——编程题的Java实现（更新完毕……）
LuckyBrown的博客
08-05 3210
二维数组中的查找 在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。[java] view plain copy print?      /*  * 思路 矩阵是有序的，从右上角来看，向左数字递减，向下数字递增，   * 因此从右上角开始查找，当要查找数字比左下角数字大时。下移  *
【数据结构】Java实现常用数据结构
Java
09-15 899
【数据结构】Java算法基础 一、前言 KMP算法 汉诺塔 八皇后（分治算法） 马踏棋盘算法（骑士周游问题）图的深度优先算法+贪心算法优化 第一章、稀疏数组和队列 1.1 稀疏数组 基本介绍 当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。 稀疏数组的处理方法是: 记录数组一共有几行几列，有多少个有效值 把具有不同值的有效元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模 package zy.code.sparsearray; /** * 稀
操作系统——动态分区管理: 用Java实现适应算法的内存分配和回收过程
xhy1999的博客
08-05 8593
前言：虽说操作系统的课程已经结束，但是我觉得梁老师的课上有很多值得记录和回味的东西，时隔多日，我决定还是来写一些博客，记录我这门课上写的实践作业。 题目：用C语言(也可以用Java)实现采用首次适应算法的内存分配和回收过程。 题目要求： 定义管理空闲分区的相关数据结构：采用空闲分区链表来管理系统中所有的空闲分区，链表中的每个节点表示一个空闲分区，登记有空闲分区的起始地址和长度。 定义一个简...
C#双向链表LinkedList排序实现方法
09-03
在C#编程语言中，双向链表（LinkedList）是一种数据结构，它允许在列表的任一侧进行插入和删除操作，而不像数组那样需要移动大量元素。LinkedList类是.NET框架提供的，它包含两个指针：一个指向前一个节点，另一个...
Java LinkedList 双向链表实现原理
01-20
相信大家都明白 LinkedList 是基于双向链表而实现的，本篇文章主要讲解一下双向链表的实现，并且我们参考 LinkedList 自己实现一个单链表尝试一下。 什么是链表？ 简单的来讲一下什么是链表：首先链表是一种线性的...
Go-LinkedList一个简单的双链表实现
08-14
LinkedList一个简单的双链表实现，提供了Append、Prepend、Remove、ForEach、ForEachRev、Map、Filter、Reduce
简单介绍线性表以及如何实现双链表
09-03
在Java中，可以使用`class Node`来定义节点，并实现相应的接口或继承自`java.util.LinkedList`。 总的来说，线性表是数据结构的基础，不同的实现方式适应不同的场景需求。数组适合于需要快速随机访问的情况，而链表...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 695
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Java爬虫之Jsoup爬Html网页链接
withme977的博客
06-20 265
Java爬虫Jsoup
Java面试八股之简述JVM内存结构
最新发布
u012151345的博客
06-20 740
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
Spring 事务传播行为之Propagation.NESTED REQUIRES_NEW等探讨
chengmin123456789的博客
06-17 227
当一个事务方法（标记为@Transactional(propagation = Propagation.NESTED))被另一个活动事务调用时，它会创建一个“保存点”（Savepoint）作为新的事务开始点。这意味着，如果这个嵌套事务方法内部发生异常并导致回滚，事务会回滚到这个保存点，而不会影响到外部事务的其他操作。如果一切正常，嵌套事务会在外部事务结束时一起提交。
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 965
GeoServerBasePage 登录
Linkedlist双向链表
03-29
Linkedlist双向链表是一种数据结构，它由一系列节点组成，每个节点包含一个指向前一个节点和后一个节点的指针。在双向链表中，可以从任何一个节点开始向前或向后遍历整个链表。 与单向链表不同，双向链表可以在任何...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

BenChuat

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

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

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

打赏作者

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

抵扣说明：

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

余额充值