集合-LinkedList

已于 2023-04-14 08:07:49 修改
阅读量675 收藏 2
点赞数 2
分类专栏： 集合容器 文章标签： 数据结构 java 链表 容器
于 2023-04-12 16:43:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44715376/article/details/130111027
版权

LinkedList

LinkedList的概述

LinkedList的底层使用双向链表实现。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YFvfuWIM-1681288911283)(E:\Java笔记\javaSE\集合（容器）（9）\集合\LinkedList.assets\image-20230406115511053.png)]

链表是一种线性数据结构，其中每个元素都是一个单独的对象，包含一个指向列表中下一个节点的引用。

它可以用于实现各种抽象数据类型，例如列表、堆栈、队列等。

LinkedList的优缺点

优点

  • 插入和删除操作的时间复杂度为O(1)，相比于数组的O(n)更加高效。
  • 链表的大小可以动态调整，不像数组需要预先分配空间。
  • 链表的节点可以在内存中部连续存储，因此可以更加的灵活的利用内存空间。

缺点

  • 访问元素的时间复杂度为O(n)，相比于数组的O(1)较低效。
  • 链表需要额外的空间来存储指向下一个节点的指针，因此占用的空间比数组更大。
  • 链表的随机访问效率比较低，因为需要从头开始遍历链表才能找到指定位置的节点。

LinkedList的创建方式

LinkedList linkedList = new LinkedList();
//向上转型
List linkedLists = new LinkedList();

常用方法，以及源码分析

方法返回类型解释
add(E e)boolean将指定元素添加到此列表的结尾
add(int index, E element)void将此列表中指定的位置插入指定的元素
addFirst(E e)void将指定元素插入此列表的开头
addLast(E e)void将指定元素添加到此列表的结尾
clear()void从此列表中移除所有元素
get(int index)E返回此列表中指定位置处的元素
getFirst()E返回此列表的第一个元素
remove()E获取并移除此列表的头（第一个元素）
remove(int index)E移除此列表中指定位置的元素
removeFirst()E移除并返回此列表的第一个元素
removelast()E移除并返回此列表的最后一个元素
set(int index,E element)E将此列表中指定位置的元素替换为指定的元素
size（）int返回此列表的元素数

add(E e)

源码分析：

通过调用 linkLast(E e) 方法将元素添加到链表的末尾。

linkLast(E e) 方法创建一个新的节点，并将其插入到链表的末尾。如果链表为空，则将新节点设置为第一个节点。否则，将新节点链接到最后一个节点。最后，更新链表的大小和 modCount 变量。

	public boolean add(E e) {
        //调用linklast方法将元素添加到链表的尾端
    	linkLast(e);
        //添加成功，返回true
    	return true;
	}
	void linkLast(E e) {
        //获取链表的最后一个节点
        final Node<E> l = last;
        //创建最后一个节点，他的前驱节点是l，后去节点为null，数据为e
        final Node<E> newNode = new Node<>(l, e, null);
        //将链表的尾节点指向新节点
        last = newNode;
        //判断节点是否为null
        if (l == null)
            //为null则将节点指向新节点
            first = newNode;
        else
            //如果不为null，将原尾节点的后继节点指向新节点
            l.next = newNode;
        //聊表的大小加1
        size++;
        //修改计数器
        modCount++;
    }
案例：
public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
    	//添加数据
        linkedList.add("张三");
        linkedList.add("李四");
    	//输出此列表
        System.out.println(linkedList);
    }

add(int index, E element)

源码分析：

将元素添加到指定位置

