2.基础的动态数据结构：链表

已于 2024-05-18 09:05:13 修改
阅读量969 收藏 16
点赞数 15
分类专栏： 数据结构与算法 文章标签： java 数据结构
于 2024-05-07 13:44:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43559187/article/details/138525233
版权

二、基础的动态数据结构：链表

在这里插入图片描述

1. 链表介绍

1.1 指针和引用

数据加载进内存
指针/引用：内存中的地址
在这里插入图片描述

1.2 为什么需要链表？

  • 用一组连续的内存空间，来存储一组具有相同类型的数据：
    int[] data = new int[5];
    在这里插入图片描述在这里插入图片描述
  • 堆内存中没有足够的连续内存空间，申请一个更大的数组，内存不够，数组初始化失败
    在这里插入图片描述能不能设计一种数据结构，合理的充分的利益非连续的内存空间

怎样去访问在非连续内存空间的数据呢?

  • 链表：

链表也是一个线性结构
链表不需要连续的内存空间，所以链表可以充分的利用存储空间
在这里插入图片描述

1.3 链表对比数组

每个内存空间除了存储数据外，还需要记录下一块内存空间的地址
在这里插入图片描述

  • 链表
    • 链表是动态数据结构，链表天然的支持动态扩容，数组需要进行resize才可以扩容
    • 链表可以充分的利用非连续的内存空间，提高内存的利用率
    • 在存储相同数量的数据时，链表需要的内存空间比数组大

1.4 节点表示

 class{
     E e;    //元素值
     Node next;    //下一个节点
 }

在这里插入图片描述

2. 单向链表

2.1 链表的基础实现

 public class LinkedList<E> {
     //节点内部类
    private class Node{
        E e;
        Node next;
 ​
        public Node(E e) {
            this.e = e;
        }
 ​
        public Node() {
        }
 ​
        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }
 ​
        @Override
        public String toString() {
            return e.toString();
        }
    }
 ​
    //头节点
     private Node head;
    //长度
     private int size;
 ​
     public LinkedList() {
         head = null;
         size = 0;
     }
 ​
     public int getSize(){
         return size;
     }
 ​
     public boolean isEmpty(){
         return size ==0;
     }
 }

2.2 查询指定索引的元素

链表的索引概念

  • 查询索引为3的节点的值
    在这里插入图片描述
    定义临时变量curr指向头节点
    在这里插入图片描述
  • 索引和size的关系
    在这里插入图片描述
    size永远比链表最大的索引值大1，指向最后一个节点的next为null的节点
    在这里插入图片描述
  • 代码实现查询指定索引的元素
    查询索引为3的节点的值
/**
     * 查询指定索引的节点的值
     * @param index
     * @return
     */
public E get(int index) {
    //检查index的合法性
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("get failed,index must >=0 and <size");
    }
    //定义临时变量指向头节点
    Node curr = head;
    for (int i = 0; i < index; i++) {
        curr = curr.next;
    }
    return curr.e;
}

public E getFirst() {
    return get(0);
}

private E getLast() {
    return get(size - 1);
}

2.3 修改指定索引节点的值

  • 修改索引为3的节点的值为88
    在这里插入图片描述
/**
     * 修改指定索引的节点的值
     * @param index
     * @param e
     */
public void set(int index,E e){
    //检查index的合法性
    if(index<0||index>=size){
        throw new IllegalArgumentException("get failed,index must >=0 and <size");
    }
    //定义临时变量指向头节点
    Node curr = head;
    for (int i = 0; i < index; i++) {
        curr = curr.next;
    }
    curr.e = e;
}

2.4 添加

两种情况，一种是在表头添加，另外一种是在链表中间部分添加

添加头节点

在这里插入图片描述

/**
     * 在链表表头新增头节点
     * @param e 新增节点需要存储的数据
     */
public void addFirst(E e){
    //新节点的值为e，新节点的下一个节点为head，再把新节点赋值给head
    //简化后：
    head = new Node(e,head);
    size++;
}
在链表中间添加节点

