/// <summary>
/// 双向链表节点类
/// </summary>
/// <typeparam name="T">节点中的存放的数据类型</typeparam>
public class Node<T> where T:IComparable<T>
{
/// <summary>
/// 当前节点的数据
/// </summary>
T data;
/// <summary>
/// 节点中存放的数据
/// </summary>
public T Data
{
get { return this.data; }
set { this.data = value; }
}
/// <summary>
/// 当前节点的下一个节点
/// </summary>
Node<T> next;
/// <summary>
/// 下一个节点
/// </summary>
public Node<T> Next
{
get { return this.next; }
set { this.next = value; }
}
/// <summary>
/// 当前节点的上一个节点
/// </summary>
Node<T> prev;
/// <summary>
/// 上一个节点
/// </summary>
public Node<T> Prev
{
get { return prev; }
set { prev = value; }
}
/// <summary>
/// 无参构造:数据为默认值,下一个节点为null,上一个节点也为null
/// </summary>
public Node()
{
this.data = default(T);
this.next = null;
this.prev = null;
}
/// <summary>
/// 构造方法:数据为传过来的t,下一个节点为null,上一个节点也为null
/// </summary>
/// <param name="t">传入的元素值</param>
public Node(T t)
{
this.data = t;
this.next = null;
this.prev = null;
}
/// <summary>
/// 构造方法:数据为t,下一个节点为node
/// </summary>
/// <param name="t">传入的元素值</param>
/// <param name="next">上一个节点</param>
/// <param name="prev">下一个节点</param>
public Node(T t, Node<T> next, Node<T> prev)
{
this.data = t;
this.next = next;
this.prev = prev;
}
/// <summary>
/// 此方法在调试过程中使用,可以删掉
/// </summary>
/// <returns></returns>
public override string ToString()
{
T p = this.prev == null ? default(T) : this.prev.data;
T n = this.next == null ? default(T) : this.next.data;
string s = string.Format("Data:{0},Prev:{1},Next:{2}", data, p, n);
return s;
}
}
/// <summary>
/// 双向链表接口
/// </summary>
/// <typeparam name="T">链表中元素的类型</typeparam>
public interface ILinkList<T> where T:IComparable<T>
{
void AddFirst(T t);
void AddLast(T t);
void Clear();
int Count { get; }
Node<T> Head { get; set; }
Node<T> Tail { get;set;}
void Insert(int index, T t);
bool IsEmpty { get; }
void RemoveAt(int index);
void RemoveFirst();
void RemoveLast();
Node<T> this[int index] { get; }
}
/// <summary>
/// 双向链表操作类
/// </summary>
/// <typeparam name="T">链表中元素的类型</typeparam>
public class LinkList<T> : ILinkList<T> where T:IComparable<T>
{
/// <summary>
/// 链表头节点
/// </summary>
Node<T> head;
/// <summary>
/// 链表头节点
/// </summary>
public Node<T> Head
{
get { return head; }
set { head = value; }
}
/// <summary>
/// 链表尾节点
/// </summary>
Node<T> tail;
/// <summary>
/// 链表尾节点
/// </summary>
public Node<T> Tail
{
get { return tail; }
set { tail = value; }
}
/// <summary>
/// 链表大小
/// </summary>
int size = 0;
/// <summary>
/// 添加节点到链表的开头
/// </summary>
/// <param name="t">要添加的数据</param>
public void AddFirst(T t)
{
Node<T> node = new Node<T>(t);
//如果头为null
if (head == null)
{
//把头节点设置为node
head = node;
//因为是空链表,所以头尾一致
tail = node;
//大小加一
size++;
return;
}
//原来头节点的上一个为新节点
head.Prev = node;
//新节点的下一个为原来的头节点
node.Next = head;
//新头节点为新节点
head = node;
//大小加一
size++;
}
/// <summary>
/// 添加节点到链表的末尾
/// </summary>
/// <param name="t">要添加的数据</param>
public void AddLast(T t)
{
Node<T> node = new Node<T>(t);
//如果头为null
if (head == null)
{
//把头节点设置为node
head = node;
//因为是空链表,所以头尾一致
tail = node;
//大小加一
size++;
return;
}
//将原尾节点的下一个设置为新节点
tail.Next = node;
//将新节点的上一个设置为原尾节点
node.Prev = tail;
//将尾节点重新设置为新节点
tail = node;
//大小加一
size++;
}
/// <summary>
/// 在给定的索引处插入数据
/// </summary>
/// <param name="index">索引</param>
/// <param name="t">要插入的数据</param>
public void Insert(int index, T t)
{
Node<T> node = new Node<T>(t);
//索引过小
if (index < 0)
{
throw new IndexOutOfRangeException();
}
//索引过大
if (index >= Count)
{
throw new IndexOutOfRangeException();
}
//如果链表是空的,而且索引大于0
if (IsEmpty && index > 0)
{
throw new IndexOutOfRangeException();
}
//如果索引为0,意味着向链表头部添加节点。
if (index == 0)
{
AddFirst(t);
return;
}
//要插入位置的节点
Node<T> current = head;
int i = 0;
while (true)
{
if (i == index)
{
break;
}
i++;
current = current.Next;
}
//此处非常重要,特别要注意先后次序
//当前节点的上一个的下一个设置为新节点
current.Prev.Next = node;
//新节点的上一个设置为当前节点的上一个
node.Prev = current.Prev;
//新节点的下一个设置为当前节点
node.Next = current;
//当前节点的上一个设置为新节点
current.Prev = node;
//大小加一
size++;
}
/// <summary>
/// 移除链表中的节点
/// </summary>
/// <param name="index">要移除的节点的索引</param>
public void RemoveAt(int index)
{
//链表头节点是空的
if (IsEmpty)
{
throw new Exception("链表是空的。");
}
//索引过小
if (index < 0)
{
throw new IndexOutOfRangeException();
}
//索引过大
if (index >= Count)
{
throw new IndexOutOfRangeException();
}
//如果要移除的是头节点
if (index == 0)
{
RemoveFirst();
return;
}
if (index == size - 1)
{
RemoveLast();
return;
}
//要移除的节点
Node<T> current = head;
int i = 0;
while (true)
{
if (i == index)
{
break;
}
i++;
current = current.Next;
}
//当前节点的上一个的Next设置为当前节点的Next
current.Prev.Next = current.Next;
//当前节点的下一个的Prev设置为当前节点的Prev
current.Next.Prev = current.Prev;
//大小减一
size--;
}
/// <summary>
/// 移除头节点
/// </summary>
public void RemoveFirst()
{
//链表头节点是空的
if (IsEmpty)
{
throw new Exception("链表是空的。");
}
//如果size为1,那就是清空链表。
if (size == 1)
{
Clear();
return;
}
//将头节点设为原头结点的下一个节点,就是下一个节点上移
head = head.Next;
//处理上一步遗留问题,原来的第二个节点的上一个是头结点,现在第二个要变成头节点,那要把它的Prev设为null才能成为头节点
head.Prev = null;
//大小减一
size--;
}
/// <summary>
/// 移除尾节点
/// </summary>
public void RemoveLast()
{
//链表头节点是空的
if (IsEmpty)
{
throw new Exception("链表是空的。");
}
//如果size为1,那就是清空链表。
if (size == 1)
{
Clear();
return;
}
//尾节点设置为倒数第二个节点
tail = tail.Prev;
//将新尾节点的Next设为null,表示它是新的尾节点
tail.Next = null;
//大小减一
size--;
}
/// <summary>
/// 判断链表是否是空的
/// </summary>
public bool IsEmpty
{
get
{
return head == null;
}
}
/// <summary>
/// 链表中元素的个数
/// </summary>
public int Count
{
get
{
也可以采用遍历的方法获得长度,遍历可以从前向后,也可以从后向前
//int count = 0;
取得链表头部节点
//Node<T> current = new Node<T>();
//current = head;
遍历整个链表,直到最后一个Next为null的节点为止
//while (current!=null)
//{
// count++;
// current = current.Next;
//}
//return count;
return size;
}
}
/// <summary>
/// 清除链表中的数据
/// </summary>
public void Clear()
{
head = null;
tail = null;
size = 0;
}
/// <summary>
/// 根据索引获取链表中的节点
/// </summary>
/// <param name="index">整型索引</param>
/// <returns>节点</returns>
public Node<T> this[int index]
{
get
{
//链表头节点是空的
if (head == null)
{
throw new Exception("链表是空的。");
}
//索引过小
if (index < 0)
{
throw new IndexOutOfRangeException();
}
//索引过大
if (index >= Count)
{
throw new IndexOutOfRangeException();
}
//取得头节点
Node<T> current = new Node<T>();
//current = head;
//int i = 0;
遍历链表
//while (true)
//{
// //找到第index个节点
// if (i == index)
// {
// break;
// }
// current = current.Next;
// i++;
//}
//return current;
//如果索引在前一半,那么从前向后找
if (index < size / 2)
{
current = head;
int i = 0;
//遍历链表
while (true)
{
//找到第index个节点
if (i == index)
{
break;
}
current = current.Next;
i++;
}
return current;
}
else//如果索引在后一半,那么从后向前找
{
current = tail;
int i = size;
//遍历链表
while (true)
{
//找到第index个节点
if (i == index)
{
break;
}
current = current.Prev;
i--;
}
return current.Next;
}
}
}
/// <summary>
/// 冒泡排序,不改变节点的位置,只交换节点的值
/// 和数组的冒泡排序最接近
/// 对于双向链表来说,如果只交换数据,而不交换
/// 节点,那么和单向链表的冒泡排序是一致的
/// </summary>
public void BubbleSort1()
{
if (IsEmpty || size == 1)
{
return;
}
//外层循环节点
Node<T> i;
//内层循环节点
Node<T> j;
i = head;
//循环不改变每个节点的先后次序,仅仅交换节点的值
while (i.Next != null)
{
j = head;
while (j.Next != null)
{
//比较前后两个节点的数据
if (j.Data.CompareTo(j.Next.Data) > 0)
{
//交换两个节点的数据
T temp = j.Data;
j.Data = j.Next.Data;
j.Next.Data = temp;
}
j = j.Next;
}
i = i.Next;
}
}
/// <summary>
/// 用交换节点的方法冒泡
/// 这种方法需要额外的的新节点
/// 对于双向链表来说,稍微麻烦一点的是要处理尾节点
/// 所以在添加了辅助头节点,还需要添加一个辅助尾节点
/// 当然最后也要把辅助尾节点给去掉。
/// </summary>
public void BubbleSort2()
{
//如果链表是空的或者链表中只有一个节点,那不需要排序
if (IsEmpty || size == 1)
{
return;
}
//临时加的新节点
Node<T> newHead;
//外层循环变量
Node<T> i;
//外层循环变量每次改变的值
Node<T> loopValue;
//交换两个节点的临时变量
Node<T> temp;
//在链表的头部加一个新的辅助接点
newHead = new Node<T>();
newHead.Next = head;
head.Prev = newHead;
head = newHead;
//在链表尾部加一个新的辅助接点
Node<T> newTail = new Node<T>();
tail.Next = newTail;
newTail.Prev = tail;
tail = newTail;
//外层循环从链表尾部开始,尾部从最后一个节点开始
//到达链表的头部为止
for (i = tail.Next; i != head; i = loopValue)
{
//开始让p等于链表头
//在里层循环中更改p的位置
loopValue = head;
//里层循环从head开始,到要交换的两个节点的后一个是尾部位置,每次向后前进一个节点
//因为一次循环就将一个最大的元素沉到最末尾了,所以下次不用到达末尾
//而第一次遍历的时候第二个元素的下一个就是null
//j.Next.Next.Next如果是null
//那么j.Next.Next就是我们刚才添加的辅助尾节点
//那么j.Next就是原始链表中的尾节点
//这个时候,就没有必要比较了。
for (Node<T> j = head; j.Next.Next != i && j.Next.Next.Next!=null ; j = j.Next)
{
//j其实就是要交换的两个节点的前一个节点
//比较前后两个元素谁大谁小
if (j.Next.Data.CompareTo(j.Next.Next.Data) > 0)
{
//将要交换的节点和前后的两个节点编号
//要交换的两个是2,3
//前面的节点是1
//后面的节点是4
//要交换的两个节点中的第二个
//temp中存放的是3
temp = j.Next.Next;
//将4接到2的后面
//如果第二个节点有下一个
//要是3有下一个(3后面还有节点,不是尾节点)
if (temp.Next != null)
//将要交换的第二个的下一个的Prev设置为要交换的第一个
temp.Next.Prev = j.Next;
//将要交换的第一个的Next设置为原先第二个节点的下一个
j.Next.Next = temp.Next;
//将2接到的3后面
//这里j.Next还是原来要交换的第一个
//将要交换的第一个的Prev设置为要交换的第二个
j.Next.Prev = temp;
//将要交换的第二个的下一个设置为要交换的第一个
temp.Next = j.Next;
//将3接到1的后面
//将要交换的第二个的Prev设置为要交换的两个节点之前的那个
temp.Prev = j;
//将最前面的那个节点的Next设置为要交换的第二个节点
j.Next = temp;
//让loopValue指向交换过以后的第二个节点那里
//精髓就在这一句,通过在里层循环改变外层循环的条件
loopValue = j.Next.Next;
}
}
}
//最后去掉那个添加上了的辅助头节点
head = head.Next;
//最后去掉那个添加上了的辅助尾节点
tail = tail.Prev ;
}
}