public void add(int index, E element) {
   		 //检查索引是否越界
        checkPositionIndex(index);
		//索引与长度相等
        if (index == size)
            //在链表尾部添加数据
            linkLast(element);
        else
            //在指定位置之前添数据
            linkBefore(element, node(index));
    }

    private void checkPositionIndex(int index) {
        //判断索引是否合法
        if (!isPositionIndex(index))
            //不合法则抛出下标越界异常
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }

    void linkLast(E e) {
        //获取链表的最后一个节点
        final Node<E> l = last;
        //创建一个新的节点，他的前驱节点是l，后去节点为null，数据为e
        final Node<E> newNode = new Node<>(l, e, null);
        //将链表的最后一个节点指向新节点
        last = newNode;
        //判断链表是否为null
        if (l == null)
            //将第一个节点指向新节点
            first = newNode;
        //如果不为null
        else
            //将最后一个节点的下一个节点指向新节点
            l.next = newNode;
        //链表大小加1
        size++;
        //修改计数器加1
        modCount++;
    }
    void linkBefore(E e, Node<E> succ) {
        //获取指定位置的前一个节点
        final Node<E> pred = succ.prev;
        //创建一个新节点
        final Node<E> newNode = new Node<>(pred, e, succ);
        //将指定位置的前一个节点的下一个节点指向新节点
        succ.prev = newNode;
        //如果指定位置的前一个节点为null，
        if (pred == null)
            //将第一个节点指向新节点
            first = newNode;
        //如果指定位置的前一个节点不为null
        else
            //将前一个节点的下一个节点指向新节点
            pred.next = newNode;
        //链表大小加1
        size++;
        //修改计数器加1
        modCount++;
    }
案例:
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    System.out.println(linkedList);
    //位置1，添加数据
    linkedList.add(1,"王五");
    System.out.println(linkedList);
}

addFirst(E e)

源码分析：

将指定元素插入到此列表的开头

public void addFirst(E e) {
    // 在链表的头部添加一个新节点
    linkFirst(e);
}
private void linkFirst(E e) {
    // 获取头节点
	final Node> f = first;
	// 创建一个新节点，它的前驱节点为null，数据为e，后继节点为头节点f
	final Node> newNode = new Node<>(null, e, f);
	// 将头节点指向新节点
	first = newNode;
	// 如果头节点为null，说明
	if (f == null)
        //链表为空，将尾节点指向新节点
		last = newNode;
	// 否则将头节点的前驱节点指向新节点
	else
		f.prev = newNode;
	// 链表长度加1
	size++;
	// 修改次数加1
	modCount++;
  }
案例：
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    System.out.println(linkedList);

    linkedList.add(1,"王五");
    System.out.println(linkedList);
	//列表开头添加数据
    linkedList.addFirst("赵六");
    System.out.println(linkedList);

}

addLast(E e)

源码分析：

将指定元素添加到此列表的结尾

 public void addLast(E e) {
     //在链表的尾部添加一个新节点
        linkLast(e);
    }
void linkLast(E e) {
        //获取链表的最后一个节点
        final Node<E> l = last;
        //创建一个新的节点，他的前驱节点是l，后去节点为null，数据为e
        final Node<E> newNode = new Node<>(l, e, null);
        //将链表的最后一个节点指向新节点
        last = newNode;
        //判断链表是否为null
        if (l == null)
            //将第一个节点指向新节点
            first = newNode;
        //如果不为null
        else
            //将最后一个节点的下一个节点指向新节点
            l.next = newNode;
        //链表大小加1
        size++;
        //修改计数器加1
        modCount++;
    }
案例：
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    System.out.println(linkedList);

    linkedList.add(1,"王五");
    System.out.println(linkedList);

    linkedList.addFirst("赵六");
    System.out.println(linkedList);
	//列表结尾添加数据
    linkedList.addLast("唐七");
    System.out.println(linkedList);
}

clear()：

源码分析:

从此列表中移除所有元素

public void clear() {
    // 遍历链表中的每一个节点
    for (Node<E> x = first; x != null; ) {
        // 保存当前节点的下一个节点
        Node<E> next = x.next;
        // 将当前节点的数据项置为null
        x.item = null;
        // 将当前节点的前驱和后继节点都置为null
        x.next = null;
        x.prev = null;
        // 将当前节点指向下一个节点
        x = next;
    }
    // 将链表的头节点和尾节点都置为null
    first = last = null;
    // 将链表的大小置为0
    size = 0;
    // 修改计数器
    modCount++;
}
案例：
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.add(1,"王五");
    linkedList.addFirst("赵六");
    linkedList.addLast("唐七");
    System.out.println(linkedList);

    //清除此列表数据
    linkedList.clear();
    System.out.println(linkedList);;
}

