算法思路整理-链表

1. 1. 链表

     a. 常用工具函数

         i. Collection.sort(list, new comparator())

     b. 单链表的选择排序

         i. 方法1，递归

            1. 1. 找到最小的，为头，头的next等于对剩余链表排序，返回头

            2. 2. 时间复杂度 n^2

         ii. 方法2，借助数组

            1. 1. ListNode放到数组里

            2. 2. Array.sort()

            3. 3. 将ListNode串联取来

            4. 4. 时间复杂度nlog(n),空间复杂度n

     c. 反转链表

         i. 方法1递归，

            1. 1. 当前链表的尾就头，尾之前的节点的next置空

            2. 2. 返回tail.next=递归剩余链表

            3. 3. 时间复杂度n^2

         ii. 方法2 

            1. 1. 找到当前尾为头，倒数第二个节点next置空

            2. 2. 从头开始遍历，往当前的新头上追加

            3. 3. 时间复杂度为n

     d. 链表指定区间反转

         i. 找到要翻转的区域之前的节点，之后的节点，以及反转区域的头尾

         ii. 此时尾为新的头，从头开始往尾遍历，不断往新的头后面追加

         iii. 时间复杂度n

     e. 判断链表中是否有环

         i. 步长1，步长2，分别遍历链表

         ii. 如果没结束，或者重叠，则有环

         iii. 复杂度n

     f. 链表中环的入口

         i. 先判断是否有环，如果没有环，返回null

         ii. 停在重叠的点，然后从头和重叠点一起走，返回再次相碰的点

         iii. 复杂度n

     g. 数组链表，区间合并

         i. 根据数组头元素的大小排序

         ii. 遍历列表，如果相邻的两个存在重叠，合并，注意尾部是两个尾部的最大值

         iii. 复杂度nlog(n)

     h. 合并K个已经排序的链表

         i. 如果链表个数奇数，加入空链表

         ii. 合并成一个新的list

         iii. 继续合并，如果链表中个数为1，返回

     i. 数组中的逆序数

     j. 删除有序链表中重复的元素并保留一个

         i. 从头遍历，如果下一个等于他自己，删除下一个

         ii. 如果下一个不等于他自己，往后走一个，直到null

         iii. 时间复杂度n

     k. 删除有序链表中重复出现的元素

         i. 从头遍历，找到第一个不重复的元素

         ii. 从第一个不重复的元素开始，如果当前下一个等于下下一个，继续往后遍历，直到不等于，全部删除

         iii. 时间复杂度n

     l. 判断一个链表是否是回文结构

         i. 求链表长度

         ii. 栈n/2, 考虑奇数偶数情形

         iii. 时间复杂度n, 空间复杂度n/2

     m. 重排链表

         i.

题目

         ii. 递归

         iii. 找到倒数第二个节点

         iv. 倒数第一个节点跟到头的后面，倒数第二个节点next置空

         v. 当前位是倒数第一个节点，倒数第一个节点.next=递归剩余list

         vi. 时间复杂度n^2

     n. 链表的奇数偶数位置重新排列，原来奇数位置的放到前面

         i. 从左到右遍历，找第一个下一个是偶数的节点n1,第一个偶数节点就是n2

         ii. 从n2开始循环往后遍历，找下一个是奇数的节点n3

         iii. N1.next=n3.next; n3.next=n3.next.next; n1=n1.next; 

         iv. 继续从n3开始遍历直到null，n1.next=n2

         v. 时间复杂度n

     o. 划分链表，给一个数，大于这个数的节点都在链表前部

         i. 找到第一个下一个大于等于k的节点n1为前半部分的队尾，下一个节点n2为后半部分的队首

         ii. 遍历后半部分，如果value小于K, 跟到前半部分的队尾，直到null

         iii. 前半部分的队尾.next=n2

         iv. 时间复杂度n

     p. 环形链表的约瑟夫问题

         i. 构建环形链表，尾部指向头

         ii. 循环删除编号为k的节点，直到只剩一个节点，返回节点val

         iii. 时间复杂度为kn, 空间复杂度为n

     q. 合并有序链表

         i. 如果一个为空，返回另一个

         ii. 递归，比较两个链表的头，小的是头，然后头.next=合并剩余列表,返回头

         iii. 时间复杂度n+m;

     r. 删除链表的倒数第n个节点

         i. 双指针，考虑临界点的情形，比如头尾

         ii. 位置落在要删除节点前的一个位置上

         iii. 复杂度n

     s. 链表中倒数第k个节点

         i. 双指针，一个先走k步，另一个开始一起走

         ii. 第一个走到尾部，停住，第二个指针指向的就是要求的

         iii. 时间复杂度n

     t. 链表中的节点每K个一组反转，剩余不满K的保持原样

         i. 递归，截取前K个，反转前K个，tail.next=反转剩余的

         ii. 前k个也通过递归方式进行反转

         iii. 时间复杂度n^2

     u. 两个链表生成相加链表

         i. 压栈，构建进位C

         ii. 当有栈空了之后，非空栈和进位C一起计算

         iii. 最后检查一下C是否>0

         iv. 时间复杂度max(N,M)，空间复杂度N+M

     v. 两个链表的第一个公共节点

         i. 先分别遍历到尾

         ii. 计算长度，长的链表先开始遍历l1-l2步，然后大家一起开始

         iii. 返回第一个重叠的节点

         iv. 时间复杂度max(N,M)