九章算法6:Linked List

九章算法6:Linked List

内容基于九章算法课件
（http://www.jiuzhang.com/）

链表的结构

如果我进行两个操作:

  1.node1 = node2;
  2.print head

具体代码

结果仍是

            1 2 3

因为node1只是一个地址信息,如果把内存比作一个大数组, 这个node1
只是这个数组的index. node1 = node2是地址赋值, 赋值完成之后就变成这样:

如果想要从第二个开始输出的话, 可以:

  head = node2;

如果想要影响链表的结构的话,可以:

  node1.next = node2.next;

之后链表就变成了:

java里面node2就自动删除了, C++里分版本, 具体老师木有说, 我也不造…

debug

两种方法:

 1.一步步带入, 人脑模拟电脑运行...
 2.关键点print

Remove Duplicates from Sorted List II

Given a sorted linked list, delete all nodes that have duplicate numbers, leaving only distinct numbers from the original list.

Given 1->2->3->3->4->4->5, return 1->2->5.
Given 1->1->1->2->3, return 2->3.
核心问题是:
prev-> cur-> next 这个链表操作中, 涉及到前一个, 当前和后一个:

   prev.next = cur.next

如果删除的是第一个怎么班呢, 比较方便和通用的是添加一个dummy node:

       1. new一个dummy node;
       2. dummy.next = head;
       3. return dummy.next

Reverse Linked List II

Reverse a linked list from position m to n.

Given 1->2->3->4->5->NULL, m = 2 and n = 4, return 1->4->3->2->5->NULL.
注意事项如下:

1.m可能等于1, 所以要加一个dummy node
2.m-1步找到prevM和M
3.reverse m~n
    temp = cur.next;
    cur.next = prev;
    prev = cur;
    cur = temp;
    右边变左边,最后一个右边是第一个左边.
4.connect

Dummy Node

Used when the head is not determined.
比如说用到 partition和merge

Partition List

Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.

You should preserve the original relative order of the nodes in each of the two partitions.
注意:

1.partition 是先整体有序再局部有序.
2.merge 是先局部有序,再整体有序

Middle of a linked list

Find the middle node of a linked list.

Given 1->2->3, return the node with value 2.
Given 1->2, return the node with value 1.
注意:

 1.两个指针,一根走一步的时候,另一根走两步.
 2.fast和slow错开一个放

Sort list

Sort a linked list in O(n log n) time using constant space complexity.

constant space complexity means: O(1)的时间复杂度
首先, nlogn的排序:

  1.快排, 无额外空间,运用partition的方法
  2.merge sort,O(n)的额外空间,运用归并的思想
  3.heap sort, O(n)的额外空间

这道题可以用quick sort写:

1.之中用<=x和>=x而不是<x和>x
2.奇数的往左扔,偶数个往右扔,以防出现1,2,2,2,2,2,2...这样的

第二条暂时不明白, 估计需要自己写写~

Reorder

Given a singly linked list L: L0 → L1 → … → Ln-1 → Ln
reorder it to: L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …

Given 1->2->3->4->null, reorder it to 1->4->2->3->null.
注意:

 1.找中点
 2.reverse后半边
 3.左边取一个,右边取一个

链表环和circleII

快慢指针:
小明和小红,小明一分钟跑两米,小红一分钟跑一米,神马时候扣圈儿相遇…

circleII:相遇后, slow回到头, slow和fast各一次一步,相遇即为环的头.

Merge k Sorted Lists

K路归并算法?

heap

merge的核心是:谁小谁出列.
k个数里面取最小,用堆
这道题用priority queque 本质是heap
一个大小为k的堆,操作用时logk
这道题需要Nlogk, N是所有list 的长度之和

merge sort的分治法

Nlogk没整明白…居然这样…

两两合并

Copy List with Random Pointer:Deep copy

A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.

Return a deep copy of the list.
random pointer可能指向自己,其它,或者空.

简单粗暴的解决办法:

1.new出node1’, node2’ 并连到node1’, node3’并连到node2’…
2.hashMap(key: old 节点) = 新节点
3.random pointer就再for一遍

不简单粗暴的方法

1.原始的节点node1, node2 等变成

 node1.next = node1';
 node1.next.next = node2;

2.if node1.next 连自己, node1’.next也连自己

  node2.next.random = node2.random.next

3.拆开:

      next = next.next

Convert sorted array into balanced tree

Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

1->2->3 =>
2
/\
13

nlogn的树形分析法

challenge: o(n)时间

没整明白…

写结题报告:

1.一句话描述这个题
2.算法是什么?用到了什么数据结构?
3.从这道题能学到什么?
分治,做过merge two, 知道题merge k
4.写程序可能遇到的bug