get(int index)

源码分析：

返回此列表中指定位置处的元素

public E get(int index) {
    //校验索引是否合法
    checkElementIndex(index);
    //返回该索引对应的节点的数据
    return node(index).item;
}
private void checkPositionIndex(int index) {
        //判断索引是否合法
        if (!isPositionIndex(index))
            //不合法则抛出下标越界异常
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
Node<E> node(int index) {
      // 如果要查找的节点在链表的前半部分
        if (index < (size >> 1)) {
            // 从头节点开始遍历
            Node<E> x = first;
            // 遍历到要查找的节点
            for (int i = 0; i < index; i++)
                // 指针指向下一个节点
                x = x.next;
            // 返回查找到的节点
            return x;
            // 如果要查找的节点在链表的后半部分
        } else {
            // 从尾节点开始遍历
            Node<E> x = last;
            // 遍历到要查找的节点
            for (int i = size - 1; i > index; i--)
                // 指针指向上一个节点	
                x = x.prev;
            // 返回查找到的节点
            return x;
        }
    }
案例：
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.add(1,"王五");
    linkedList.addFirst("赵六");
    linkedList.addLast("唐七");
    System.out.println(linkedList);

    //获取指定位置的数据
    System.out.println(linkedList.get(2));
}

getFirst()

源码分析：

返回此列表的第一个元素

public E getFirst() {
    //获取链表的头节点
    final Node<E> f = first;
    //如果头节点为null
    if (f == null)
        //抛出NoSuchElementException异常
        throw new NoSuchElementException();
    //返回头节点的数据
    return f.item;
}
案例：
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.add(1,"王五");
    linkedList.addFirst("赵六");      
    linkedList.addLast("唐七");
    System.out.println(linkedList);
    //获取此列表的第一个节点
    System.out.println(linkedList.getFirst());

}

remove()

源码分析：

获取并移除此里列表的头（第一个元素）

public E remove() {
    //调用移除第一个元素方法
    return removeFirst();
}
public E removeFirst() {
    // 获取链表的头节点
    final Node<E> f = first;
    // 如果头节点为空，
    if (f == null)
        //抛出NoSuchElementException异常
        throw new NoSuchElementException();
    // 返回调用调用unlinkFirst方法删除头节点并返回删除的元素
    return unlinkFirst(f);
}
 private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
     // 获取头节点的元素
    final E element = f.item;
     // 获取头节点的下一个节点
    final Node<E> next = f.next;
     // 将头节点的元素置为空
    f.item = null;
     // 将头节点的下一个节点置为空，以便垃圾回收
    f.next = null; // help GC
     // 将链表的头节点指向原头节点的下一个节点
    first = next;
     // 如果原头节点的下一个节点为空
    if (next == null)
        //将链表的尾节点也置为空
        last = null;
    else
        // 否则将原头节点的下一个节点的前一个节点置为空
        next.prev = null;
     // 链表的大小减1
    size--;
     // 修改计数器加1
    modCount++;
     // 返回删除的元素
    return element; 
}
案例：
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.add(1,"王五");
    linkedList.addFirst("赵六");
    linkedList.addLast("唐七");
    
    //获取并移除此列表的第一个节点
    System.out.println(linkedList.remove());
    //输出此列表的全部数据
    System.out.println(linkedList);
}

remove(int index)

源码分析：

移除指定列表中的指定位置的元素

