【数据结构】LinkedList ------ java实现

已于 2024-09-05 09:55:53 修改
阅读量764 收藏 12
点赞数 9
分类专栏： 数据结构 文章标签： java 开发语言
于 2024-09-05 09:53:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C384136844/article/details/141905724
版权

  知识框架图：

  LinkedList是一种常用的数据结构。底层是一个双向链表。每个节点包含数据以及指向前一个节点和后一个节点的引用。

   一：LinkedList的使用

   1.1 LinkedList的构造方法

方法 解释
LinkedList() 无参构造
public LinkedList(Collection<? extends E> c) 使用其他集合容器中元素构造List

  代码示例： 

public static void main(String[] args) {
// 构造一个空的LinkedList
List<Integer> list1 = new LinkedList<>();
List<String> list2 = new ArrayList<>();

list2.add("三国演义");
list2.add("西游记");
list2.add("水浒传");

// 使用ArrayList构造LinkedList
List<String> list3 = new LinkedList<>(list2);
}

  1.2 LinkedList的常用方法

方法 解释
boolean add (E e) 尾插 e
void add (int index, E element)将 e 插入到 index 位置
boolean addAll (Collection<? extends E> c)尾插 c 中的元素
E remove (int index) 删除 index 位置元素
boolean remove (Object o)删除遇到的第一个 o
E get (int index)获取下标 index 位置元素
E set (int index, E element)将下标 index 位置元素设置为 element
void clear () 清空
boolean contains (Object o) 判断 o 是否在线性表中
int indexOf (Object o) 返回第一个 o 所在下标
int lastIndexOf (Object o)返回最后一个 o 的下标
List<E> subList (int fromIndex, int toIndex)截取部分 list

  部分方法代码示例：

public static void main(String[] args) {
LinkedList<Integer> list = new LinkedList<>();
list.add(1); // add(elem): 表示尾插
list.add(2);
list.add(3);
list.add(4);
list.add(5);
list.add(6);
list.add(7);
System.out.println(list.size());
System.out.println(list);
// 在起始位置插入0
list.add(0, 0); // add(index, elem): 在index位置插入元素elem
System.out.println(list);
list.remove(); // remove(): 删除第一个元素，内部调用的是removeFirst()
list.removeFirst(); // removeFirst(): 删除第一个元素
list.removeLast(); // removeLast(): 删除最后元素
list.remove(1); // remove(index): 删除index位置的元素
System.out.println(list);
// contains(elem): 检测elem元素是否存在，如果存在返回true，否则返回false
if(!list.contains(1)){
list.add(0, 1);
}

list.add(1);
System.out.println(list);
System.out.println(list.indexOf(1)); // indexOf(elem): 从前往后找到第一个elem的位置
System.out.println(list.lastIndexOf(1)); // lastIndexOf(elem): 从后往前找第一个1的位置
int elem = list.get(0); // get(index): 获取指定位置元素
list.set(0, 100); // set(index, elem): 将index位置的元素设置为elem
System.out.println(list);
// subList(from, to): 用list中[from, to)之间的元素构造一个新的LinkedList返回
List<Integer> copy = list.subList(0, 3); 
System.out.println(list);
System.out.println(copy);
list.clear(); // 将list中元素清空
System.out.println(list.size());
}

  1.3 LinkedList的遍历 

  1.使用普通 for 循环遍历

//由于LinkedList不能像数组那样通过索引直接快速访问元素，使用普通 for 循环遍历需要借助size()方法和 
//get(int index)方法来逐个获取元素。这种方式效率较低，不推荐在频繁遍历的场景中使用。

for (int i = 0; i < list.size(); i++) {
    String element = list.get(i);
    System.out.println(element);
}

  2.使用增强型 for 循环遍历

//增强for循环可以简洁地遍历集合中的元素。
for (String element : list) {
    System.out.println(element);
}

  3. 使用迭代器（Iterator）遍历

