数据结构之双向链表
双向链表宛如一列火车，刚发明的时候只有一个头，若是它的行驶路线为：A->B->C->D->E->F->G->H->I->J->K->A
这个时候有一批货物须要从K运到J，那么它的运输路线必定是：
K->A->B->C->D->E->F->G->H->I->J
因此后来火车就有了两个头，因而可知双向链表的重要性！！！node
双向链表：在单链表结点上增添了一个指针域，指向当前结点的前驱。这样就能够方便的由其后继来找到其前驱，而实现输出终端结点到开始结点的数据序列。
web
双向链表的结点结构svg
/// <summary>
/// 双向链表节点
/// </summary>
/// <typeparam name="T"></typeparam>
public class BdNode<T>
{
public T data { set; get; }
public BdNode<T> next { set; get; }
public BdNode<T> prev { set; get; }
public BdNode(T val, BdNode<T> prev, BdNode<T> next)
{
this.Data = val;
this.Prev = prev;
this.Next = next;
}
public BdNode(T data, BdNode<T> next)
{
this.data = data;
this.next = next;
this.prev = null;
}
public BdNode(BdNode<T> next)
{
this.data = default(T);
this.next = next;
this.prev = null;
}
public BdNode(T data)
{
this.data = data;
this.next = null;
this.prev = null;
}
public BdNode()
{
data = default(T);
next = null;
prev = null;
}
public T Data
{
set { this.data = value; }
get { return this.data; }
}
public BdNode<T> Prev
{
get { return prev; }
set { prev = value; }
}
public BdNode<T> Next
{
get { return next; }
set { next = value; }
}
}
双向链表还能做为双向循环链表使用，下图为双向循环链表的结构图：
this
双向链表的插入：
总共四个步骤：
步骤1：a.next=a2;
步骤2：a.prev=a1;
步骤3：a1.next=a;
步骤4：a2.prev=a;
插入顺序按图标所示，操做虽然简单可是不能写反，顺序很重要！
其实现代码以下：spa
/// <summary>
/// 在最后附加元素
/// </summary>
/// <param name="item"></param>
public void Append(T item)
{
BdNode<T> d = new BdNode<T>(item);
BdNode<T> n = new BdNode<T>();
if (Head == null)
{
Head = d;
return;
}
n = Head;
while (n.Next != null)
{
n = n.Next;
}
n.Next = d;
d.Prev = n;
}
//前插
public void InsertBefore(T item, int i)
{
if (IsEmpty() || i < 0)
{
Console.WriteLine("List is empty or Position is error!");
return;
}
//在最开头插入
if (i == 0)
{
BdNode<T> q = new BdNode<T>(item);
q.Next = head;//把"头"改为第二个元素
head.Prev = q;
head = q;//把本身设置为"头"
return;
}
BdNode<T> n = head;
BdNode<T> d = new BdNode<T>();
int j = 0;
//找到位置i的前一个元素d
while (n.Next != null && j < i)
{
d = n;
n = n.Next;
j++;
}
if (n.Next == null) //说明是在最后节点插入(即追加)
{
BdNode<T> q = new BdNode<T>(item);
n.Next = q;
q.Prev = n;
q.Next = null;
}
else
{
if (j == i)
{
BdNode<T> q = new BdNode<T>(item);
d.Next = q;
q.Prev = d;
q.Next = n;
n.Prev = q;
}
}
}
/// <summary>
/// 在位置i后插入元素item
/// </summary>
/// <param name="item"></param>
/// <param name="i"></param>
public void InsertAfter(T item, int i)
{
if (IsEmpty() || i < 0)
{
Console.WriteLine("List is empty or Position is error!");
return;
}
if (i == 0)
{
BdNode<T> q = new BdNode<T>(item);
q.Next = head.Next;
head.Next.Prev = q;
head.Next = q;
q.Prev = head;
return;
}
BdNode<T> p = head;
int j = 0;
while (p != null && j < i)
{
p = p.Next;
j++;
}
if (j == i)
{
BdNode<T> q = new BdNode<T>(item);
q.Next = p.Next;
if (p.Next != null)
{
p.Next.Prev = q;
}
p.Next = q;
q.Prev = p;
}
else
{
Console.WriteLine("Position is error!");
}
}
删除操做：只需把被删除节点的前一个节点的next指针指向它下一个节点的下一个节点，再把被删除节点的下一个节点的prev指针指向它前一个节点的前一个节点就OK了，以下图所示：
其实现代码以下：指针
/// <summary>
/// 删除位置i的元素
/// </summary>
/// <param name="i"></param>
/// <returns></returns>
public T RemoveAt(int i)
{
if (IsEmpty() || i < 0)
{
Console.WriteLine("Link is empty or Position is error!");
return default(T);
}
BdNode<T> q = new BdNode<T>();
if (i == 0)
{
q = head;
head = head.Next;
head.Prev = null;
return q.Data;
}
BdNode<T> p = head;
int j = 0;
while (p.Next != null && j < i)
{
j++;
q = p;
p = p.Next;
}
if (j == i)
{
p.Next.Prev = q;
q.Next = p.Next;
return p.Data;
}
else
{
Console.WriteLine("The node is not exist!");
return default(T);
}
}
双向链表的好处在于：
一、对链表数据的遍历操做不单单能向后遍历(如单链表），并且还可以向前遍历寻找元素，对链表数据的操做更加灵活。
二、能够直接删除某一个数据元素，我的认为这是比较重要的一方面，由于对单链表而言，若是要删除某一个数据元素，须要遍历至此元素以前的一个结点才能删除，而双向链表能够遍历到某一元素，而后能够直接对它进行删除操做。code