//删除指定位置的节点
public E remove(int index) {
    // 检查索引是否越界
    checkElementIndex(index);
    // 删除并返回指定位置的节点
    return unlink(node(index));
}
// 检查索引是否越界
private void checkElementIndex(int index) {
    // 如果索引越界
    if (!isElementIndex(index))
        //则抛出IndexOutOfBoundsException异常
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
// 删除指定节点
E unlink(Node<E> x) {
    // 获取节点的值	
    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;
}

// 获取指定位置的节点
Node<E> node(int index) {
    
	// 如果索引小于链表大小的一半
    if (index < (size >> 1)) {
         // 从头节点开始遍历
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            // 遍历到指定位置
            x = x.next;
        // 返回指定位置的节点
        return x;
   // 如果索引大于等于链表大小的一半
    } else {
        // 从尾节点开始遍历
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            // 遍历到指定位置
            x = x.prev;
        // 返回指定位置的节点
        return x;
    }
}
案例：
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.add(1,"王五");
    linkedList.addFirst("赵六");
    linkedList.addLast("唐七");

    //移除此列表的指定位置的节点
    System.out.println(linkedList.remove(1));
    //输出此列表的全部数据
    System.out.println(linkedList);
}

removeFirst()

源码分析：

移除并返回列表的第一个元素

// 删除链表的头节点
public E removeFirst() {
    // 获取头节点
    final Node<E> f = first;
    // 如果头节点为空，
    if (f == null)
        //抛出NoSuchElementException异常
        throw new NoSuchElementException();
    // 否则，调用unlinkFirst方法删除头节点
    return unlinkFirst(f);
}
 private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
     // 获取头节点的元素
    final E element = f.item;
     // 获取头节点的下一个节点
    final Node<E> next = f.next;
     // 将头节点的元素置为空
    f.item = null;
     // 将头节点的下一个节点置为空，以便垃圾回收
    f.next = null; // help GC
     // 将链表的头节点指向原头节点的下一个节点
    first = next;
     // 如果原头节点的下一个节点为空
    if (next == null)
        //将链表的尾节点也置为空
        last = null;
    else
        // 否则将原头节点的下一个节点的前一个节点置为空
        next.prev = null;
     // 链表的大小减1
    size--;
     // 修改计数器加1
    modCount++;
     // 返回删除的元素
    return element; 
}
案例：
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.add(1,"王五");
    linkedList.addFirst("赵六");
    linkedList.addLast("唐七");

    //移除并返回列表的第一个元素
    System.out.println(linkedList.removeFirst());
    //输出此列表的全部数据
    System.out.println(linkedList);
}

removelast()

源码分析：

移除并返回此列表最后一个元素

// 从链表的尾部删除一个节点
public E removeLast() {
    // 获取尾节点
    final Node<E> l = last;
    // 如果尾节点为空
    if (l == null)
        //抛出NoSuchElementException异常
        throw new NoSuchElementException();
    // 调用unlinkLast方法删除尾节点
    return unlinkLast(l);
}
// 删除链表中的一个节点
private E unlinkLast(Node<E> l) {
    // assert l == last && l != null;
    // 获取节点的数据
    final E element = l.item;
    // 获取节点的前一个节点
    final Node<E> prev = l.prev;
    // 将节点的数据置为空
    l.item = null;
    // 将节点的前一个节点置为空	
    l.prev = null; // help GC
    // 将尾节点指向前一个节点
    last = prev;
    // 如果前一个节点为空
    if (prev == null)
        // 将头节点置为空
        first = null;
    else
        // 将前一个节点的指针置为空
        prev.next = null;
    // 链表大小减1
    size--;
    // 修改计数器加1
    modCount++;
    // 返回被删除节点的数据
    return element;
}
案例：
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.add(1,"王五");
    linkedList.addFirst("赵六");
    linkedList.addLast("唐七");

    //移除并返回列表的最后一个元素
    System.out.println(linkedList.removeLast());
    //输出此列表的全部数据
    System.out.println(linkedList);
}

set(int index,E element)

源码分析：

将此列表中指定位置的元素替换为指定的元素

