/// <summary> /// 拆分结点 /// </summary> /// <param name="node">要被拆分的结点</param> /// <param name="offset">拆分偏移量</param> /// <param name="after">前拆将会将offset之前的元素作为返回结点,后拆分则会将offset之后的元素作为返回结点</param> /// <returns>拆分出的结点</returns> private QuickListNode SplitNode(QuickListNode node, int offset, bool after) { var newNode = CreateNode(); newNode.List.Init(node.List.Split(offset, after)); return(newNode); }
/// <summary> /// 快速列表结点是否允许插入 /// </summary> /// <param name="node">结点</param> /// <returns>是否可以插入</returns> private bool AllowInsert(QuickListNode node) { if (node == null) { return(false); } return(node.List.Count < fill); }
/// <summary> /// 清空 /// </summary> public void Clear() { header = null; tail = null; version = 0; Count = 0; Length = 0; }
/// <summary> /// 是否允许进行合并 /// </summary> /// <param name="a">结点</param> /// <param name="b">结点</param> /// <returns>是否可以合并</returns> private bool AllowMerge(QuickListNode a, QuickListNode b) { if (a == null || b == null) { return(false); } return(a.List.Count + b.List.Count < (fill * MERGE_PRO)); }
/// <summary> /// 构造一个迭代器 /// </summary> /// <param name="quickList"></param> /// <param name="forward"></param> internal Enumerator(QuickList <TElement> quickList, bool forward) { this.quickList = quickList; this.forward = forward; version = quickList.version; current = default(TElement); node = forward ? quickList.header : quickList.tail; index = 0; }
/// <summary> /// 列表弹出数据 /// </summary> /// <param name="node">结点</param> /// <param name="head">是否是头部</param> private TElement ListPop(QuickListNode node, bool head) { var ele = head ? node.List.Shift() : node.List.Pop(); if (node.List.Count <= 0) { DeleteNode(node); } --Count; ++version; return(ele); }
/// <summary> /// 尝试合并结点 /// </summary> /// <param name="node">发起合并的结点</param> private void AttemptMergeNode(QuickListNode node) { if (node == null) { return; } QuickListNode backward, backwardBackward, forward, forwardForward; backward = backwardBackward = forward = forwardForward = null; if (node.Backward != null) { backward = node.Backward; if (backward.Backward != null) { backwardBackward = backward.Backward; } } if (node.Forward != null) { forward = node.Forward; if (forward.Forward != null) { forwardForward = forward.Forward; } } if (AllowMerge(backward, backwardBackward)) { MergeNode(backward, backwardBackward, false); backward = backwardBackward = null; } if (AllowMerge(forward, forwardForward)) { MergeNode(forward, forwardForward, true); forward = forwardForward = null; } if (AllowMerge(node, node.Backward)) { MergeNode(node, node.Backward, false); } if (AllowMerge(node, node.Forward)) { MergeNode(node, node.Forward, true); } }
/// <summary> /// 插入结点 /// </summary> /// <param name="oldNode">旧的结点</param> /// <param name="newNode">新的结点</param> /// <param name="after">在旧的结点之前还是之后</param> private void InsertNode(QuickListNode oldNode, QuickListNode newNode, bool after) { if (after) { newNode.Backward = oldNode; if (oldNode != null) { newNode.Forward = oldNode.Forward; if (oldNode.Forward != null) { oldNode.Forward.Backward = newNode; } oldNode.Forward = newNode; } if (tail == oldNode) { tail = newNode; } } else { newNode.Forward = oldNode; if (oldNode != null) { newNode.Backward = oldNode.Backward; if (oldNode.Backward != null) { oldNode.Backward.Forward = newNode; } oldNode.Backward = newNode; } if (header == oldNode) { header = newNode; } } if (Length == 0) { header = tail = newNode; } ++Length; }
/// <summary> /// 列表弹出数据 /// </summary> /// <param name="node">结点</param> /// <param name="head">是否是头部</param> private TElement ListPop(QuickListNode node, bool head) { TElement ele; if (head) { ele = node.List.Shift(); } else { ele = node.List.Pop(); } if (node.List.Count <= 0) { DeleteNode(node); } --Count; ++version; return(ele); }
/// <summary> /// 删除结点 /// </summary> /// <param name="node">结点</param> private void DeleteNode(QuickListNode node) { if (node.Forward != null) { node.Forward.Backward = node.Backward; } if (node.Backward != null) { node.Backward.Forward = node.Forward; } if (node == tail) { tail = node.Backward; } if (node == header) { header = node.Forward; } Count -= node.List.Count; --Length; node.List.IsDelete = true; }
/// <summary> /// 移动到下一个节点 /// </summary> /// <returns>下一个节点是否存在</returns> public bool MoveNext() { if (node == null) { return(false); } if (version != quickList.version) { throw new InvalidOperationException("Can not modify data when iterates again."); } if (forward) { do { if (index < node.List.Count) { current = node.List[index++]; return(true); } index = 0; node = node.Forward; } while (node != null); return(false); } do { if (index < node.List.Count) { current = node.List[node.List.Count - ++index]; return(true); } index = 0; node = node.Backward; } while (node != null); return(false); }
/// <summary> /// 将从结点合并进主节点 /// </summary> /// <param name="master">主结点</param> /// <param name="slave">从结点</param> /// <param name="after">从结点将怎么合并</param> private void MergeNode(QuickListNode master, QuickListNode slave, bool after) { master.List.Merge(slave.List, after); DeleteNode(slave); }
/// <summary> /// 插入元素 /// </summary> /// <param name="insert">被插入的元素</param> /// <param name="after">是否在被查找的元素之后插入</param> /// <param name="node">需要插入的结点</param> /// <param name="offset">结点相对偏移量</param> private void Insert(TElement insert, QuickListNode node, int offset, bool after) { bool full, fullNext, fullBackward, atTail, atHead; full = fullNext = fullBackward = atTail = atHead = false; QuickListNode newNode; if (node == null) { newNode = CreateNode(); newNode.List.InsertAt(insert, 0); InsertNode(null, newNode, after); ++Count; ++version; return; } //如果结点不能插入那么标记为满 if (!AllowInsert(node)) { full = true; } if (after && (offset + 1) == node.List.Count) { //标记为尾部的元素 atTail = true; //同时如果后面的结点也不能插入那么标记后置结点已满 if (!AllowInsert(node.Forward)) { fullNext = true; } } if (!after && (offset == 0)) { //标记为头部元素 atHead = true; //同时如果之前的结点也不能插入那么标记前置结点已满 if (!AllowInsert(node.Backward)) { fullBackward = true; } } //如果结点没有满,且是后插式插入 if (!full && after) { if (offset + 1 < node.List.Count) { //如果偏移量的位置之后还存在元素 node.List.InsertAt(insert, offset + 1); } else { //如果之后没有元素那么直接推入 node.List.Push(insert); } } else if (!full) { //结点没有满,且是前插式 node.List.InsertAt(insert, offset); } else if (atTail && node.Forward != null && !fullNext && after) { //如果当前结点满了,且是后插入尾部元素,并且下一个结点存在而且不是满的 //那么就会插入到下一个结点中的头部 newNode = node.Forward; newNode.List.UnShift(insert); } else if (atHead && node.Backward != null && !fullBackward && !after) { //如果当前结点满了,且是前插入头部元素,并且上一个结点存在而且不是满的 //那么就会插入到上一个结点中的尾部 newNode = node.Backward; newNode.List.Push(insert); } else if (((atTail && node.Forward != null && fullNext && after) || (atHead && node.Backward != null && fullBackward && !after))) { //如果当前结点是满的,且前置结点和后置结点都是满的那么 //就新建一个结点,插入在2个结点之间 newNode = CreateNode(); newNode.List.InsertAt(insert, 0); InsertNode(node, newNode, after); } else { //如果当前结点是满的,且插入的元素不处于头部或者尾部的位置 //那么拆分数据 newNode = SplitNode(node, offset, after); if (after) { newNode.List.UnShift(insert); } else { newNode.List.Push(insert); } InsertNode(node, newNode, after); AttemptMergeNode(node); } ++Count; ++version; }
/// <summary> /// 重置迭代器 /// </summary> void IEnumerator.Reset() { current = default(TElement); node = forward ? quickList.header : quickList.tail; index = 0; }
/// <summary> /// 快速列表结点是否允许插入 /// </summary> /// <param name="node">结点</param> /// <returns>是否可以插入</returns> private bool AllowInsert(QuickListNode node) { return(node?.List.Count < fill); }