深入理解ArrayList与LinkedList，源码分析与性能测试

最新推荐文章于 2022-07-22 16:32:13 发布
最新推荐文章于 2022-07-22 16:32:13 发布
阅读量230 收藏 1
点赞数
分类专栏： JavaSE 文章标签： java 链表 数据结构 列表 数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42193813/article/details/107726793
版权

思维导图

剧透：ArrayList的插入操作与查询操作都比LinkedList快很多

ArrayList

特点

  • 底层使用数组实现，查询速度快，增删改速度慢（理论上）
  • 线程不安全

ArrayList常用方法

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * @author 张宝旭
 */
public class ArrayListTest {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(); // 创建ArrayList

        list.add("北京"); // 添加元素
        list.add("上海");
        list.add("杭州");
        list.add("沈阳");
        list.add("东戴河");

        System.out.println(list.toString()); // 打印集合

        System.out.println(list.size()); // 获取集合大小

        System.out.println(list.get(0)); // 获取指定下标的元素

        list.remove(0); // 删除指定下标的元素
        list.remove("上海"); // 删除指定元素

        System.out.println(list.isEmpty()); // 判断集合是否为空

        System.out.println(list.contains("北京")); // 判读集合中是否包含某个元素

        // 迭代遍历集合元素
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();
        // 增强for遍历
        for (String value : list) {
            System.out.print(value + " ");
        }
    }
}

对基本数据类型的操作

当向列表中添加基本数据类型的时候，会自动装箱成包装类型

List<Integer> lit = new ArrayList<>();
lit.add(12);
lit.add(25);
lit.add(99);

而当我们删除其中的指定元素时

lit.remove(12);

因为12是基本数据类型，所以这种删除方式删除的是下标为12的元素

所以需要将此删除语句更改，将12强转为包装类型

lit.remove((Integer)12);

这样就可以正确删除列表中为12的元素了


ArrayList源码分析

底层使用数组保存元素

transient Object[] elementData;

默认容量：10

private static final int DEFAULT_CAPACITY = 10;

ArrayList构造方法

当创建列表时，没有向列表中添加元素时，容量为0

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

add()方法（扩容）