public E set(int index, E element) {
    //检查索引是否越界
    checkElementIndex(index);
    // 获取指定索引的节点
    Node<E> x = node(index);
    // 获取原节点的值
    E oldVal = x.item;
    // 将指定索引的节点的值设置为新值
    x.item = element;
    // 返回原节点的值
    return oldVal;
}
 private void checkElementIndex(int index) {
     // 如果索引越界
    if (!isElementIndex(index))
        //抛出IndexOutOfBoundsException异常
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
    Node<E> node(int index) {
        // assert isElementIndex(index);
		// 如果指定索引小于链表长度的一半，则从头节点开始遍历
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
            // 如果索引大于等于链表长度的一半，则从尾节点开始遍历
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }
案例：
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.addFirst("赵六");
    linkedList.addLast("唐七");
    System.out.println("原数据："+linkedList);

    //指定位置的值替换为指定的元素
    linkedList.set(2,"小明");
    System.out.println("修改后的数据："+linkedList);
}

size（）

源码分析：

返回此列表的元素个数

public int size() {
    //返回链表的长度
    return size;
}
案例：
public static void main(String[] args) {
    LinkedList linkedList = new LinkedList();
    linkedList.add("张三");
    linkedList.add("李四");
    linkedList.addFirst("赵六");
    linkedList.addLast("唐七");

    System.out.println(linkedList.size());
}

线程安全

LinkedList不是线程安全的，如果需要在多线程环境下使用LinkedList，需要使用Collections.synchronizedList方法将其包装成线程安全的List

List<String> linkedList = new LinkedList<>();
List<String> synchronizedList = Collections.synchronizedList(linkedList);

观众老爷看完觉得不错点个赞
在这里插入图片描述