在这里插入图片描述
注意，第三步和第四步不能更换顺序
在这里插入图片描述

//表尾插入
public void addLast(E e){
    add(size,e);
}

/**
     * 在指定索引的位置插入新的节点
     * @param index 需要插入的位置
     * @param e 需要插入的数据
     */
public void add(int index,E e){
    //检查index的合法性
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("get failed,index must >=0 and <size");
    }
    //如果是在表头插入元素
    if(index == 0){
        addFirst(e);
    }else{
        //要插入位置的前一个节点
        Node prev = head;
        for (int i = 0; i < index - 1; i++) {
            prev = prev.next;
        }
        //优化后：
        prev.next = new Node(e,prev.next);
        size++;
    }
}

2.5 删除节点

删除头节点

在这里插入图片描述

/**
     * 删除链表的头节点
     * @return
     */
public E removeFirst(){
    if(head == null){
        return null;
    }
    Node delNode = head;
    head = head.next;
    delNode.next = null;
    size--;
    return delNode.e;
}
删除中间节点

在这里插入图片描述

//移除表尾
public E removeLast(){
    return remove(size-1);
}

/**
     * 删除指定索引的节点，并返回删除的节点的值
     * @param index
     * @return
     */
public E remove(int index){
    //检查index的合法性
    if(index<0||index>=size){
        throw new IllegalArgumentException("get failed,index must >=0 and <size");
    }

    if(index==0){
        return removeFirst();
    }else{
        Node prev = head;
        for (int i = 0; i < index - 1; i++) {
            prev = prev.next;
        }
        Node delNode = prev.next;
        prev.next = delNode.next;
        delNode.next = null;
        size--;
        return delNode.e;
    }
}

2.6总代码(未使用虚拟头节点)

 package com.douma.line.linkedList;
 ​
 public class LinkedList<E> {
 ​
     //节点类
     private class Node {
         E e;
         Node next;
 ​
         public Node(E e) {
             this.e = e;
         }
 ​
         public Node() {
         }
 ​
         public Node(E e, Node next) {
             this.e = e;
             this.next = next;
         }
 ​
         @Override
         public String toString() {
             return e.toString();
         }
     }
 ​
     //头节点
     private Node head;
     //长度
     private int size;
 ​
     public LinkedList() {
         head = null;
         size = 0;
     }
 ​
     public int getSize() {
         return size;
     }
 ​
     public boolean isEmpty() {
         return size == 0;
     }
 ​
     /**
      * 查询指定索引的节点的值
      * @param index
      * @return
      */
     public E get(int index) {
         //检查index的合法性
         if (index < 0 || index >= size) {
             throw new IllegalArgumentException("get failed,index must >=0 and <size");
         }
         //定义临时变量指向头节点
         Node curr = head;
         for (int i = 0; i < index; i++) {
             curr = curr.next;
         }
         return curr.e;
     }
 ​
     public E getFirst() {
         return get(0);
     }
 ​
     private E getLast() {
         return get(size - 1);
     }
 ​
     /**
      * 修改指定索引的节点的值
      *
      * @param index
      * @param e
      */
     public void set(int index, E e) {
         //检查index的合法性
         if (index < 0 || index >= size) {
             throw new IllegalArgumentException("get failed,index must >=0 and <size");
         }
         //定义临时变量指向头节点
         Node curr = head;
         for (int i = 0; i < index; i++) {
             curr = curr.next;
         }
         curr.e = e;
     }
 ​
     /**
      * 在链表表头新增头节点
      * @param e 新增节点需要存储的数据
      */
     public void addFirst(E e){
         //新节点的值为e，新节点的下一个节点为head，再把新节点赋值给head
         head = new Node(e,head);
         size++;
     }
 ​
     //表尾插入
     public void addLast(E e){
         add(size,e);
     }
 ​
     /**
      * 在指定索引的位置插入新的节点
      * @param index 需要插入的位置
      * @param e 需要插入的数据
      */
     public void add(int index,E e){
         //检查index的合法性
         if (index < 0 || index >= size) {
             throw new IllegalArgumentException("get failed,index must >=0 and <size");
         }
         //如果是在表头插入元素
         if(index == 0){
             addFirst(e);
         }else{
             //要插入位置的前一个节点
             Node prev = head;
             for (int i = 0; i < index - 1; i++) {
                 prev = prev.next;
             }
             //优化后：
             prev.next = new Node(e,prev.next);
             size++;
         }
     }
 ​
     /**
      * 删除链表的头节点
      * @return
      */
     public E removeFirst(){
         if(head == null){
             return null;
         }
         Node delNode = head;
         head = head.next;
         delNode.next = null;
         size--;
         return delNode.e;
     }
 ​
     //移除表尾
     public E removeLast(){
         return remove(size-1);
     }
 ​
     /**
      * 删除指定索引的节点，并返回删除的节点的值
      * @param index
      * @return
      */
     public E remove(int index){
         //检查index的合法性
         if(index<0||index>=size){
             throw new IllegalArgumentException("get failed,index must >=0 and <size");
         }
 ​
         if(index==0){
             return removeFirst();
         }else{
             Node prev = head;
             for (int i = 0; i < index - 1; i++) {
                 prev = prev.next;
             }
             Node delNode = prev.next;
             prev.next = delNode.next;
             delNode.next = null;
             size--;
             return delNode.e;
         }
     }
 }