1、当列表中没有元素时，添加一个元素后，容量扩充为10
public boolean add(E e) {
    // 初始时，size为0，所以将1传入
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    // 最开始时，数组为空，所以条件成立
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 令minCapacity = 两者之间最大的数
        // DEFAULT_CAPACITY为默认容量10，minCapacity传入的参数为1
        // 所以minCapacity = 10
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    // 然后调用此方法，传入参数为10
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    // 修改的次数，加一
    modCount++;

    // overflow-conscious code
    // 最开始数组长度为0，所以 10-0 > 0 成立
    if (minCapacity - elementData.length > 0)
        // 调用此方法
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    // 原来的数组长度为0
    int oldCapacity = elementData.length;
    // 新的数组长度 = 原来的长度 + （原来的长度除2） = 0 + 0/2 = 0
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 0 - 10 < 0 成立
    if (newCapacity - minCapacity < 0)
        // 所以新数组长度赋值 = 10
        newCapacity = minCapacity;
    // 10 - 一个很大的数 > 0 不成立，所以不会执行
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    // 然后调用此方法进行数组复制
    // 将原来的数组，给新的长度10，还复制到这个数组中，实现了数组扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

所以，到这里就实现了最开始添加一个元素时，数组扩容为10的操作

然后再接着执行add()方法剩下的操作，将值添加到数组中，size大小加一

再次梳理一遍流程

  • 首先调用add()方法
  • 然后调用ensureCapacityInternal()方法，判断列表中元素是否为空，如果为空，则进行赋值扩容参数为10
  • 然后调用ensureExplicitCapacity()方法，判断最小的容量是否大于数组的长度。如果不大于，则无需扩容，如果大于，则进行扩容，调用grow(minCapacity)方法
  • 然后调用的grow(minCapacity)方法，给出扩容的长度，然后用数组复制的方法进行扩容
  • 最后接着执行add()方法，将值添加到数组中，size大小加一

2、当列表中有元素时，但是没有超过数组容量的大小时，向列表中添加元素

（假如此时集合中有一个元素，size=1, 数组长度为10）

// 首先调用add方法，进行添加
public boolean add(E e) {
    // 判断是否需要扩容，传入参数为2
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    // 数组不为空，所以条件不成立
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    // 那么直接调用此方法
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    // 修改次数加一
    modCount++;

    // overflow-conscious code
    // 2 - 10 > 0，条件不成立，不向下执行
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

最后接着执行add()方法

// 将size的位置添加新的元素e，然后长度size加一
elementData[size++] = e;

3、当列表中有元素，而且长度已经满了，需要进行第二次扩容的时候

（假如当前数组大小size = 10）

// 先调用add()方法进行添加
public boolean add(E e) {
    // 进行扩容，传入参数为11
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    // 数组不为空，所以条件不成立
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    // 直接调用此方法，传入参数为11
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    // 修改次数加一
    modCount++;

    // overflow-conscious code
    // 11 - 10 > 0，条件成立，调用grow方法
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    // 原来数组长度 = 10
    int oldCapacity = elementData.length;
    // 新数组长度 = 10 + (10 / 2) = 15
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    // 15 - 11 < 0 条件不成立
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    // 15 - 很大的数 > 0 条件不成立
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    // 所以直接执行此方法，将原数组复制，还复制到原数组中（相当于覆盖）
    // 复制长度为15，这样就实现了数组扩容
    elementData = Arrays.copyOf(elementData, newCapacity);
}

最后接着执行add()方法，将元素添加到后面，然后size加一

由此代码可知

int newCapacity = oldCapacity + (oldCapacity >> 1);

在除第一次添加元素的时候进行扩容，每次扩容大小是原来的1.5倍（向右移一位就是除2）


remove()方法

假如有10个元素，要删除下标为3的元素

public boolean remove(Object o) {
    // 先判断传入的对象是否为null
    if (o == null) {
        // 如果为null，就再遍历数组，查找有没有值为null的元素
        for (int index = 0; index < size; index++)
            // 当找到值为null的元素时，就进行快速删除，然后返回true，表示删除成功
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        // 如果传入的对象不是null，也进行遍历
        for (int index = 0; index < size; index++)
            // 在数组中找到和此对象相匹配的
            if (o.equals(elementData[index])) {
                // 然后使用快速删除方法，删除找到的下标为index的元素
                fastRemove(index);
                return true;
            }
    }
    return false;
}

private void fastRemove(int index) {
    // 修改次数加一
    modCount++;
    // 元素需要移动的次数 10 - 3 - 1 = 6
    // 0 1 2 3 4 5 6 7 8 9
    // 因为3位置的后面有6个元素，删除之后，这6个元素都要向前移动一位
    int numMoved = size - index - 1;
    // 如果需要移动元素的时候
    if (numMoved > 0)
        // 使用数组复制的方法，从index+1的位置开始，将后面的元素向前移动一位（也就是向前覆盖）
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 移动之后，需要将最后一个元素的值清空，然后将size减一，则完成删除操作
    elementData[--size] = null; // clear to let GC do its work
}

LinkedList

特点

  • 底层使用链表方式实现，插入删除速度快（理论上），查询速度快
  • 可以用LinkedList来实现栈、队列等数据结构

LinkedList常用方法

import java.util.*;

/**
 * @author 张宝旭
 */
public class LinkedListTest {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("I"); // 添加元素
        linkedList.add("Love");
        linkedList.add("You");
        linkedList.add("Very");

        linkedList.remove("Very"); // 删除指定元素

        linkedList.size(); // 获取列表长度

        linkedList.get(0); // 获取指定下标的元素

        linkedList.contains("Love"); // 判断是否包含指定元素

        linkedList.indexOf("I"); // 获取指定元素的下标

        linkedList.set(1, "love"); // 修改指定下标的元素

        // 将列表转换成数组
        String[] strings = linkedList.toArray(new String[0]);
        System.out.println(Arrays.toString(strings));

        // for循环遍历
        for(int i = 0; i < linkedList.size(); i++) {
            System.out.print(linkedList.get(i) + " ");
        }
        System.out.println();

        // 增强for遍历
        for (String s : linkedList) {
            System.out.print(s + " ");
        }
        System.out.println();

        // 迭代器遍历
        Iterator<String> iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
        System.out.println();

        // 列表迭代器遍历 (反向遍历)
        ListIterator<String> listIterator = linkedList.listIterator(linkedList.size());
        while (listIterator.hasPrevious()) {
            System.out.print(listIterator.previousIndex() + " : " + listIterator.previous() + " ");
        }
    }
}

LinkedList源码分析

基本属性

构造方法

public LinkedList() {
}

链表长度

transient int size = 0;

头指针

transient Node<E> first;

尾指针

transient Node<E> last;

add()方法

public boolean add(E e) {
    linkLast(e);
    return true;
}

void linkLast(E e) {
    // 创建一个临时的指针，指向last，也就是l就是最后一个结点
    final Node<E> l = last;
    // 创建一个结点，前驱指针指向l，元素为e，后继结点指向null
    final Node<E> newNode = new Node<>(l, e, null);
    // 令last指针指向新结点
    last = newNode;
    // 当l为空时，说明链表为空，直接添加，令头指针指向新结点
    // 此时只有一个结点，last指向它，first也指向它
    if (l == null)
        first = newNode;
    else
        // 当l不为空时，说明链表中有元素，所以将l的后继指针指向新结点
        // 此时就完成了双向链表的连接（第二部完成了前驱指针指向l）
        l.next = newNode;
    size++;
    modCount++;
}

remove()方法

public boolean remove(Object o) {
    // 先判断要删除的元素是否是null
    if (o == null) {
        // 如果是，就遍历链表，查找结点值为null的结点
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                // 找到之后调用此方法删除元素
                unlink(x);
                return true;
            }
        }
    } else {
        // 如果要删除的元素不是null，也遍历链表，查找此元素
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                // 找到之后调用此方法删除元素
                unlink(x);
                return true;
            }
        }
    }
    return false;
}

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; // 返回删除的元素
}

