3. LinkedList

双向循环列表

1. 区分时候双向,看有没有prev 属性,有就是双向
2. 区分是否循环,看head.pref 是否等于null,等于则不是循环

1. 双向列表的话只是在中间都添加了prev,next.head的prev=null,last的next=null

2. 循环链表是个圈,双向顺换是循环链表中的一种

3. 双向循环列表是将head.prev=last,last.next=head ,变成了一个圈,但是并不会死循环,因为有head的存在,do{node=node.next;}while(node!=head)

LinkListNode

LinkedList list;
LinkedListNode next;
LinkedListNode prev;
T item;

cotr

1. LinkedListNode(T value){item=value;}
2. LinkedListNode(LinkedList list,T value){list=list,item=value;}

prop

1. List{get{return list;}}
2. Next{get{return nextnull||nextlist.head?null:next;}} //这样写我很疑惑
3. Previous{Get{return prevnull||thislist.head?null:prev;}}
4. T Value{get;set;} //return item;

method

1. Invalidate()
{
// clear field
list=null;
next=null;
prev=null;
}

LinkedList内部 664行,中等

理解链表的第一步是它内部不是数组,是组合
如果自己来实现的话,永远要记得head=node的情况
LinkedListNode head; //头结点
int count; //结点数量
int version; //版本

interface

一句话就是ICollection,所以没有索引器
ICollection,ICollection,IreadOnlyCollection...

ctor

public LinkedList(){} //什么也没有
public LinkedList(IEnumerable collection){} //foreach{AddLast(item);}

private ValidateNode(node);

1. 判断node是否为空
2. 判断node.List==this,不等说明篡改了,你可以用反射进行篡改啊

private ValidateNewNode(node)

1. 判断node是否为空
2. 判断node.List=null;

AddFirst(T value)

public LinkedListNode AddFirst(T value){
LinkedListNode result=new LinkedListNode(this,value);
if(head==null){
InternalInsertNodeToEmptyList(result);
}else{
InternalInsertNodeBefore(head,result);
head=result; //将新的node设置为head
}
return result;
}

private void InternalInsertNodeToEmptyList(LinkedListNode result){
Debug.Assert(headnull&&count0,"Linked must be empty when this method is called!"); //在这里使用Debug.Assert() 不错
//一个节点时,node中prev=next
newNode.next=newNode;
newNode.prev=newNode;
head=newNode; //设置头结点
version++;
count++;
}

private void InternalInsertNodeBefore(LinkedListNode node,LinkedListNode newNode){
newNode.next=node;
nextNode.prev=node.prev;
node.prev.next=newNode;
node.prev=newNode;
version++;
count++;
}

AddBefore(LinkedListNode node,T value)

public LinkedListNode AddBefore(LinkedListNode node,T value){
ValidateNode(node);
LinkedListNode result =new LinkedListNode(node.list,value);
InternalInsertNodeBefore(node,result);
if(node == head){ //这种情况就是在原先的head前面插入数据,所以需要修改head
head=result;
}
return result;
}

AddAfter(LinkedListNode node,T value)

public LinkedListNode AddAfter(LinkedListNode node,T value){
ValidateNode(node);
LinkedListNode result =new LinkedListNode(node.list,value);
InternalInsertNodeBefore(node.next,result); //和AddFirst()内部调用一样,这封装厉害,加法也是减价
return result;
}

public LinkedListNode Find(T value) O(n)

1. EqualityComparer.Default
2. null判断
3. Equals判断

Remove(T value)

1. Find(T value);
2. InternalRemoveNode(LinkedListNode node)
1. check all need check
2. modify next,prev,将中间节点去掉
node.prev.next=node.next;
node.next.prev=node.prev;
if(head==node){ //这个是容易忘记的
head=node.next;
}
3. node.Invalidate() //clear node
4. count--;
5. verson++;

Remove(LinkedListNode node) 同上

如果没有查询的话,你直接构造了一个LinkedListNode,你是不知道它的next,prev的

正向遍历

LinkedListNode node = head;
do{
node=node.next; //因为这里是相当于node指向了另一块内存,而不是修改了原先内存中的东西,所以和原先无关
... do something
}while(node!=head);

反向遍历

LinkedListNode last=head.prev;
LinkedListNode node=last;
do{
node=node.prev; //因为这里是相当于node指向了另一块内存,而不是修改了原先内存中的东西,所以和原先无关
... dosomething
}while(last!=node)

GetEnumerator()

{
return new Enumerator(this);
}

public struct Enumerator:IEnumerator,IEnumerator,...

它限制了实现三个方法,
所以构造函数是非常重要的,负责传入this,也就是LinkedList
new Enumerator(this);