3. 单向链表优化

3.1 虚拟(哨兵)节点

简化头节点和其他节点的处理逻辑
在之前的新增或删除时都要特殊考虑头节点，因为都用到了待新增(删除)节点的前一个节点
在这里插入图片描述
加入哨兵节点后会使得处理头节点的逻辑和处理中间节点的逻辑变的一致

package com.douma.line.linkedList;

public class LinkedList<E> {

    //节点类
    private class Node {
        E e;
        Node next;

        public Node(E e) {
            this.e = e;
        }

        public Node() {
        }

        public Node(E e, Node next) {
            this.e = e;
            this.next = next;
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    //虚拟头节点
    private Node dummyHead;
    //长度
    private int size;

    public LinkedList() {
        dummyHead = new Node();
        size = 0;
    }

    public int getSize() {
        return size;
    }

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

    /**
     * 查询指定索引的节点的值
     * @param index
     * @return
     */
    public E get(int index) {
        //检查index的合法性
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get failed,index must >=0 and <size");
        }
        //定义临时变量指向头节点
        Node curr = dummyHead.next;
        for (int i = 0; i < index; i++) {
            curr = curr.next;
        }
        return curr.e;
    }

    public E getFirst() {
        return get(0);
    }

    private E getLast() {
        return get(size - 1);
    }

    /**
     * 修改指定索引的节点的值
     *
     * @param index
     * @param e
     */
    public void set(int index, E e) {
        //检查index的合法性
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get failed,index must >=0 and <size");
        }
        //定义临时变量指向头节点
        Node curr = dummyHead.next;
        for (int i = 0; i < index; i++) {
            curr = curr.next;
        }
        curr.e = e;
    }

    /**
     * 在链表表头新增头节点
     * @param e 新增节点需要存储的数据
     */
    public void addFirst(E e){
        add(0,e);
    }

    //表尾插入
    public void addLast(E e){
        add(size,e);
    }

    /**
     * 在指定索引的位置插入新的节点
     * @param index 需要插入的位置
     * @param e 需要插入的数据
     */
    public void add(int index,E e){
        //检查index的合法性
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get failed,index must >=0 and <size");
        }

        //要插入位置的前一个节点
        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        //优化后：
        prev.next = new Node(e,prev.next);
        size++;
    }

    /**
     * 删除链表的头节点
     * @return
     */
    public E removeFirst(){
       return remove(0);
    }

    //移除表尾
    public E removeLast(){
        return remove(size-1);
    }

    /**
     * 删除指定索引的节点，并返回删除的节点的值
     * @param index
     * @return
     */
    public E remove(int index){
        //检查index的合法性
        if(index<0||index>=size){
            throw new IllegalArgumentException("get failed,index must >=0 and <size");
        }

        Node prev = dummyHead;
        for (int i = 0; i < index; i++) {
            prev = prev.next;
        }
        Node delNode = prev.next;
        prev.next = delNode.next;
        delNode.next = null;
        size--;
        return delNode.e;
    }
}