测试ArrayList和LinkedList的性能

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * 测试ArrayList和LinkedList的性能。
 *
 * @author 张宝旭
 */
public class PerformanceTest {
    // 一百万次
    static final int QUERY_COUNT = 10000000;
    static List<String> arrayList = new ArrayList<>();
    static List<String> linkedList = new LinkedList<>();
    public static void main(String[] args) {
        // 插入
        PerformanceTest.arrayListInsert();
        PerformanceTest.linkedListInsert();
        // 查询
        PerformanceTest.arrayListQuery();
        PerformanceTest.linkedListQuery();
    }

    /**
     * 测试ArrayList插入性能
     */
    public static void arrayListInsert() {
        long startTime = System.currentTimeMillis();
        for(int i = 0; i < QUERY_COUNT; i++) {
            arrayList.add(String.valueOf(i));
        }
        long endTime = System.currentTimeMillis();
        System.out.println("ArrayList插入消耗时间: " + (endTime - startTime));
    }

    /**
     * 测试LinkedList插入性能
     */
    public static void linkedListInsert() {
        long startTime = System.currentTimeMillis();
        for(int i = 0; i < QUERY_COUNT; i++) {
            linkedList.add(String.valueOf(i));
        }
        long endTime = System.currentTimeMillis();
        System.out.println("LinkedList插入消耗时间: " + (endTime - startTime));
    }

