C#学习单向链表和接口 IList<T>

C#学习单向链表和接口 IList<T>

作者：乌龙哈里
时间：2015-11-04
平台：Window7 64bit,Visual Studio Community 2015

参考：

• MSDN 索引器（C# 编程指南）
• 《数据结构（C#语言版）》下载
• When to use IEnumerable, ICollection, IList and List

章节：

• 单向链表元素
• 定义单向链表操作接口
• 逐步实现单向链表

正文：

前面学习了 IEnumerable<T>、IComparable<T>、ICollection<T> 三个接口，就是为了学习数据结构编程使用。

一、单向链表元素

根据单向链表（Single Linked List）的定义，我们知道链表中的元素 Node 由 数据 和 下一个元素 NextNode 两部分组成。构建如下：

//=====单向链表元素=====
class Node<T>
{
    public T Value;
    public Node<T> NextNode;
}

该元素的创立应该有不带参数（）和带参数（T value） 两种形式，我们继续补全代码如下：

//=====单向链表元素=====
class Node<T>
{
    public T Value;
    public Node<T> NextNode;

public Node():this(default(T)){ }
    public Node(T value)
    {
        Value = value;
        NextNode = null;
    }
}

不带参数的创立里面有 default(T)，参见 MSDN 泛型代码中的默认关键字（C# 编程指南）。

二、定义单向链表操作接口

有了元素 Node<T>后，我们要操作它，设想中的操作有 增加、删除、修改、清空、遍历、索引器等，我们看看接口 IColloction<T> 和 IList<T> 的约定，就知道我们要实现 IList<T>。

//======参考 IList<T>===
public interface IList<T> : ICollection<T>
{
    T this[int index] {get;set;}
    int IndexOf(T item);
    void Insert(int index, T item);
    void RemoveAt(int index);
}

//======参考 ICollection<T>===
public interface ICollection<T> : IEnumerable<T>
{
     int Count { get; }
     bool IsReadOnly { get; }
     void Add(T item);
     void Clear();
     bool Contains(T item);
     void CopyTo(T[] array, int arrayIndex);
     bool Remove(T item);
}

三、逐步实现单向链表

定义一个单向链表类：

//=====单向链表=====
public class SinglyLinkedList<T> : IList<T>
{
}

接下来在VS2015 IDE 的小黄灯泡提示内选实现，让 IDE 帮我们出填空题吧。好长一大串^_^!，共14个方法或属性需要填（以我小菜鸟的经历来看，绝对是我填过最长的一个类）。下来我们只好逐步来实现这个类。

1、加入头元素。先要引入 元素类 Node<T>,把它命名为 head（书本上是这样起名的，本来我想起名叫 root的），按 C# 6.0 的新写法，我们可以直接把它缺省值 =null。刚开始创建链表里面是空的，所以头元素为 null。