3.2 链表遍历的另一种方式

在这里插入图片描述

/**
     * 判断链表中是否存在指定元素
     * @param e
     * @return
     */
public boolean contains(E e){
    Node curr = dummyHead.next;
    while (curr!=null){
        if(curr.e.equals((e))){
            return true;
        }
        curr = curr.next;
    }
    return false;
}

3.3 覆写toString方法

@Override
public String toString() {
    StringBuilder sb = new StringBuilder();
    Node curr = dummyHead.next;
    while (curr!=null){
        sb.append(curr+"=>");
        curr = curr.next;
    }
    sb.append("null");
    return sb.toString();
}

3.4 链表方法测试

 public class LinkedListTest {
     public static void main(String[] args) {
         LinkedList<Integer> list = new LinkedList<>();
         list.addLast(5);
         System.out.println(list);
 ​
         list.addFirst(10);
         System.out.println(list);
 ​
         list.add(2,34);
         System.out.println(list);
 ​
         list.addFirst(5);
         System.out.println(list);
 ​
         System.out.println(list.get(1));
 ​
         list.remove(3);
         System.out.println(list);
     }
 }

3.5 链表时间复杂度分析

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4. 双向链表

4.1 基本实现

在这里插入图片描述

 //节点类
 private class Node {
     E e;
     Node prev;
     Node next;
 ​
     public Node(E e) {
         this.e = e;
     }
 ​
     public Node() {
     }
 ​
     public Node(E e, Node prev, Node next) {
         this.e = e;
         this.prev = prev;
         this.next = next;
     }
 ​
     @Override
     public String toString() {
         return e.toString();
     }
 }
 ​
 private int size;
 ​
 public DoubleLinkedList(){
     first = last = null;
 }
 ​
 public int getSize(){
     return size;
 }
 ​
 public boolean isEmpty(){
     return size==0;
 }

4.2 优缺点

耗费内存
有时要比单向链表性能好很多
例如：
在这里插入图片描述
空间换时间

/**
     *  找到指定索引index所在的节点的元素值
     * @param index
     * @return
     */
//时间复杂度O(n)
public E get(int index){
    //检查index的合法性
    if (index < 0 || index >= size) {
        throw new IllegalArgumentException("get failed,index must >=0 and <size");
    }

    if(index<size/2){
        Node curr = first;
        for (int i = 0; i < index; i++) {
            curr = curr.next;
        }
        return curr.e;
    }else {
        Node curr = last;
        for (int i = 0; i < size - index - 1; i++) {
            curr = curr.prev;
        }
        return curr.e;
    }
}

4.3 优势

//表头和表尾时间复杂度为O(1)
public Node getFirst(){
    return first;
}

public Node getLast(){
    return last;
}

4.4 修改双向链表节点的值

将通过指定索引查询节点的方法抽离出来

/**
     * 返回指定索引的节点
     * @param index
     * @return
     */
private Node node(int index){
    //检查index的合法性
    if (index < 0 || index >= size) {
        throw null;
    }

    if(index<size/2){
        Node curr = first;
        for (int i = 0; i < index; i++) {
            curr = curr.next;
        }
        return curr;
    }else {
        Node curr = last;
        for (int i = 0; i < size - index - 1; i++) {
            curr = curr.prev;
        }
        return curr;
    }
}

修改通过指定索引查找元素值的方法

/**
     *  找到指定索引index所在的节点的元素值
     * @param index
     * @return
     */
//时间复杂度O(n)
public E get(int index){
    Node node = node(index);
    if(node == null){
        throw new IllegalArgumentException("get failed,index must >=0 and <size");
    }
    return node.e;
}

创建修改指定索引元素值的方法

/**
     * 修改双向链表指定索引的值
     * @param index
     * @param e
     */