    /**
     * 测试ArrayList查询性能
     */
    public static void arrayListQuery() {
        long startTime = System.currentTimeMillis();
        for(int i = 0; i < QUERY_COUNT; i++) {
            arrayList.get(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("ArrayList查询消耗时间: " + (endTime - startTime));
    }

    /**
     * 测试LinkedList性能
     */
    public static void linkedListQuery() {
        long startTime = System.currentTimeMillis();
        for(int i = 0; i < QUERY_COUNT; i++) {
            linkedList.get(i);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("LinkedList查询消耗时间: " + (endTime - startTime));
    }
}

结果

ArrayList插入消耗时间: 96
LinkedList插入消耗时间: 1684
ArrayList查询消耗时间: 8
LinkedList查询消耗时间: 很久，没有执行完

结论

虽然ArrayList底层是数组，LinkedList的底层是链表，但是ArrayList的插入操作，确实要比LinkedList的插入操作效率更高

因为ArrayList底层使用了 elementData = Arrays.copyOf(elementData, newCapacity); 这是一个native方法，所以效率比较高

public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

当修改执行次数的时候，之前测试是一百万次，现在修改为10000次

ArrayList插入消耗时间: 3
LinkedList插入消耗时间: 2
ArrayList查询消耗时间: 1
LinkedList查询消耗时间: 48

可以看到，当执行次数小的时候，两者的插入操作差别并不明显，但是查询操作，还是ArrayList更快

当执行次数大的时候，ArrayList的插入效率要高于LinkedList

总结

ArrayList底层使用数组实现，LinkedList底层使用链表实现

ArrayList的查询操作比LinkedList的查询操作快

理论上：ArrayList的插入操作比LinkedList的插入操作慢

实际上：ArrayList的插入操作比LinkedList的插入操作快

因为ArrayList底层使用了 elementData = Arrays.copyOf(elementData, newCapacity); 这是一个native方法，所以效率比较高

她的坏机器人
关注
专栏目录
阿里巴巴java性能调优实战：ArrayList还是LinkedList？使用不当性能差千倍
m0_58336848的博客
06-03 173
ArrayList还是LinkedList？使用不当性能差千倍 集合作为一种存储数据的容器，是我们日常开发中使用最频繁的对象类型之一。JDK 为开 发者提供了一系列的集合类型，这些集合类型使用不同的数据结构来实现。因此，不同的集 合类型，使用场景也不同。 很多同学在面试的时候，经常会被问到集合的相关问题，比较常见的有 ArrayList 和 LinkedList 的区别。 相信大部分同学都能回答上：“ArrayList 是基于数组实现，LinkedList 是基于链表实 现。” ...
ArrayList和LinkedList（源码分析）
qq_45369827的博客
03-25 425
底层数据结构的区别 实现的接口的差别 初始化时的容量 get方法根据下标随机访问的区别 两者的扩容 两者删除元素效率的对比 线程安全问题 总结 ArrayList 底层是数组，而 LinkedList 底层是双向链表。 ArrayList 实现了随机访问接口 RandomAccess，允许用下标随机访问。LinkedList 需要从头结点或者尾结点遍历。所以在用下标访问的性能上ArrayList 胜出。 ArrayList 的数据结构是数组，也就是顺序表，在删除元素的时候需要前移后面的元素，性能差于L.
深入浅析ArrayList 和 LinkedList的执行效率比较
08-29
主要介绍了ArrayList 和 LinkedList的执行效率比较的相关资料,需要的朋友可以参考下
java中ArrayList与LinkedList性能测试
ylb125的专栏
07-17 771
package 数组与线性表性能测试; import java.util.ArrayList; import java.util.LinkedList; import java.util.Random; public class Test { final static int count=1000000; public static void test1() {
深入理解ArrayList 和 LinkedList 区别
山月风成的博客
11-29 2328
ArrayList 和 LinkedList 的不同点，ArrayList是基于数组，LinkedList 是基于链表，这是基本概念，我们还需要深入理解。
深入理解java中的ArrayList和LinkedList
QLH的博客
04-19 496
ArrayList和LinkedList的区别 ArrayList和LinkedList是顺序存储结构和链式存储结构的表在java语言中的实现. ArrayList提供了一种可增长数组的实现,使用ArrayList,因为内部使用数组实现,所以,它的优点是,对于get和set操作调用花费常数时间.缺点是插入元素和删除元素会付出昂贵的代价.因为这个操作会导致后面的元素都要发生变动,除非操作发生在集合的...
深入理解ArrayList和LinkedList!
断掉的手环
10-23 162
深入理解ArrayList和LinkedList ArrayList和LinkedList都是实现了List接口 1 ArrayList底层是由数组来实现的 优点：基于动态的数组实现，有确定的下标，读和改更加容易，存放元素可以重复，也可以为null，有序 缺点：不适合对元素进行频繁的插入和删除，插入和删除都需要做大量的元素移动 特点：集合中默认创建为一个大小为10的数组，执行add方法时，会首先执行ensureCapacity()方法，当元素数量正好为数组大小时，会创建一个新的数组，数组大小为原来数组的1.
【Java集合框架深入剖析】：LinkedList源码与性能分析
[【Java集合框架深入剖析】：LinkedList源码与性能分析](https://img-blog.csdnimg.cn/20181206213142429.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV...
毕业设计源码之ArrayList，LinkList链表接口实现.zip
最新发布
09-19
1. **集合框架理解**：深入理解Java集合框架，包括List接口、Set接口和Map接口，以及它们的实现类如ArrayList、LinkedList、HashSet、HashMap等。 2. **ArrayList与LinkedList的区别**：对比分析ArrayList和...
第17章 - 深入研究容器 - Collection(List,Set,Queue)的性能测试框架(单线程中)(P501)
08-04
为了更好地理解源码，可以查阅Java集合框架的开放源代码，如ArrayList、HashSet和LinkedList的实现。这有助于了解它们在底层如何工作，以及为何在特定场景下性能有所不同。同时，了解这些类的并发性和线程安全性也是...
ArrayList 和 LinkedList 源码解析
男儿不展风云志，空有天生八尺躯
06-16 160
LinkedList private static class Node<E> { E item; Node<E> next; Node<E> prev; Node(Node<E> prev, E element, Node<E> next) { this.item = element; this.next = next;
Arraylist和linkedlist的性能测试
weibin_6388的专栏
04-06 662
1，通过源码角度分析Arraylist和 linkedlist的性能如下：   Add() Remove(int i) Set(int i, E e) Get(int i) Arraylist O(1)-O(N) O(N) O(1) O(1) Linkedlist
ArrayList和LinkedList性能对比测试
编程技术分享，Java后端、Vue前端
11-04 377
package com.test.api; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; public class TestList { /** * @author Administrator * @date 2016-11-3下午11:49:12 * @功能: L
基于JMH对ArrayList和LinkedList插入操作进行性能测试
努力推石头的西西弗斯
07-22 254
基于JMH对ArrayList和LinkedList插入操作进行性能测试
ArrayList 和 LinkedList测试
木卯的专栏
03-25 319
ArrayList 和 LinkedList测试 1.ArrayList 和 LinkedList 新增元素操作测试 测试结果 (花费时间)： 通过这组测试，我们可以知道 LinkedList 添加元素的效率未必要高于 ArrayList。 从集合头部位置新增元素 从集合中间位置新增元素 从集合尾部位置新增元素 ArrayList>LinkedList ArrayList<LinkedList ArrayList<LinkedList 由于 ArrayList 是数组实现的，而数组是一块连
LinkedList与ArrayList性能分析和适用场景
ZDLW5的博客
07-17 334
目录LinkedList与ArrayList性能分析对比在索引中间位置同时进行删除、插入操作性能测试集合size为100时集合size为1000时在索引头尾进行删除、插入操作性能测试集合size为1000时 LinkedList与ArrayList性能分析对比 网上的信息比较驳杂，所以自己写测试测一测 在索引中间位置同时进行删除、插入操作性能测试 集合size为100时 @Test void test23() { ArrayList<Double> list = new ArrayList
ArrayList和LinkedList区别及性能测试
weixin_34113237的博客
10-19 178
　　ArrayList和LinkedList是JavaLis接口的2个实现。它们的区别如下表所示： 底层结构 强项 弱项 ArrayList 数组 随机访问get和set 插入删除 LinkedList 链表 插入删除 随机访问get和set ...
[剑指offer][JAVA][第62题][约瑟夫环][LinkedList vs ArrayList]
dadongwudi的博客
03-31 219
【问题描述】 面试题62. 圆圈中最后剩下的数字 0,1,,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字。求出这个圆圈里剩下的最后一个数字。 例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。   示例 1： 输入: n = 5, m = 3 输出:&nbsp...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值