//1.使用迭代器的hasNext和next方法进行遍历，避免在遍历过程中频繁调用size方法
//或通过索引访问元素。这样可以提高遍历的效率，特别是在处理大型链表时。

//2.在遍历过程中尽量避免对链表进行修改操作，因为这可能会导致迭代器失效，需要重新获取迭代器。
//如果必须在遍历过程中进行修改，可以使用迭代器的remove方法来安全地删除元素。

LinkedList<String> list = new LinkedList<>();
list.add("计算机科学与技术");
list.add("软件工程");
list.add("人工智能");

//1.获取迭代器：可以通过LinkedList的iterator()方法获取一个Iterator对象。
Iterator<String> iterator = list.iterator();

//2.使用迭代器遍历：通过hasNext()方法判断是否还有下一个元素，使用next()方法获取下一个元素。
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}


  4. 从链表尾部向头部遍历


LinkedList<String> list = new LinkedList<>();
list.add("计算机科学与技术");
list.add("软件工程");
list.add("人工智能");


//1.获取列表迭代器并指向尾部：可以使用listIterator(int index)方法获取一个ListIterator对象,
//并将其初始位置设置为链表的尾部。
ListIterator<String> listIterator = list.listIterator(list.size());

//2.向头部遍历：使用hasPrevious()方法判断是否还有前一个元素，使用previous()方法获取前一个元素。
while (listIterator.hasPrevious()) {
    String element = listIterator.previous();
    System.out.println(element);
}

   二：使用案例

  2.1实现队列和栈数据结构

  1. 队列（Queue）：

  • LinkedList 可以很方便地用来实现队列。在队列中，元素遵循先进先出（FIFO）的原则。可以利用 LinkedList 的 addLast 方法在队尾添加元素，使用 removeFirst 方法在队首取出元素。

  • 例如：在一个任务调度系统中，可以使用队列来管理待执行的任务。新任务添加到队尾，执行引擎从队首获取任务并执行。
 

  代码示例：

import java.util.LinkedList;

public class TaskQueue {
    private LinkedList<String> queue = new LinkedList<>();

    public void addTask(String task) {
        queue.addLast(task);
    }

    public String getNextTask() {
        return queue.removeFirst();
    }

    public static void main(String[] args) {
        TaskQueue taskQueue = new TaskQueue();
        taskQueue.addTask("Task 1");
        taskQueue.addTask("Task 2");
        System.out.println(taskQueue.getNextTask()); // 输出：Task 1
        System.out.println(taskQueue.getNextTask()); // 输出：Task 2
    }
}

  2. 栈（Stack）：

  • LinkedList 也可以用于实现栈。在栈中，元素遵循先进后出（LIFO）的原则。可以使用 addFirst 方法将元素压入栈顶，使用 removeFirst 方法弹出栈顶元素。

  • 例如：在表达式求值、函数调用栈等场景中可以使用栈。
 

import java.util.LinkedList;

public class StackExample {
    private LinkedList<String> stack = new LinkedList<>();

    public void push(String item) {
        stack.addFirst(item);
    }

    public String pop() {
        return stack.removeFirst();
    }

    public static void main(String[] args) {
        StackExample stack = new StackExample();
        stack.push("Item 1");
        stack.push("Item 2");
        System.out.println(stack.pop()); // 输出：Item 2
        System.out.println(stack.pop()); // 输出：Item 1
    }
}

  2.2. 频繁插入和删除的场景

  1. 日志记录系统：

  • 在一个日志记录系统中，新的日志条目不断产生并需要添加到日志列表中。同时，可能需要根据时间范围或其他条件删除一些旧的日志条目。由于 LinkedList 在插入和删除操作上的高效性，特别是在列表中间进行插入和删除时，非常适合这种场景。

  • 代码示例：

import java.util.LinkedList;

public class LoggingSystem {
    private LinkedList<String> logs = new LinkedList<>();

    public void addLog(String logEntry) {
        logs.add(logEntry);
    }