public void set(int index,E e){
    Node node = node(index);
    if(node==null){
        throw new IllegalArgumentException("get failed,index must >=0 and <size");
    }
    node.e = e;
}

4.5 插入节点

插入头节点

链表一个节点都没有的情况：
在这里插入图片描述
链表中本来就存在节点：
在这里插入图片描述

 /**
      * 往链表的表头插入节点
      * @param e
      */
 //时间复杂度为O(1)
 public void addFirst(E e){
     Node newNode = new Node(e);
     if(first == null){
         last = newNode;
     }else{
         newNode.next = first;
         first.prev = newNode;
     }
     first = newNode;
     size++;
 }
插入尾节点

链表为空：
在这里插入图片描述
链表中本身已经存在节点：
在这里插入图片描述

/**
     * 往链表的表尾插入节点
     * @param e
     */
//时间复杂度为O(1)
public void addLast(E e){
    Node newNode = new Node(e);
    if(first == null){
        first = newNode;
    }else{
        newNode.prev = last;
        last.next = newNode;
    }
    last = newNode;
    size++;
}
插入中间节点

在这里插入图片描述

/**
     * 往指定索引位置插入节点
     * @param index
     * @param e
     */
public void add(int index,E e){
    //检查index的合法性
    if (index < 0 || index > size) {
        throw new IllegalArgumentException("get failed,index must >=0 and <=size");
    }
    if(index == size){
        addLast(e);
    }else if(index == 0){
        addFirst(e);
    }else{
        Node oldNode = node(index);
        Node prev = oldNode.prev;
        Node newNode = new Node(e,prev,oldNode);
        oldNode.prev = newNode;
        prev.next = newNode;
        size++;
    }
}

4.6 删除节点

删除头节点

链表只有一个节点：
在这里插入图片描述
链表中不止一个节点：
在这里插入图片描述

 /**
      * 删除头节点
      * @return
      */
 //时间复杂度O(1)
 public E removeFirst(){
     if(first == null){
         throw new NoSuchElementException();
     }
     E e = first.e;
     Node next = first.next;
     if(next == null){
         first = null;
         last = null;
     }else{
         first.next = null;
         next.prev = null;
         first = next;
     }
     size--;
     return e;
 }
删除尾节点

链表只有一个节点：
在这里插入图片描述
链表不止一个节点：
在这里插入图片描述

/**
     * 删除尾节点
     * @return
     */
//时间复杂度O(1)
public E removeLast(){
    if(last == null){
        throw new NoSuchElementException();
    }
    E e = last.e;
    Node prev = last.prev;
    if(prev == null){
        last = null;
        first = null;
    }else{
        last.prev = null;
        prev.next = null;
        last = prev;
    }
    size--;
    return e;
}
删除中间节点

在这里插入图片描述

 /**
      * 删除指定索引的节点
      * @return
      */
 public E remove(int index){
     //检查index的合法性
     if (index < 0 || index >= size) {
         throw new IllegalArgumentException("get failed,index must >=0 and <size");
     }
     if(index == 0){
         return removeFirst();
     }else if(index == size-1){
         return removeLast();
     }
 ​
     Node delNode = node(index);
     E e = delNode.e;
 ​
     Node prev = delNode.prev;
     Node next = delNode.next;
 ​
     //将删除节点的前后节点联系起来
     prev.next = next;
     next.prev = prev;
 ​
     //将删除节点从链表中断开
     delNode.next = null;
     delNode.prev = null;
     size--;
     return e;
 }