//=====单向链表=====
public class SinglyLinkedList<T> : IList<T>
{
    private Node<T> head = null;

2、填写 Add(T item) 方法和 int Count{get;} 属性。由于这是个链表，元素只能直线流动，所以要添加元素只能一个一个遍历到链表最尾端，我们这里加一个计数字段 int _count 。

//=====单向链表=====
public class SinglyLinkedList<T> : IList<T>
{
    private Node<T> head = null;
    private int _count = 0;
    //---添加元素并计数
    public void Add(T item)
    {
        if (head == null)
        {
            head = new Node<T>(item);
            _count++;
        }
        else
        {
            Node<T> node = head;
            while (node.NextNode != null)
            {
                node = node.NextNode;
                _count++;
            }
            node.NextNode = new Node<T>(item);
        }
    }
    //---计数---
    public int Count
    {
        get { return _count; }
    }

好了，终于可以添加元素并开始计数了，实验调用一下，看看是否正确：

static void Main(string[] args)
{
    SinglyLinkedList<int> slist = new SinglyLinkedList<int>();
    Console.WriteLine($"count: {slist.Count}");
    slist.Add(1);
    slist.Add(2);
    slist.Add(3);
    slist.Add(4);
    Console.WriteLine($"count: {slist.Count}");

//输出结果：
//count: 0
//count: 4

3、实现枚举器，使得可以遍历。能够 Add(T item)后，虽然能加入元素，但我们无法显示出来里面元素的值是多少，这时就要实现 IEnumerable<T> 接口，让它能够遍历显示里面的元素值。

//---实现可枚举
public IEnumerator<T> GetEnumerator()
{
    Node<T> node = head;
    Node<T> result = new Node<T>();
    while (node != null)
    {
        result = node;
        node = node.NextNode;
        yield return result.Value;
    }
}
//---不用填写，只调用上面的
IEnumerator IEnumerable.GetEnumerator()
{
    throw new NotImplementedException();
}

接下来调用看看：

Console.Write("elements: ");
foreach (var s in slist) { Console.Write($"{s} "); }

//输出：
//elements: 1 2 3 4

4、实现清空。只要把 head 设置成null ，并把 计数器归零即可。这里我这个小菜鸟不禁想到没有垃圾收集器的语言，那剩下的元素所占内存怎么释放，难道要先遍历逐个释放？或者数据不放在堆上？算了，我水平太次，不思考超出能力范围的事。

//---清空---
public void Clear()
{
    head = null;
    _count = 0;
}

5、实现规定的 Insert(int index,T item)。意思是在 index 位置上插入一个元素。由于是链表，插入一个新值会破坏掉整个链的连接，我们需要在插入新值前保护现场，即把上个元素和当前元素保存起来，然后把在前个元素的 NextNode 里填写新元素，在新元素的 NextNode 里填写当前元素，这样整个链表又完整了。

//---插入值---
public void Insert(int index, T item)
{
    if (index >= 0 && index < _count)
    {
        Node<T> node = head;
        Node<T> prev = null;
        Node<T> next = null;
        //头元素永远是head，所以要专门弄个index=0的特殊
        if (index == 0)
        {
            next = head;
            head = new Node<T>(item);
            head.NextNode = next;
        }
        else
        {
            for (int i = 0; i < index; i++)
            {
                prev = node;
                node = node.NextNode;
            }
            next = node;
            node = new Node<T>(item);
            node.NextNode = next;
            prev.NextNode = node;
        }
        _count++;
    }
    else throw new Exception("Out of Range !");
}

调用检查正确否：

SinglyLinkedList<int> slist = new SinglyLinkedList<int>();
Console.WriteLine($"count: {slist.Count}");

slist.Add(1);
slist.Add(2);
slist.Add(3);
slist.Add(4);

Console.WriteLine($"count: {slist.Count}");
Console.Write("elements: ");
foreach (var s in slist) { Console.Write($"{s} "); }
Console.WriteLine();

slist.Insert(0, 5);
Console.Write("elements: ");
foreach (var s in slist) { Console.Write($"{s} "); }
Console.WriteLine();

Console.WriteLine($"count: {slist.Count}");
Console.ReadKey();

//输出：
count: 0
count: 4
elements: 1 2 3 4
elements: 5 1 2 3 4
count: 5

如果连 index=0 都能插入值，那我们之前的 Add(T item) 可以视作是 Insert(0,T item)，但是在 Insert 里面有个index 越界的检查，当链表为空的时候， Count=0，会抛出错误。针对这个，我们在 Add(T item) 前先把 Count +1，Insert 后再 Count -1 回去。Add 改造如下：

//---添加元素并计数
public void Add(T item)
{
    _count++;
    Insert(_count - 1, item);
    _count--;
}

6、填写 int IndexOf(T item) 方法。后面的方法有 int IndexOf(T item)、bool Remove(T item)、void RemoveAt(int index) 、bool Contains(T item) 和一个索引器，这些都和查找元素有关，而 int IndexOf(T item) 无疑就是一个查找元素位置的方法，所以我们先要实现它。
还有一个问题就是，要查找 T item ，T 必须是可比较类型，所以我们在 SinglyLinkedList 类上加个 T 的约束是符合 IComparable<T> 接口的。

//=====单向链表=====
public class SinglyLinkedList<T> : IList<T> where T : IComparable<T>

//---查找---
public int IndexOf(T item)
{
    int result = -1;
    Node<T> node = head;
    for(int i = 0; i < _count; i++)
    {
        if (node.Value.Equals(item))
        {
            result = i;
            break;
        }
        node = node.NextNode;
    }
    return result;
}

有了 int IndexOf(T item) 这个利器，下来的一些方法填空就简单了。

//---包含---
public bool Contains(T item)
{
    return IndexOf(item) > -1 ? true : false;
}
//---删除---
public void RemoveAt(int index)
{
    if (index >= 0 && index < _count)
    {
        Node<T> prev = null;
        Node<T> node = head;
        if (index == 0)
        {
            head = head.NextNode;
        }
        else
        {
            for (int i = 0; i < index; i++)
            {
                prev = node;
                node = node.NextNode;
            }
            prev.NextNode = node.NextNode;
        }
        _count--;
    }
    else throw new Exception("Out of Range !");
}
//---删除---
public bool Remove(T item)
{
    int n = IndexOf(item);
    if (n < 0) { return false; }
    RemoveAt(n);
    return true;
}

7、完成索引器。索引器见参考。下来具体实现：

//---索引器
public T this[int index]
{
    get
    {
        if (index >= 0 && index < _count)
        {
            Node<T> node = head;
            for(int i = 0; i < index;i++)
            {
                node = node.NextNode;
            }
            return node.Value;
        }
        else throw new Exception("Out of Range !");
    }
    set
    {
        Insert(index,value);
    }
}

8、实现拷贝功能:

//---拷贝
public void CopyTo(T[] array, int arrayIndex)
{
    Node<T> node = head;
    for(int i = 0; i < _count; i++)
    {
        array[arrayIndex + i] = node.Value;
        node = node.NextNode;
    }
}

至此，整个单向链表和 IList<T> 接口就学习好了。附完成源程序：

//=====单向链表=====
public class SinglyLinkedList<T> : IList<T> where T : IComparable<T>
{
    private Node<T> head = null;
    private int _count = 0;
    //---添加元素并计数---
    public void Add(T item)
    {
        _count++;
        Insert(_count - 1, item);
        _count--;
    }
    //---计数---
    public int Count
    {
        get { return _count; }
    }
    //---实现可枚举
    public IEnumerator<T> GetEnumerator()
    {
        Node<T> node = head;
        Node<T> result = new Node<T>();
        while (node != null)
        {
            result = node;
            node = node.NextNode;
            yield return result.Value;
        }
    }
    //---不用填写，只调用上面的
    IEnumerator IEnumerable.GetEnumerator()
    {
        throw new NotImplementedException();
    }
    //---清空---
    public void Clear()
    {
        head = null;
        _count = 0;
    }
    //---插入值---
    public void Insert(int index, T item)
    {
        if (index >= 0 && index < _count)
        {
            Node<T> node = head;
            Node<T> prev = null;
            Node<T> next = null;
            //头元素永远是head，所以要专门弄个index=0的特殊
            if (index == 0)
            {
                next = head;
                head = new Node<T>(item);
                head.NextNode = next;
            }
            else
            {
                for (int i = 0; i < index; i++)
                {
                    prev = node;
                    node = node.NextNode;
                }
                next = node;
                node = new Node<T>(item);
                node.NextNode = next;
                prev.NextNode = node;
            }
            _count++;
        }
        else throw new Exception("Out of Range !");
    }
    //---查找---
    public int IndexOf(T item)
    {
        int result = -1;
        Node<T> node = head;
        for (int i = 0; i < _count; i++)
        {
            if (node.Value.Equals(item))
            {
                result = i;
                break;
            }
            node = node.NextNode;
        }
        return result;
    }
    //---包含---
    public bool Contains(T item)
    {
        return IndexOf(item) > -1 ? true : false;
    }
    //---删除---
    public void RemoveAt(int index)
    {
        if (index >= 0 && index < _count)
        {
            Node<T> prev = null;
            Node<T> node = head;
            if (index == 0)
            {
                head = head.NextNode;
            }
            else
            {
                for (int i = 0; i < index; i++)
                {
                    prev = node;
                    node = node.NextNode;
                }
                prev.NextNode = node.NextNode;
            }
            _count--;
        }
        else throw new Exception("Out of Range !");
    }
    //---删除---
    public bool Remove(T item)
    {
        int n = IndexOf(item);
        if (n < 0) { return false; }
        RemoveAt(n);
        return true;
    }
    //---索引器---
    public T this[int index]
    {
        get
        {
            if (index >= 0 && index < _count)
            {
                Node<T> node = head;
                for (int i = 0; i < index; i++)
                {
                    node = node.NextNode;
                }
                return node.Value;
            }
            else throw new Exception("Out of Range !");
        }
        set
        {
            Insert(index, value);
        }
    }
    //---只读？---
    public bool IsReadOnly
    {
        get { return false; }
    }
    //---拷贝---
    public void CopyTo(T[] array, int arrayIndex)
    {
        Node<T> node = head;
        for (int i = 0; i < _count; i++)
        {
            array[arrayIndex + i] = node.Value;
            node = node.NextNode;
        }
    }
}
//=====单向链表元素=====
class Node<T>
{
    public T Value;
    public Node<T> NextNode;
    public Node() : this(default(T)) { }
    public Node(T value)
    {
        Value = value;
        NextNode = null;
    }
}