图的邻接表存储结构

using System;

namespace Graphic_AdjacencyList
{
internal class Program
{
private static void Main(string[] args)
{
var adjacencyList = new AdjacencyList<char>();

Console.WriteLine("1.初始化树结构：");

Console.WriteLine("=================================");
//添加顶点；
adjacencyList.AddVertex('A');
adjacencyList.AddVertex('B');
adjacencyList.AddVertex('C');
adjacencyList.AddVertex('D');

//添加边；
adjacencyList.AddEdge('A', 'B');
adjacencyList.AddEdge('A', 'C');
adjacencyList.AddEdge('A', 'D');
adjacencyList.AddEdge('B', 'D');
adjacencyList.AddEdge('C', 'D');

Console.WriteLine("=================================");

Console.WriteLine("2.树的邻接表遍历：");
Console.WriteLine(adjacencyList.ToString());
Console.Read();
}
}
}

namespace Graphic_AdjacencyList
{
/// <summary>
///     链表中的节点
/// </summary>
public class Node<T>
{
/// <summary>
///     邻接点域
/// </summary>
public Vertex<T> Adjvex;

/// <summary>
///     下一个邻接点指针域
/// </summary>
public Node<T> Next;

/// <summary>
///     链表中的节点
/// </summary>
/// <param name="value"></param>
public Node(Vertex<T> value)
{
Adjvex = value;
}
}
}

using System;

namespace Graphic_AdjacencyList
{
/// <summary>
///     链表中的表头节点
/// </summary>
/// <typeparam name="T"></typeparam>
public class Vertex<T>
{
/// <summary>
///     数据
/// </summary>
public T Data;

/// <summary>
///     邻接表表头指针
/// </summary>
public Node<T> FirstEdge;

/// <summary>
///     访问标志，遍历时使用
/// </summary>
public Boolean Visited;

/// <summary>
///     表头节点
/// </summary>
/// <param name="value"></param>
public Vertex(T value) //构造方法；
{
Data = value;
}
}
}

using System;
using System.Collections.Generic;
using System.Linq;

namespace Graphic_AdjacencyList
{
/// <summary>
///     图的邻接表存储类
/// </summary>
/// <typeparam name="T"></typeparam>
public class AdjacencyList<T>
{
/// <summary>
///     图的顶点集合
/// </summary>
private readonly List<Vertex<T>> _items;

public AdjacencyList()
: this(10)
{
}

public AdjacencyList(int capacity)
{
_items = new List<Vertex<T>>(capacity);
}

/// <summary>
///     添加顶点
/// </summary>
/// <param name="item"></param>
public void AddVertex(T item)
{
if (Contains(item))
{
throw new ArgumentException("插入了重复顶点！");
}
_items.Add(new Vertex<T>(item));
Console.WriteLine("添加顶点：" + item);
}

/// <summary>
///     添加无向边
/// </summary>
/// <param name="from"></param>
/// <param name="to"></param>
public void AddEdge(T from, T to)
{
Vertex<T> fromVer = Find(from);
if (fromVer == null)
{
throw new ArgumentException("头顶点不存在！");
}
Vertex<T> toVer = Find(to);
if (toVer == null)
{
throw new ArgumentException("尾顶点不存在！");
}
//无向边的两个顶点都需记录边信息；
AddDirectedEdge(fromVer, toVer);
AddDirectedEdge(toVer, fromVer);

Console.WriteLine(string.Format("添加无向边：{0}—{1}", from, to));
}

/// <summary>
///     添加有向边
/// </summary>
/// <param name="fromVer"></param>
/// <param name="toVer"></param>
private void AddDirectedEdge(Vertex<T> fromVer, Vertex<T> toVer)
{
if (fromVer.FirstEdge == null) //无临接点时；
{
fromVer.FirstEdge = new Node<T>(toVer);
}
else
{
Node<T> tem, node = fromVer.FirstEdge;
do
{
if (node.Adjvex.Data.Equals(toVer.Data))
{
throw new ArgumentException("添加了重复的边！");
}
tem = node;
node = node.Next;
} while (node != null);
tem.Next = new Node<T>(toVer); //添加到链表末尾；
}
}
public bool Contains(T item)
{
//foreach (Vertex<T> v in _items)
//{
//    if (v.data.Equals(item))
//    {
//        return true;
//    }
//}
return _items.Any(v => v.Data.Equals(item));
}

private Vertex<T> Find(T item)
{
//foreach (Vertex<T> v in _items)
//{
//    if (v.data.Equals(item))
//    {
//        return v;
//    }
//}
return _items.FirstOrDefault(v => v.Data.Equals(item));
}

public override string ToString()
{
string result = string.Empty;
foreach (var vertex in _items)
{
if (vertex != null)
{
result += string.Format("顶点：{0}:", vertex.Data);
if (vertex.FirstEdge != null)
{
Node<T> tem = vertex.FirstEdge;
while (tem != null)
{
result += tem.Adjvex.Data.ToString();
tem = tem.Next;
}
}
}
result += "\r\n";
}
return result;
}
}
}