4.7 总代码

 import java.util.NoSuchElementException;
 ​
 public class DoubleLinkedList<E> {
 ​
     //节点类
     private class Node {
         E e;
         Node prev;
         Node next;
 ​
         public Node(E e) {
             this.e = e;
         }
 ​
         public Node() {
         }
 ​
         public Node(E e, Node prev, Node next) {
             this.e = e;
             this.prev = prev;
             this.next = next;
         }
 ​
         @Override
         public String toString() {
             return e.toString();
         }
     }
 ​
     private Node first;
     private Node last;
     private int size;
 ​
     public DoubleLinkedList(){
         first = last = null;
     }
 ​
     public int getSize(){
         return size;
     }
 ​
     public boolean isEmpty(){
         return size==0;
     }
 ​
     /**
      *  找到指定索引index所在的节点的元素值
      * @param index
      * @return
      */
     //时间复杂度O(n)
     public E get(int index){
         Node node = node(index);
         if(node == null){
             throw new IllegalArgumentException("get failed,index must >=0 and <size");
         }
         return node.e;
     }
 ​
     //表头和表尾时间复杂度为O(1)
     public Node getFirst(){
         return first;
     }
 ​
     public Node getLast(){
         return last;
     }
 ​
     /**
      * 返回指定索引的节点
      * @param index
      * @return
      */
     //时间复杂度O(n/2)本质上也是O(n)
     private Node node(int index){
         //检查index的合法性
         if (index < 0 || index >= size) {
             throw null;
         }
 ​
         Node curr = null;
         if(index<size/2){
             curr = first;
             for (int i = 0; i < index; i++) {
                 curr = curr.next;
             }
         }else {
             curr = last;
             for (int i = 0; i < size - index - 1; i++) {
                 curr = curr.prev;
             }
         }
         return curr;
     }
 ​
     /**
      * 修改双向链表指定索引的值
      * @param index
      * @param e
      */
     //时间复杂度O(n)
     public void set(int index,E e){
         Node node = node(index);
         if(node==null){
             throw new IllegalArgumentException("get failed,index must >=0 and <size");
         }
         node.e = e;
     }
 ​
     /**
      * 往链表的表头插入节点
      * @param e
      */
     //时间复杂度为O(1)
     public void addFirst(E e){
         Node newNode = new Node(e);
         if(first == null){
             last = newNode;
         }else{
             newNode.next = first;
             first.prev = newNode;
         }
         first = newNode;
         size++;
     }
 ​
     /**
      * 往链表的表尾插入节点
      * @param e
      */
     //时间复杂度为O(1)
     public void addLast(E e){
         Node newNode = new Node(e);
         if(first == null){
             first = newNode;
         }else{
             newNode.prev = last;
             last.next = newNode;
         }
         last = newNode;
         size++;
     }
 ​
     /**
      * 往指定索引位置插入节点
      * @param index
      * @param e
      */
     //时间复杂度O(n)
     public void add(int index,E e){
         //检查index的合法性
         if (index < 0 || index > size) {
             throw new IllegalArgumentException("get failed,index must >=0 and <=size");
         }
         if(index == size){
             addLast(e);
         }else if(index == 0){
             addFirst(e);
         }else{
             Node oldNode = node(index);
             Node prev = oldNode.prev;
             Node newNode = new Node(e,prev,oldNode);
             oldNode.prev = newNode;
             prev.next = newNode;
             size++;
         }
     }
 ​
     /**
      * 删除头节点
      * @return
      */
     //时间复杂度O(1)
     public E removeFirst(){
         if(first == null){
             throw new NoSuchElementException();
         }
         E e = first.e;
         Node next = first.next;
         if(next == null){
             first = null;
             last = null;
         }else{
             first.next = null;
             next.prev = null;
             first = next;
         }
         size--;
         return e;
     }
 ​
     /**
      * 删除尾节点
      * @return
      */
     //时间复杂度O(1)
     public E removeLast(){
         if(last == null){
             throw new NoSuchElementException();
         }
         E e = last.e;
         Node prev = last.prev;
         if(prev == null){
             last = null;
             first = null;
         }else{
             last.prev = null;
             prev.next = null;
             last = prev;
         }
         size--;
         return e;
     }
 ​
     /**
      * 删除指定索引的节点
      * @return
      */
     //时间复杂度O(n)
     public E remove(int index){
         //检查index的合法性
         if (index < 0 || index >= size) {
             throw new IllegalArgumentException("get failed,index must >=0 and <size");
         }
         if(index == 0){
             return removeFirst();
         }else if(index == size-1){
             return removeLast();
         }
 ​
         Node delNode = node(index);
         E e = delNode.e;
 ​
         Node prev = delNode.prev;
         Node next = delNode.next;
 ​
         //将删除节点的前后节点联系起来
         prev.next = next;
         next.prev = prev;
 ​
         //将删除节点从链表中断开
         delNode.next = null;
         delNode.prev = null;
         size--;
         return e;
     }
 }

