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<T> list;
LinkedListNode<T> next;
LinkedListNode<T> prev;
T item;	

cotr

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

prop

1. List{get{return list;}}
2. Next{get{return next==null||next==list.head?null:next;}}  //这样写我很疑惑
3. Previous{Get{return prev==null||this==list.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<T> head; //头结点
int count;      //结点数量
int version;	//版本

interface

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

ctor

public LinkedList(){} //什么也没有
public LinkedList(IEnumerable<T> 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<T> AddFirst(T value){
	LinkedListNode<T> result=new LinkedListNode<T>(this,value);
	if(head==null){
		InternalInsertNodeToEmptyList(result);
	}else{
		InternalInsertNodeBefore(head,result);
		head=result;   //将新的node设置为head
	}
	return result;
}

private void InternalInsertNodeToEmptyList(LinkedListNode<T> result){
	Debug.Assert(head==null&&count==0,"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<T> node,LinkedListNode<T> newNode){
	newNode.next=node;
	nextNode.prev=node.prev;
	node.prev.next=newNode;
	node.prev=newNode;
	version++;
	count++;
}

AddBefore(LinkedListNode node,T value)

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

AddAfter(LinkedListNode node,T value)

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

public LinkedListNode Find(T value) O(n)

1. EqualityComparer<T>.Default
2. null判断
3. Equals判断

Remove(T value)

1. Find(T value);
2. InternalRemoveNode(LinkedListNode<T> 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<T> node = head;
do{
	node=node.next;  //因为这里是相当于node指向了另一块内存,而不是修改了原先内存中的东西,所以和原先无关
	... do something
}while(node!=head);

反向遍历

LinkedListNode<T> last=head.prev;
LinkedListNode<T> 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);