陆卿之
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LinkedList集合
LYHLL_hh的博客
11-09 430
一、LinkedList集合 java.util.LinkedList集合是java.util.List的实现类，实现List接口的所有方法(添加，删除，查找，判断是空等) ，它添加，删除元素较快，查询相对慢，但是查询头尾元素较快 LinkedList集合实现双向链表接口，实现从头元素到尾元素的链表和从尾到头元素的链表，目标为了增加元素的检索效率 ，如下图 关于LinkedList实现大量操作头元素和尾元素的方法。 其中必须通过LinkedList的引用创建该对象 public void addFirst
集合-LinkedList集合
qq_42247084的博客
01-31 413
LinkedList内部定义了一个Node节点，它包含3个部分：元素内容item，前引用prev和后引用next。2.解决：JUC（Java->util->concurrent包下）问题原因：多线程下，后序线程覆盖前序线程，指针数据丢失。1/线程安全问题出现模块：增加元素。多线程下，使用CAS原理。
java集合-LinkedList源码详解
qq_52616972的博客
09-15 643
LinkedList是一种屋里存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点组成，结点可以在运行时动态生成，LinkedList中有两个指针，前指针和后指针，是一个双向链表； 链表的增删由于不需要移动底层数组数据，其底层是链表实现的，只需要修改链表节点指针，所以效率较高。
Java集合 - LinkedList
qq_49425091的博客
04-01 701
Java集合 - LinkedList
java集合-LinkedList的使用
06-14
基于双向链表实现的列表，支持在任意位置的插入和删除操作。
java集合 collection-list-LinkedList详解
08-31
总之，`LinkedList`是Java集合框架中一个重要的列表实现，适用于需要高效执行链式操作的场景。理解其工作原理和特性对于优化Java程序的性能至关重要。在实际编程中，开发者应根据具体需求选择合适的集合类型。
Java集合--LinkedList
Snail_Dawn's blog
09-07 654
1、从源码分析LinkedList 2、Java语法糖之内部类 3、LinkedList的序列化与反序列化 4、ArrayList与LinkedList的区别和选择
集合 - LinkedList自定义类实现以及LinkedList自定义迭代器（Iterator）实现
Fly_Fly_Zhang的博客
02-22 717
Iterator迭代器实现原理参照此篇博客请点击 package collection; import java.util.Iterator; /** * @Created with IntelliJ IDEA * @Description: * @Package: collection * @author: FLy-Fly-Zhang * @Date: 2019/2/20 * @Ti...
集合------LinkedList
s179042358的博客
10-02 163
1、概述 双向链表结构，增删快，查找慢 不同步，线程不安全 可以被当作堆栈、队列或双端队列进行操作 创建： LinkedList<> data = new LinkedList<>(); 注：最好自己试一遍 2、构造方法 1、LinkedList（） 构造一个空列表， 2、LinkedList（Collection <？extends E> C） 按照集合的迭代器返回的顺序构造一个包含指定集合元素的列表 3、方法 1、add 方法 1、add(int index，E e
数据结构之LRUCache
我要学编程的博客
08-22 1130
LRU Cache 的概念、模拟实现、相关练习
数据结构-时间、空间复杂度-详解
2401_86587256的博客
08-23 1210
数据结构-时间、空间复杂度-详解
排序------快速排序（C语言实现）
markingyi的博客
08-25 863
讲解快速排序原理，并通过例题使用C语言实现。
八股总结-----C++、数据结构、算法
m0_48022770的博客
08-25 359
存储可执行代码（程序指令）。：存储全局变量和静态变量（已初始化和未初始化）。：用于动态内存分配，由程序员管理。：存储函数调用中的局部数据（局部变量、参数、返回地址）。
Linux 数据结构 链表
最新发布
mxyzhy的博客
08-28 250
单向链表操作
【初阶数据结构】顺序表和链表算法题（上）
2301_81072404的博客
08-22 745
数据结构与算法—顺序表链表篇
数据结构之AVL树的 “奥秘“
robin_suli的博客
08-23 825
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索在二叉搜索树树平均查找长度是结点的深度的函数，即结点越深，则比较次数越多。如果需要 一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修 改，就不太适合。如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺 序表中搜索元素，效率低下。保证每个结点的左右子树高度之差的绝对值不超过 1。情况一：subLR平衡因子等于-1。情况二：subLR平衡因子等于1。subLR的平衡因子区分情况。
【每日一题 | 数据结构 | 树的转换与遍历】
程序员小火龙的知识分享
08-24 477
记住一个口诀：“左孩子，右兄弟”，如图所示节点的左指针指向第一个孩子，右指针指向其的兄弟（如果有多个兄弟依次串联）逻辑分析一下：森林中叶子结点是没有孩子的，用左孩子右兄弟方法来转化，转化为二叉树里面就没有左孩子了，类似：将每一棵树的根节点看作兄弟结点，然后通过**”左孩子，右兄弟“**的口诀进行转换。【2014统考真题】将森林F转换为对应的二叉树T，F中叶节点的个数等于（）所有概念性题目，没有给出具体树的，都用枚举树发（化抽象为具体）的方法来做。对于森林的处理，一般会将森林转换为二叉树存储，与。
【JAVA】后端开发中的数据结构：基础知识与应用场景
一个不断前行的程序者
08-25 981
*数据结构是后端开发中的基础和核心。**通过了解数据结构的基本概念、常见类型以及在日常开发中的应用场景，我们可以更好地运用数据结构来提高程序的性能和可维护性。在后端开发中，掌握数据结构对于提升个人技能和职业发展具有重要意义。在实际工作中，我们应该根据具体需求和场景选择合适的数据结构，以实现高效、稳定的系统设计。
|-集合 |-Collection接口，对象集合 |-List接口 |-ArrayList |-LinkedList |-Vector |-Stack |-Set接口 |-HashSet |-TreeSet |-Queue接口 |-Map接口，键值对集合 |-HashMap |-Hashtable |-Properties
02-06
ArrayList、LinkedList、Vector、Stack都是实现了List接口的类，它们都是有序的集合，可以使用下标访问元素。其中，ArrayList是实现了动态数组的列表，LinkedList是由链表实现的列表，Vector是线程安全的列表，Stack...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

陆卿之

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

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

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

打赏作者

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

抵扣说明：

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

余额充值