5. 学习与分享

在这里插入图片描述

懿所思
关注
  • 15
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第4章 最基础的动态数据结构：链表
Kaptcha的学习
03-02 1339
第四章 最基础的动态数据结构：链表4-1 什么是链表链表数组与链表的对比4-2 链表Linked List在链表头添加元素在链表中间和末尾添加元素4-3 使用链表的虚拟头结点4-4 链表的遍历，查询和修改4-5 从链表中删除元素链表的时间复杂度分析4-6 使用链表实现栈4-7 带有尾指针的链表：使用链表实现队列 4-1 什么是链表 为什么链表很重要 链表：真正的动态数据结构 最简单的动态数据结...
01基础数据结构之链表
09-14
链表数据结构知识点 ...链表是一种基本的数据结构，它具有动态的存储能力和灵活的插入删除能力，但同时也存在一些缺点，如访问时间复杂度高。因此，在实际应用中，需要根据具体情况选择合适的数据结构。
数据结构：链表及其C++实现
热门推荐
forGemini的博客
05-26 1万+
前言 链表是一种非常非常基础的数据结构，本文首先讲解链表的基础知识，然后使用C++的模板实现了一个链表类，并简单实现了常见的插入、删除、查找等算法。 阅读本文需要对C/C++的指针具有一定的了解。 基础知识 链表是一种逻辑上连续，内存上分散的线性表数据结构，其基本单位为结点，每个结点分数据区和指针区，数据区用于存放数据，指针区则用于指向其他结点，通过指针每个结点就被串接成了一条“链子”。
基础数据结构【链表：动态链表，（结构体，一维数组）静态链表、STL list】
ren_dao的博客
03-10 987
链接性：链表中的每个节点包含一个指针，指向下一个节点（单向链表）或前一个节点（双向链表）。通过这种链接关系，可以将一系列节点按照特定顺序连接在一起。动态性：链表的大小可以动态地调整，可以动态地添加或删除节点，而不需要像数组那样需要提前申请固定大小的内存空间。灵活性：链表可以在任何位置插入或删除节点，而不会影响其他节点的位置，因为每个节点都包含指针信息，可以直接访问相邻节点。内存空间的分散性：链表的节点在内存中可以分散存储，不要求一块连续的内存空间。这也是链表可以动态调整大小的原因。
数据结构与算法:1.链表结构
绝世这天下的博客
03-18 3636
1 Python链表 1.1基本概念 概念：链表是通过一个个节点组成的，每个节点都包含了称为cargo的基本单元，它也是一种**递归**的数据结构。 图示：能保持数据之间的逻辑顺序，但不必按照顺序存储。 和C不一样的是python没有专门的指针概念，在python中每个变量都是指针 链表的删除可以通过修改指针来实现 Python实现链表的方法： class Node: ''' data:节点保存的数据 _next:保存下一个节点对象 ''' def __init
数据结构：动态链表（C语言描述）
一条咸鱼的博客
07-04 5631
这一篇文章我们先简单的说一下动态链表，下一篇整理静态链表。 主要内容：普通单链表，单向循环链表和双向循环链表，如何判断链表中是否包含环和入环点的确定，以及一些经典题目。 ①普通单链表： 这里我只是简单的定义了一个长度为10的单链表并输出相关内容，并没有写创建、插入、删除、查找等相关功能。对链表熟悉了之后就会发现创建链表的头插法和尾插法只是两个模板而已。下面的代码创建链表的方法就十分简单。 普通单链表不从头节点开始遍历就无法遍历完全部的节点。这在某些情况下具有很大的弊端。 #include<
数据结构入门指南：链表（新手避坑指南）
2202_75605090的博客
07-30 5946
前边我们学习了顺序表，顺序表是数据结构中最简单的一种线性数据结构，今天我们来学习链表，难度相较于顺序表会大幅增加，非常考验大家对结构体、指针的理解。但是也不要害怕，我会一一向大家解答疑惑，本期的内容先给初学者预预热，主要介绍在刚开始实现链表时注意的点以及逻辑基础，下期会将功能接口具体实现。}SLNode;定义链表这里就迎来了第一个坑，上述的这种形式很常见，对于初学者来说这里就有一个坑，这个链表定义的是否正确呢？这种方式是不正确的，为什么？
数据结构： 数组与链表
timberman666的博客
10-02 1591
数据结构： 数组与链表
重温四大基础数据结构：数组、链表、队列和栈
“逛丢一只鞋”的博客
09-06 1849
文章目录前言数组链表队列栈 前言 数组、链表、队列、栈，是数据结构中最基础的四大结构，数组和链表更是基础中的基础，后续所有复杂的数据结构都是在它们的基础上演变而来的。 本节，我们就来重温这四大结构。 数组 关于数组，大家都比较熟悉了。 它是一种线性数据结构，使用一组连续的内存空间存储一组具有相同类型的数据。 这个概念中有三个关键词：线性、连续、相同类型。 线性，表示没有分叉，任意元素的前后元素最多只有一个，同样是线性结构的还有链表、队列等。 连续，它在内存空间中的存储是连续的，不间断的，前后两个元素紧挨着
四大基础数据结构：数组、链表、队列和栈
weixin_46585151的博客
03-22 3028
四大基础数据结构：数组、链表、队列和栈1、时间复杂度（大O表示法）2、数组3. 链表合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 1、时间复杂度（大O表示法） 衡量时间复杂度与空间复杂度的计数表示，即 衡量算法时间长与不长、占用内存多与多
数据结构链表入门.docx
01-13
《数据结构链表入门》 链表是一种基础且重要的数据结构，在计算机科学中扮演着不可或缺的角色。本资料主要介绍链表的基本概念、操作以及如何在C++中实现链表。以下将详细阐述链表的原理及其在代码中的体现。 1. ...
数据结构-链表.pdf
08-15
数据结构-链表是计算机科学和信息技术领域中的一个基础概念，它广泛应用于计算机科学和信息技术领域。链表是一种非常重要的数据结构，它可以分为单向链表、循环链表和双向循环链表等。链表的优点是插入和删除操作...
一、基础数据结构-1.链表-2.静态链表
01-17
一、基础数据结构-1.链表-2.静态链表
数据结构课设一：链表实现大数相加
04-24
该文件夹是用vs2017实现的整个项目文件，作为数据结构的第一次上机实习，用的也只是一些数据结构中较为基础的知识，仅仅用到最简单的链表就能实现大数的相加，该代码仅供参考，代码还是自己动手实现才有意义。
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 624
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 705
JSON，Ajax
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 953
GeoServerBasePage 登录
Javase.认识异常
最新发布
Joseit的博客
06-21 1135
在Java开发中，异常处理是确保程序稳定性和可靠性的关键环节。这篇blog深入解析了Java异常的概念、体系、处理策略及自定义异常类。它介绍了异常的基本概念与分类，详细阐述了异常抛出、捕获与处理的最佳实践，包括防御式编程策略、try-catch结构的使用、以及finally块在资源清理中的作用。此外，还涵盖了自定义异常类以满足特定业务需求的重要性。通过学习本blog，读者可以深入理解Java异常处理机制，提升代码质量。
pintos基础数据结构:通用链表
11-01
Pintos是一个操作系统的教学项目，它里面有许多基础的数据结构。其中之一就是通用链表（generic list）。 链表是一个常见的数据结构，用于存储一系列的元素。在Pintos中，通用链表是一种灵活且可扩展的数据结构，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

懿所思

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

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

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

打赏作者

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

抵扣说明：

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

余额充值