    public void removeOldLogs(int daysAgo) {
        // 假设日志中有时间戳，可以根据时间戳删除超过指定天数的日志
        // 这里只是一个简单的示例，实际实现可能更复杂
        for (String log : logs) {
            // 根据条件判断是否删除日志
        }
    }

    public static void main(String[] args) {
        LoggingSystem loggingSystem = new LoggingSystem();
        loggingSystem.addLog("Log entry 1");
        loggingSystem.addLog("Log entry 2");
        // 后续可以根据需要添加和删除日志
    }
}

  2. 实时消息处理：

  • 在一个实时消息处理系统中，新的消息不断到来需要添加到消息队列中，同时已处理的消息可以从队列中删除。LinkedList 的高效插入和删除操作可以满足这种实时性要求。

  • 代码示例：

import java.util.LinkedList;

public class MessageProcessingSystem {
    private LinkedList<String> messages = new LinkedList<>();

    public void addMessage(String message) {
        messages.add(message);
    }

    public String processNextMessage() {
        return messages.removeFirst();
    }

    public static void main(String[] args) {
        MessageProcessingSystem messageSystem = new MessageProcessingSystem();
        messageSystem.addMessage("Message 1");
        messageSystem.addMessage("Message 2");
        System.out.println(messageSystem.processNextMessage()); // 输出：Message 1
        System.out.println(messageSystem.processNextMessage()); // 输出：Message 2
    }
}

 

  三：LinkedList源码分析：

  3.1 主要成员变量

• size：表示链表中元素的个数。

• first：指向链表的第一个节点。

• last：指向链表的最后一个节点。

  3.2 内部节点类

• item：存储节点中的元素。

• next：指向下一个节点的引用。

• prev：指向前一个节点的引用。

  3.3 构造方法

   默认构造方法：创建一个空的链表。

   包含集合参数的构造方法：可以从另一个集合创建LinkedList，将集合中的元素依次添加到链表中。

  3.4添加元素方法

1. add(E e)：在链表末尾添加元素。

    内部调用linkLast方法，将新元素作为最后一个节点添加到链表中。

2. add(int index, E element)：在指定位置插入元素。

    首先检查索引是否合法，然后根据索引位置决定是在末尾添加（调用linkLast）还是在指定位置插入（调用linkBefore）。

  3.5 删除元素方法

 1. remove(int index)： 删除指定位置的元素。

首先检查索引是否合法，然后调用unlink方法删除指定节点。 


