java之 LinkedList详解

LinkedList （双向链表结构）

• (1)LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。
• (2)LinkedList 实现 List 接口，能对它进行队列操作。
• (3)LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。
• (4)LinkedList 实现了Cloneable接口，即覆盖了函数clone()，能克隆。
• (5)LinkedList 实现java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化去传输。
• (6)LinkedList 是非同步的。

参考自（如有侵权请联系删除）：
(https://blog.csdn.net/qedgbmwyz/article/details/80108618)

https://www.cnblogs.com/LiaHon/p/11107245.html

LinkedList操作
1.添加元素：

• boolean add(Object element) —— 将元素添加在链表的最后
• boolean add(int index, Object element) 【index - 要在其中插入指定元素处的索引；element - 要插入的元素】
• 在列表的指定位置插入指定元素（可选操作）
• boolean addFirst(Object element) —— 将元素添加在链表的第一个元素的位置
• boolean addLast(Object element) —— 将元素添加在链表最后

*2.获取链表的元素

• E get(int index)——获取索引处的元素
• E getFirst()——获取第一个元素
• E getLast()——获取第最后一个元素

3.删除元素

• E remove()——移除链表中第一个元素
• boolean remove(Object o)——移除链表中指定的元素
• E remove(int index)——移除链表中该索引处的元素
• E removeFirst()——移除链表中第一个元素
• E removeLast()——移除链表中最后一个元素
• boolean removeFirstOccurrence(Object o)——移除链表中第一次出现所在位置的元素
• boolean removeLastOccurrence(Object o)——移除链表中最后一次出现所在位置的元素

4.其他操作

• void push(E e)——与add()效果一样
• E pop()——与remove()效果一样
• E set(int index，Object element)———修改指定元素列表位置的元素值
• E poll()——查询并移除第一个元素
• void clear()——清空集合里的所有元素
• Object clone()——复制一个集合
• boolean contains(Object object)——判断集合是否包含指定元素
• indexOf(Object o)——返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
• lastIndexOf(Object o)——返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。

RandomAccess接口（参考文章）【如有侵权，请联系删除】
https://blog.csdn.net/weixin_39148512/article/details/79234817

小节：ArrayList用for循环遍历比iterator迭代器遍历快，LinkedList用iterator迭代器遍历比for循环遍历快

时间复杂度

• Random Access 时间复杂度：O（n）
• addFirst() 时间复杂度：O（1）
• addLast() 时间复杂度：O（1）
• add(Object element) 时间复杂度：O（1）
• removeFirst() 时间复杂度：O（1）
• removeLast() 时间复杂度：O（1）
• remove() 时间复杂度：O（1）
• set(int index，Object element) 时间复杂度：O（n）
• get(int index) 时间复杂度：O（n）

oracle jdk学习文档
https://docs.oracle.com/javase/8/docs/api/java/util/LinkedList.html

题目： 给定一个非负整数，表示为非空，一个单链数字列表，加上一个整数您可以假设整数不包含任何前导零，
但数字0本身除外。存储这些数字时，最有意义的数字位于列表的开头。(LinkedList指针不能往回)
input 1->2->3 output 1->2->4
input 9->9 output 1->0->0
input: 1->9->8->9 output: 1->9->9->0
input: 1->9->0->9 output: 2->0->0->0
示例一； input: 0 output: 1

示例二； input: 99 output: 100
示例三； input: 1989 output: 1990
示例四； input: 1909 output: 2000

package array;
import java.util.Iterator;
import java.util.LinkedList;

public class PlusOneLinkedList {

    private static class ListNode{
        int val;
        ListNode next;
        ListNode(int x){
            val=x;
        }
    }
    
    private static ListNode plusOne(ListNode head){

        ListNode dummy= new ListNode(0);//定义一个dummy节点，用来存储最高位进一数据（最高位不进一则舍去该节点）
        dummy.next=head;//移动到头部
        ListNode i=dummy;//定义i指针,寻找最后一位数字
        ListNode j=dummy;//定义j指针,移动到数字为9的前一位数
        while (j.next!=null){//循环ListNode
            j=j.next;
            if(j.val!=9){//如果j指针不为9，i指针定位到j指针位置处;如果j指针为9，i指针待在j指针前一位
                i=j;
            }
        }
        //最后一位不为9
        if(j.val!=9){//最后一位不为9，j指针执行加一操作
            j.val++;
        }else{
            //最后一位为9
            i.val++; //（j指针指向最后数字9的前一位）i指针执行加一操作
            i=i.next; //后移一位
            while(i!=null){//如果后移一位的位置（数字9的位置）不为空
                i.val=0;//数字赋值为0
                i=i.next;//继续后移，重复循环操作
            }
        }
        //如果头部dummy节点为0（说明最高位不为9）,直接返回dummy节点的下一项
        if(dummy.val==0){
            return dummy.next;
        }
        return dummy;
    }

    public static void main(String[] args) {

        System.out.println(plusOne(new ListNode(109)).val);
      /*  LinkedList linkList=new LinkedList();
        linkList.add(1);
        linkList.add(2);
        linkList.add(3);
        Iterator iter = linkList.iterator();
        while(iter.hasNext()){
            System.out.print(iter.next()+"   ");

        }*/
       /*linkList.add(2,5);
        Iterator iter2 = linkList.iterator();
        while(iter2.hasNext()){
            System.out.print(iter2.next()+"   ");
        }*/
    }
}