public E remove(int index) {
    checkElementIndex(index);
    return unlink(node(index));
}
   E unlink(Node<E> x) {
    // assert x!= null;
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    if (prev == null) {
        first = next;
    } else {
        prev.next = next;
        x.prev = null;
    }

    if (next == null) {
        last = prev;
    } else {
        next.prev = prev;
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}


2. remove(Object o)：删除指定的元素。

遍历链表找到指定元素的节点，然后调用unlink方法删除该节点。


public boolean remove(Object o) {
    if (o == null) {
        for (Node<E> x = first; x!= null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node<E> x = first; x!= null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

  同理，其他的方法都可以通过源码阅读知道底层是怎么去实现的。

  四：模拟实现LinkedList

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

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

    public ListNode head;//标记双向链表的头部
    public ListNode tail;//标记双向链表的尾部


    /**
     * 打印双向链表的每个节点 的值
     */
    public void display() {
        ListNode cur = this.head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    //得到链表的长度
    public int size() {
        int count = 0;
        ListNode cur = this.head;
        while (cur != null) {
            cur = cur.next;
            count++;
        }
        return count;
    }

    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }


    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
            this.tail = node;
        } else {
            node.next = this.head;
            this.head.prev = node;
            head = node;
        }
    }

    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
            this.tail = node;
        } else {
            tail.next = node;
            node.prev = tail;
            tail = node;
        }
    }

    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) {
        //1、判断Index位置的合法性
        if (index < 0 || index > size()) {
            throw new IndexWrongFulException("index位置不合法！");
        }
        //2、判断特殊位置，头插 和 尾插
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        //3、找到index位置节点的地址
        ListNode cur = findIndexListNode(index);
        //4、修改4个指向
        ListNode node = new ListNode(data);
        node.next = cur;
        cur.prev.next = node;
        node.prev = cur.prev;
        cur.prev = node;
    }

    private ListNode findIndexListNode(int index) {
        ListNode cur = head;
        while (index != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }


    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) {
                    head = head.next;
                    if (head != null) {
                        head.prev = null;
                    } else {
                        tail = null;
                    }
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        this.tail = cur.prev;
                    }
                }
                return;
            }
            cur = cur.next;
        }
    }

    //删除所有值为key的节点
    public void removeAllKey(int key) {
        ListNode cur = head;
        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) {
                    head = head.next;
                    if (head != null) {
                        head.prev = null;
                    } else {
                        tail = null;
                    }
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        this.tail = cur.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }

    public void clear() {
        ListNode cur = head;
        while (cur != null) {
            ListNode curNext = cur.next;
            cur.prev = null;
            cur.next = null;
            cur = curNext;
        }
        head = null;
        tail = null;
    }
}

  注意：上述代码中，只是简单模拟一下LinkedList中常用方法的实现逻辑，用的是基本数据类型，并没有像源码那样使用泛型，改成泛型更加通用，因为节点中的数据可能是引用数据类型或者自定义类型 。

  五：LinkedList细节

  5.1 插入和删除操作

  • LinkedList在进行插入和删除操作时非常高效，尤其是在链表中间插入或删除元素。但是，在进行大量的随机插入和删除操作时，需要注意维护链表的结构完整性，避免出现指针错误。

   在 Java 的LinkedList中进行频繁的插入和删除操作时，可以通过以下方法避免性能下降： 如果要在链表中间插入或删除元素，可以先使用迭代器找到目标位置，然后使用迭代器的add和remove方法进行操作。这样可以避免在遍历过程中频繁地调用get方法，提高性能。

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("cherry");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    if (element.equals("banana")) {
        iterator.remove(); // 删除元素
    }
}
iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    if (element.equals("apple")) {
        iterator.add("orange"); // 在元素后插入
    }
}

   5.2 遍历方式选择

  • 可以使用迭代器、增强型 for 循环和普通 for 循环进行遍历。如果只需要顺序遍历链表，迭代器和增强型 for 循环是比较好的选择，简洁且高效。如果需要在遍历过程中同时进行插入或删除操作，迭代器是更安全的方式，因为它可以正确地处理链表结构的变化。

  5.3 LinkedList插入和删除元素的平均时间复杂度为 O(1)，但在某些特殊情况下可能接近 O(n)。

  插入操作:

  在链表头部插入元素：只需要更新一个指针，将新节点的next指向原来的头节点，然后更新头节点为新节点。时间复杂度为 O(1)。

public void addFirst(E e) {
    linkFirst(e);
}

private void linkFirst(E e) {
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null)
        last = newNode;
    else
        f.prev = newNode;
    size++;
    modCount++;
}

  在链表尾部插入元素：同样只需要更新一个指针，将新节点的prev指向原来的尾节点，然后更新尾节点为新节点。时间复杂度为 O(1)。

public void addLast(E e) {
    linkLast(e);
}

void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode;
    else
        l.next = newNode;
    size++;
    modCount++;
}

   在链表中间插入元素：需要先找到插入位置，然后调整前后节点的指针。如果已知插入位置的前驱节点，那么插入操作的时间复杂度为 O(1)；如果需要从头开始遍历找到插入位置，那么时间复杂度接近 O(n)，其中 n 是链表的长度。

   删除链表中间元素：需要先找到要删除的节点，然后调整前后节点的指针。如果已知要删除节点的前驱节点，那么删除操作的时间复杂度为 O(1)；如果需要从头开始遍历找到要删除的节点，那么时间复杂度接近 O(n)，其中 n 是链表的长度。

  5.4 类型安全问题

  在使用LinkedList时，需要注意类型安全问题。如果存储不同类型的元素，可能会引发ClassCastException异常。可以使用泛型来确保链表中存储的元素类型一致。 

​
LinkedList list = new LinkedList();
list.add(10);
list.add("hello");
int number = (int) list.get(1); // 这里会抛出 ClassCastException

​

  5.5集合类之间的转换

  可以将LinkedList转换为其他集合类，例如使用toArray()方法将其转换为数组，或者使用ArrayList的构造函数将其转换为ArrayList。但在进行转换时，需要注意数据类型的兼容性和性能开销。

  5.6 并发修改异常

  • 在使用迭代器遍历LinkedList的同时进行修改操作（如添加或删除元素），可能会导致ConcurrentModificationException异常。因为迭代器在遍历过程中会维护一个修改计数器，当检测到集合被外部修改时，就会抛出异常。为了避免这种情况，可以使用迭代器的remove()方法在遍历过程中进行安全的删除操作，或者在修改后重新获取迭代器。

LinkedList<String> list = new LinkedList<>();
list.add("apple");
list.add("banana");
list.add("cherry");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    if (element.equals("banana")) {
        list.remove(element); // 这里会抛出 ConcurrentModificationException
    }
}

1. 如果在多线程环境下使用LinkedList，可以考虑使用并发安全的集合类，

如：ConcurrentLinkedQueue。这些集合类在设计时考虑了多线程并发访问的情况，提供了更高的性能和线程安全性。

2. 如果必须使用LinkedList，可以使用同步机制来保护对链表的访问。例如，可以使用synchronized关键字或者ReentrantLock来确保在多线程环境下对链表的操作是线程安全的。但需要注意同步带来的性能开销。

  5.7 空指针处理

  • 当从LinkedList中获取元素时，需要注意处理可能返回的null值，以避免空指针异常。特别是在使用迭代器遍历链表时，要确保对每个元素进行适当的空指针检查。

  5.8 内存管理问题

  1. 内存泄漏：如果在使用LinkedList的过程中，没有正确地管理对链表中元素的引用，可能会导致内存泄漏。例如，如果一个元素被插入到链表中，但在后续的操作中不再被需要，却仍然被链表中的节点引用着，那么这个元素所占用的内存就无法被垃圾回收器回收。方案：及时清理无用的引用：如果一个元素从链表中被删除，确保其引用被及时设置为null，以便垃圾回收器可以回收其占用的内存。

  2. 内存浪费：由于LinkedList的每个节点都需要额外的内存来存储前后节点的引用，对于存储大量小元素的情况，可能会导致相对较高的内存开销。相比之下，数组或其他更紧凑的数据结构可能会更节省内存。（方案：选择合适的数据结构）

  5.9特殊用途

  1. 双向链表的优势：LinkedList是双向链表，这意味着可以从链表的头部和尾部两个方向进行快速的插入和删除操作。例如，可以使用addFirst和removeFirst方法在链表头部进行高效的操作，这在一些特定的算法和数据结构中可能非常有用，如实现栈或队列的数据结构。

  2. 作为队列或栈的实现：虽然 Java 中有专门的Queue和Stack接口以及相应的实现类，但LinkedList可以很容易地用作队列或栈。例如，通过只使用addLast和removeFirst方法，可以将LinkedList用作队列；通过只使用addFirst和removeFirst方法，可以将其用作栈。

  3. 与其他数据结构的转换：LinkedList可以与其他数据结构进行转换，这在一些特定的场景下可能很有用。例如，可以将LinkedList转换为数组，或者将其转换为另一种集合类型。但在进行转换时，需要注意性能和类型安全问题。

  5.10 内存布局细节

  1. 节点结构：LinkedList的节点不仅包含数据元素，还包含前后节点的引用。这使得每个节点占用的内存相对较大，尤其是在存储小数据量时，与其他数据结构相比可能存在一定的内存浪费。例如，存储大量小整数时，ArrayList可能在内存使用上更加紧凑，因为它是基于数组实现的，而LinkedList的每个节点都需要额外的空间来存储指针。

  2. 内存碎片化：由于LinkedList的节点在内存中是分散存储的，频繁的插入和删除操作可能导致内存碎片化。虽然 Java 的垃圾回收机制会处理不再使用的节点，但在某些情况下，内存碎片化可能会影响程序的性能，尤其是在长时间运行的程序中。

  5.11 性能特性的微妙之处

  1. 遍历性能：虽然在插入和删除操作上表现出色，但LinkedList的遍历性能相对较差。这是因为在遍历过程中，需要逐个节点地通过指针进行访问，而不能像ArrayList那样通过索引快速定位元素。例如，在一个大型的LinkedList中进行顺序遍历可能比在同等大小的ArrayList中遍历要慢得多。

  2. 大尺寸链表的性能下降：当LinkedList变得非常大时，一些操作的性能可能会急剧下降。例如，在一个包含数十万甚至更多节点的链表中进行插入或删除操作，可能会因为需要遍历较长的距离来找到插入或删除位置而变得非常耗时。



 

qq_384136844
关注
  • 9
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javalist源码-LinkedList-in-Java:链表的Java源代码实现
05-19
在Java编程语言中，`LinkedList`是`List`接口的一个实现，它提供了链表数据结构的支持。`LinkedList`类在`java.util`包中定义，主要用于存储和操作有序的元素集合。这个类允许我们在列表的任何位置进行插入和删除...
LinkedList-in-Java:该程序实现了完整的链表集合
03-26
在"LinkedList-in-Java-master"这个压缩包中，可能包含了以下内容： - 源代码文件，展示了如何创建和操作LinkedList实例。 - 示例程序，演示了如何使用LinkedList进行增删查改操作。 - 单元测试，确保链表操作的正确...
Java数据结构-链表与LinkedList
daweidi的博客
07-11 2008
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节 点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。LinkedList实现了List接口。LinkedList没有实现RandomAccess接口，因此不支持随机访问。LinkedList的任意位置插入和删除元素时效率比较高，时间复杂度为O（1）方法解释尾插 e将 e 插入到 index 位置尾插 c 中的元素删除 index 位置元素。
Java数据结构11-死磕Java队列-LinkedList
孤山之王
10-01 941
Java队列
【Java数据结构】---List(LinkedList)
optimistic_chen的博客
08-11 1402
上篇博客详细写了ArrayList的相关问题，包括上图（极其重要），我会在最近几篇博客中都有附上。ArrayList的优点很明显，底层逻辑是一个数组，它通过下标去访问数据的速度非常快。但是在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低所以java集合框架中引入了LinkedList类，即链表结构。LinkedList的底层是双向链表结构由于链表没有将元素存储在连续。
Java数据结构-图
qq_51938362的博客
10-16 3026
Java图
Java数据结构-图详解
m0_63526467的博客
06-09 1720
Java数据结构-图详解
Java进阶篇--数据结构
m0_74293254的博客
08-17 2139
Java 提供了多种数据结构来有效地组织和处理数据。以下是一些常见的 Java 数据结构：是一种线性数据结构，用于存储固定大小的相同类型元素的连续序列，可以通过索引快速访问和修改元素。。在 Java 中，数组可以包含基本类型（如 int、double、char 等）或引用类型（如对象、字符串等）的元素。1.2 基本操作：初始化：创建一个数组，并为其赋初值。遍历：使用循环遍历数组中的每个元素。打印：将数组中的元素依次输出。最大值：遍历数组，通过比较找到数组中的最大值。
数据结构---桶排序
记录我目之所及的世界
12-17 892
桶排序
Java数据结构算法-图形算法
小橘子的博客
04-08 3014
深度优先搜索是一种用于遍历或搜索树或图的算法。这个算法会尽可能深地搜索树的分支。当节点v的所在边都已被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。广度优先搜索是另一种用于遍历或搜索树或图的算法。这个算法从根节点（或任意节点）开始，探索最近的节点，然后进一步探索下一层的节点，依此类推。
Java数据结构--List的介绍
m0_61801103的博客
03-11 1318
什么是List 在集合框架中，List是一个接口，继承自Collection。 Collection也是一个接口，该接口中规范了后序容器中常用的一些方法 Iterable也是一个接口，表示实现该接口的类是可以逐个元素进行遍历的 站在数据结构的角度来看，List就是一个线性表，即n个具有相同类型元素的有限序列，在该序列上可以执行增删改查以及变量等操作 List的使用 List是个接口，并不能直接用来实例化。 如果要使用，必须去实例化List的实现类。在集合框架中，ArrayList和Link
Java基础篇--数据结构
weixin_61500949的博客
05-19 2074
一、数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关系的数据元素的集合，通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率 二、常见的数据结构之栈： 1.数据进入栈模型的过程称为：压/进栈 2.数据离开栈模型的过程称为：弹/出栈 3.栈是一种数据先进后出的模型 三、常见的数据结构之数组 ： 1.查询数据通过索引定位，查询任意数据耗时相同，查询效率高 2.删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低 3添加数据时，添加位置后每个数据后移，
javalist数据结构-Java数据结构-------List.pdf
07-11
Java中的List接口是集合框架的重要组成部分，它定义了一组有序的元素序列，允许有重复的元素。ArrayList、Vector和LinkedList都是List接口的实现...在实际使用中，根据业务需求权衡性能和功能，选择最适合的数据结构。
java集合 collection-list-LinkedList详解
08-31
`LinkedList`类是实现`List`接口的一个具体类，它提供了链表结构的数据存储方式，允许在列表的任何位置进行插入和删除操作，而不需要移动其他元素。 `LinkedList`的主要特点包括： 1. **内部结构**：`LinkedList`...
The_Data_Structure-and-Algorithms--Java:JAVA中实现的数据结构和算法
04-17
数据结构和算法--Java 所有算法均以Java实现（出于教育目的） 这些实现是出于学习目的。 这些实现的效率可能不如Java标准库。 表中的内容：： 搜索算法 排序算法 数据结构 堆 队列 链表 树 贪婪算法 练习题
JAVA基础：数据类型、命名规范
weixin_53755148的博客
09-05 968
变量类型就是用来指定变量中存储数据的类型。也称为数据类型。
浅析synchronized锁升级的原理与实现 1
水w的博客
09-01 1233
浅析synchronized锁升级的原理与实现
基于JavaWeb开发的JavaSpringboot+Vue实现前后端分离房屋租赁系统
最新发布
央顺科技官方博客
09-05 371
2021年处于信息科技高速发展的大背景之下。在今天，缺少手机和电脑几乎已经成为不可能的事情，人们生活中已经难以离开手机和电脑。针对增加的成本管理和操作,各大商家非常有必要建立自己的网上房屋租赁平台系统，这既可以让更多的人体验到网络所带来的方便，也有助于提高房屋的租赁。在经过几十年的高速发展后，互联网已成为最流行、最普及的媒体，每天的信息流量甚至能比得上过去十年。其以便捷的信息交换、快速的沟通速度，悄然地改变着会员的消费方式。
计算机毕业设计选题推荐-任务管理系统-项目任务分配系统-Java/Python项目实战
IT研究室的博客
09-03 783
随着信息化技术的迅猛发展，各类企业和组织越来越依赖于高效的任务管理系统以保证其日常运营的顺利进行。根据IDC（国际数据公司）发布的报告显示，全球企业在数字化转型上的投入已达数千亿美元，其中相当一部分资金用于提升企业内部的管理效率。任务管理系统作为企业信息化的重要组成部分，能有效帮助企业分配、监控和反馈任务，从而提高工作效率。然而，尽管市场上已有多种任务管理系统，它们在功能、用户体验和适用性上存在显著差异。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值