数据结构（C#语言版）——线性表

线性表

线性表(List)：由n(n>=0)个相同类型的数据元素构成的有限序列。
简记L=(D，R) D：数据元素的有限集合；R：数据元素之间关系的有限集合。
线性表的基本操作：求长度、清空操作、判断线性表是否为空、附加操作、插入操作、删除操作、取表元。

/// <summary>
/// 线性表的基本操作接口
/// 线性表(List)：由n(n>=0)个相同类型的数据元素构成的有限序列。
/// 简记L=(D，R) D：数据元素的有限集合；R：数据元素之间关系的有限集合。
/// </summary>
/// <typeparam name="T">元素类型</typeparam>
public interface IList<T>: IEnumerable<T> {
    /// <summary>
    /// 列表长度
    /// </summary>
    int Count { get; }

    /// <summary>
    /// 清空列表
    /// </summary>
    void Clear();

    /// <summary>
    /// 判断是否为空
    /// </summary>
    bool IsEmpty { get; }

    /// <summary>
    /// 添加一个数据项至列表尾部
    /// </summary>
    /// <param name="value">插入项</param>
    void Add(T value);

    /// <summary>
    /// 在指定位置插入一个数据项
    /// </summary>
    /// <param name="value">数据项</param>
    /// <param name="index">位置</param>
    void Insert(T value, int index);

    /// <summary>
    /// 删除指定位置的数据项
    /// </summary>
    /// <param name="index">位置</param>
    void Delete(int index);

    /// <summary>
    /// 获取指定位置的数据项
    /// </summary>
    /// <param name="index">位置</param>
    /// <returns>数据项</returns>
    T this[int index] { get; set; }
}

顺序表

在内存中用一块地址连续的空间依次存放线性表的数据元素，这种方式存储的线性表叫顺序表。

顺序表是用地址连续的存储单元顺序存储线性表中的各个数据元素，逻辑上相邻的数据元素在物理位置上也相邻。因此，在顺序表中查找任何一个位置上的数据元素非常方便，这是顺序存储的优点。但是，在对顺序表进行插入和删除时，需要通过移动数据元素来实现 ，影响了运行效率。

顺序表实现：

public class SequenceList<T> : IList<T> {
    private const int Step = 16;
    private int _capacity;
    private T[] _datas;
    private int _last = -1;

    public SequenceList() : this(Step) {}

    public SequenceList(int capacity) {
        this._capacity = capacity;
        this._datas = new T[capacity];
    }

    #region Implementation of IEnumerable

    public IEnumerator<T> GetEnumerator() {
        int index = 0;
        while(index<=this._last) {
            yield return this._datas[index++];
        }
    }

    IEnumerator IEnumerable.GetEnumerator() {
        return GetEnumerator();
    }

    #endregion

    #region Implementation of IList<T>

    /// <summary>
    /// 列表长度
    /// </summary>
    public int Count {
        get { return this._last + 1; }
    }

    /// <summary>
    /// 清空列表
    /// </summary>
    public void Clear() {
        this._last = -1;
    }

    /// <summary>
    /// 判断是否为空
    /// </summary>
    public bool IsEmpty {
        get { return this._last == -1; }
    }

    /// <summary>
    /// 添加一个数据项至列表尾部
    /// </summary>
    /// <param name="value">插入项</param>
    public void Add(T value) {
        if(this._last+1==this._capacity) {
            Reassign();
        }
        this._last++;
        this._datas[this._last] = value;
    }

    private void Reassign() {
        this._capacity += Step;
        T[] newDatas = new T[this._capacity];
        int index = 0;
        while(index<=this._last) {
            newDatas[index] = this._datas[index];
            index++;
        }
        this._datas = newDatas;
    }

    /// <summary>
    /// 在指定位置插入一个数据项
    /// </summary>
    /// <param name="value">数据项</param>
    /// <param name="index">位置</param>
    public void Insert(T value, int index) {
        CheckIndex(index);
        if(this._last+1==this._capacity) {
            Reassign();
        }
        this._last++;
        int tempIndex = this._last;
        while(tempIndex>index) {
            this._datas[tempIndex] = this._datas[tempIndex - 1];
            tempIndex--;
        }
        this._datas[tempIndex] = value;
    }

    private void CheckIndex(int index) {
        if(index<0 || index>this._last) {
            throw new ArgumentException("不正确的位置。");
        }
    }

    /// <summary>
    /// 删除指定位置的数据项
    /// </summary>
    /// <param name="index">位置</param>
    public void Delete(int index) {
        CheckIndex(index);
        int tempIndex = index;
        while(tempIndex<this._last) {
            this._datas[tempIndex] = this._datas[tempIndex + 1];
            tempIndex++;
        }
        this._last--;
    }

    /// <summary>
    /// 获取指定位置的数据项
    /// </summary>
    /// <param name="index">位置</param>
    /// <returns>数据项</returns>
    public T this[int index] {
        get {
            CheckIndex(index);
            return this._datas[index];
        }
        set {
            CheckIndex(index);
            this._datas[index] = value;
        }
    }

    #endregion
}

顺序表测试：

[TestClass]
public class SequenceListTest {
    /// <summary>
    /// 已知顺序表L，写一算法将其倒置
    /// 11，23，36，45，80，60，40，6
    /// </summary>
    [TestMethod]
    public void Revers() {
        SequenceList<int> l = new SequenceList<int>();
        l.Add(11);
        l.Add(23);
        l.Add(36);
        l.Add(45);
        l.Add(80);
        l.Add(60);
        l.Add(40);
        l.Add(6);

        for(int i = 0; i < l.Count / 2; i++) {
            int temp = l[i];
            l[i] = l[l.Count - 1 - i];
            l[l.Count - 1 - i] = temp;
        }

        foreach(var i in l) {
            Console.WriteLine(i);
        }
    }


    /// <summary>
    /// 有数据类型为整形的顺序表La和Lb，其数据元素均按从小到大的升序排列。
    /// 编写一个算法将它们合并成一个表Lc，要求Lc中数据元素也按升序排列。
    /// 1,2,5,7
    /// 3,4,6,8,9
    /// </summary>
    [TestMethod]
    public void Merge() {
        SequenceList<int> la = new SequenceList<int>();
        la.Add(1);
        la.Add(2);
        la.Add(5);
        la.Add(7);

        SequenceList<int> lb = new SequenceList<int>();
        lb.Add(3);
        lb.Add(4);
        lb.Add(6);
        lb.Add(8);
        lb.Add(9);

        int aIndex = 0;
        int bIndex = 0;

        SequenceList<int> lc = new SequenceList<int>();

        while(aIndex < la.Count && bIndex < lb.Count) {
            if(la[aIndex] <= lb[bIndex]) {
                lc.Add(la[aIndex]);
                aIndex++;
            }
            else {
                lc.Add(lb[bIndex]);
                bIndex++;
            }
        }

        while(aIndex < la.Count) {
            lc.Add(la[aIndex]);
            aIndex++;
        }

        while(bIndex < lb.Count) {
            lc.Add(lb[bIndex]);
            bIndex++;
        }

        foreach(var i in lc) {
            Console.WriteLine(i);
        }
    }

    /// <summary>
    /// 已知一个存储整数的顺序表La，试构造顺序表Lb，要求顺序表Lb中只包含顺序表La中所有值不相同的数据元素。
    /// 11，23，23，36，45，36，80，11，60，40，6, 6
    /// </summary>
    [TestMethod]
    public void Purge() {
        SequenceList<int> la = new SequenceList<int>();
        la.Add(11);
        la.Add(23);
        la.Add(23);
        la.Add(36);
        la.Add(45);
        la.Add(36);
        la.Add(80);
        la.Add(11);
        la.Add(60);
        la.Add(40);
        la.Add(6);
        la.Add(6);

        SequenceList<int> lb = new SequenceList<int>();
        lb.Add(la[0]);
        for(int i = 1; i < la.Count; i++) {
            int j = 0;
            for(; j < lb.Count; j++) {
                if(la[i] == lb[j]) {
                    break;
                }
            }
            if(j == lb.Count) {
                lb.Add(la[i]);
            }
        }

        foreach(var i in lb) {
            Console.WriteLine(i);
        }
    }

}

链表

链式存储，这样的线性表叫链表（Lnked List）。链表不要求逻辑上相邻的数据元素在物理存储位置上也相邻，因此，在对链表进行插入和删除时不需要移动数据元素，但同时也失去了顺序表可随机存储的优点。

单链表实现：

public class OneWayNode<T> {
    private OneWayNode<T> _next;
    private T _value;

    public OneWayNode() : this(default(T), null) {
    }

    public OneWayNode(T value) : this(value, null) {
    }

    public OneWayNode(T value, OneWayNode<T> next) {
        this._value = value;
        this._next = next;
    }

    public OneWayNode<T> Next {
        get { return this._next; }
        set { this._next = value; }
    }

    public T Value {
        get { return this._value; }
        set { this._value = value; }
    }
}

public class OneWayLinkList<T> : IList<T> {
    private OneWayNode<T> _head;

    #region Implementation of IEnumerable

    public IEnumerator<T> GetEnumerator() {
        OneWayNode<T> node = this.Head;
        while(node!=null) {
            yield return node.Value;
            node = node.Next;
        }
    }

    IEnumerator IEnumerable.GetEnumerator() {
        return GetEnumerator();
    }

    #endregion

    #region Implementation of IList<T>

    /// <summary>
    /// 列表长度
    /// </summary>
    public int Count {
        get {
            int count = 0;
            OneWayNode<T> node = this._head;
            while(node!=null) {
                count++;
                node = node.Next;
            }
            return count;
        }
    }

    /// <summary>
    /// 清空列表
    /// </summary>
    public void Clear() {
        this._head = null;
    }

    /// <summary>
    /// 判断是否为空
    /// </summary>
    public bool IsEmpty {
        get { return this.Head == null; }
    }

    public OneWayNode<T> Head {
        get { return this._head; }
        set { this._head = value; }
    }

    /// <summary>
    /// 添加一个数据项至列表尾部
    /// </summary>
    /// <param name="value">插入项</param>
    public void Add(T value) {
        if(this.Head == null) {
            this.Head = new OneWayNode<T>(value);
            return;
        }
        OneWayNode<T> node = this.Head;
        while(node.Next!=null) {
            node = node.Next;
        }
        node.Next = new OneWayNode<T>(value);
    }

    /// <summary>
    /// 在指定位置插入一个数据项
    /// </summary>
    /// <param name="value">数据项</param>
    /// <param name="index">位置</param>
    public void Insert(T value, int index) {
        CheckIndex(index);
        if(index==0) {
            this._head = new OneWayNode<T>(value, this._head);
            return;
        }

        OneWayNode<T> prev = this._head;
        OneWayNode<T> next = this._head.Next;
        int tempIndex = 1;
        while(tempIndex<index) {
            prev = next;
            next = next.Next;
            tempIndex++;
        }
        prev.Next = new OneWayNode<T>(value, next);
    }

    private void CheckIndex(int index) {
        if(index<0 || index>=Count) {
            throw new ArgumentException("不正确的位置。");
        }
    }

    /// <summary>
    /// 删除指定位置的数据项
    /// </summary>
    /// <param name="index">位置</param>
    public void Delete(int index) {
        if(index==0) {
            this._head = this._head.Next;
            return;
        }
        OneWayNode<T> prev = this._head;
        OneWayNode<T> next = this._head.Next;
        int tempIndex = 1;
        while(tempIndex < index) {
            prev = next;
            next = next.Next;
            tempIndex++;
        }
        prev.Next = next.Next;
    }

    /// <summary>
    /// 获取指定位置的数据项
    /// </summary>
    /// <param name="index">位置</param>
    /// <returns>数据项</returns>
    public T this[int index] {
        get {
            OneWayNode<T> current = GetItem(index);
            return current.Value;
        }
        set {
            OneWayNode<T> current = GetItem(index);
            current.Value = value;
        }
    }

    private OneWayNode<T> GetItem(int index) {
        OneWayNode<T> current = this.Head;
        int tempIndex = 0;
        while(tempIndex < index) {
            current = current.Next;
            tempIndex++;
        }
        return current;
    }

    #endregion
}

单链表测试：

[TestClass]
public class OneWayLinkListTest {
    /// <summary>
    /// 已知顺序表L，写一算法将其倒置
    /// 11，23，36，45，80，60，40，6
    /// </summary>
    [TestMethod]
    public void Revers() {
        OneWayLinkList<int> l = new OneWayLinkList<int>();
        l.Add(11);
        l.Add(23);
        l.Add(36);
        l.Add(45);
        l.Add(80);
        l.Add(60);
        l.Add(40);
        l.Add(6);

        OneWayNode<int> node = l.Head;
        l.Head = null;
        while(node != null) {
            OneWayNode<int> next = node.Next;
            node.Next = l.Head;
            l.Head = node;
            node = next;
        }

        foreach(var i in l) {
            Console.WriteLine(i);
        }
    }


    /// <summary>
    /// 有数据类型为整形的顺序表La和Lb，其数据元素均按从小到大的升序排列。
    /// 编写一个算法将它们合并成一个表Lc，要求Lc中数据元素也按升序排列。
    /// 1,2,5,7
    /// 3,4,6,8,9
    /// </summary>
    [TestMethod]
    public void Merge() {
        OneWayLinkList<int> la = new OneWayLinkList<int>();
        la.Add(1);
        la.Add(2);
        la.Add(5);
        la.Add(7);

        OneWayLinkList<int> lb = new OneWayLinkList<int>();
        lb.Add(3);
        lb.Add(4);
        lb.Add(6);
        lb.Add(8);
        lb.Add(9);

        OneWayNode<int> aNode = la.Head;
        OneWayNode<int> bNode = lb.Head;

        OneWayLinkList<int> lc = new OneWayLinkList<int>();


        while(aNode != null && bNode != null) {
            if(aNode.Value <= bNode.Value) {
                lc.Add(aNode.Value);
                aNode = aNode.Next;
            }
            else {
                lc.Add(bNode.Value);
                bNode = bNode.Next;
            }
        }

        while(aNode != null) {
            lc.Add(aNode.Value);
            aNode = aNode.Next;
        }

        while(bNode != null) {
            lc.Add(bNode.Value);
            bNode = bNode.Next;
        }

        foreach(var i in lc) {
            Console.WriteLine(i);
        }
    }

    /// <summary>
    /// 已知一个存储整数的顺序表La，试构造顺序表Lb，要求顺序表Lb中只包含顺序表La中所有值不相同的数据元素。
    /// 11，23，23，36，45，36，80，11，60，40，6, 6
    /// </summary>
    [TestMethod]
    public void Purge() {
        OneWayLinkList<int> la = new OneWayLinkList<int>();
        la.Add(11);
        la.Add(23);
        la.Add(23);
        la.Add(36);
        la.Add(45);
        la.Add(36);
        la.Add(80);
        la.Add(11);
        la.Add(60);
        la.Add(40);
        la.Add(6);
        la.Add(6);

        OneWayLinkList<int> lb = new OneWayLinkList<int>();

        lb.Add(la.Head.Value);
        OneWayNode<int> aNode = la.Head.Next;

        while(aNode!=null) {
            OneWayNode<int> bNode = lb.Head;
            while(bNode!=null) {
                if(aNode.Value==bNode.Value) {
                    break;
                }
                bNode = bNode.Next;
            }
            if(bNode==null) {
                lb.Add(aNode.Value);
            }
            aNode = aNode.Next;
        }

        foreach(var i in lb) {
            Console.WriteLine(i);
        }
    }
}

双链表实现：

public class TwoWayNode<T> {
    private TwoWayNode<T> _next;
    private TwoWayNode<T> _prev;
    private T _value;

    public TwoWayNode() : this(default(T), null, null) {

    }

    public TwoWayNode(T value)
        : this(value, null, null) {

    }

    public TwoWayNode(T value, TwoWayNode<T> prev, TwoWayNode<T> next) {
        this._value = value;
        this._prev = prev;
        this._next = next;
    }

    public TwoWayNode<T> Next {
        get { return this._next; }
        set { this._next = value; }
    }

    public TwoWayNode<T> Previous {
        get { return this._prev; }
        set { this._prev = value; }
    }

    public T Value {
        get { return this._value; }
        set { this._value = value; }
    }
}

public class TwoWayLinkList<T> : IList<T> {
    private TwoWayNode<T> _head;

    #region Implementation of IEnumerable

    public IEnumerator<T> GetEnumerator() {
        TwoWayNode<T> node = this.Head;
        while(node != null) {
            yield return node.Value;
            node = node.Next;
        }
    }

    IEnumerator IEnumerable.GetEnumerator() {
        return GetEnumerator();
    }

    #endregion

    #region Implementation of IList<T>

    /// <summary>
    /// 列表长度
    /// </summary>
    public int Count {
        get {
            int count = 0;
            TwoWayNode<T> node = this._head;
            while(node != null) {
                count++;
                node = node.Next;
            }
            return count;
        }
    }

    /// <summary>
    /// 清空列表
    /// </summary>
    public void Clear() {
        this._head = null;
    }

    /// <summary>
    /// 判断是否为空
    /// </summary>
    public bool IsEmpty {
        get { return this.Head == null; }
    }

    public TwoWayNode<T> Head {
        get { return this._head; }
        set { this._head = value; }
    }

    /// <summary>
    /// 添加一个数据项至列表尾部
    /// </summary>
    /// <param name="value">插入项</param>
    public void Add(T value) {
        if(this.Head == null) {
            this.Head = new TwoWayNode<T>(value);
            return;
        }
        TwoWayNode<T> node = this.Head;
        while(node.Next != null) {
            node = node.Next;
        }
        node.Next = new TwoWayNode<T>(value, node, null);
    }

    /// <summary>
    /// 在指定位置插入一个数据项
    /// </summary>
    /// <param name="value">数据项</param>
    /// <param name="index">位置</param>
    public void Insert(T value, int index) {
        CheckIndex(index);
        if(index == 0) {
            this._head = new TwoWayNode<T>(value, null, this._head);
            return;
        }

        TwoWayNode<T> current = this.GetItem(index);
        current.Previous.Next = current.Next.Previous = new TwoWayNode<T>(value, current.Previous, current.Next);
    }

    private void CheckIndex(int index) {
        if(index < 0 || index >= Count) {
            throw new ArgumentException("不正确的位置。");
        }
    }

    /// <summary>
    /// 删除指定位置的数据项
    /// </summary>
    /// <param name="index">位置</param>
    public void Delete(int index) {
        if(index == 0) {
            this._head = this._head.Next;
            return;
        }
        TwoWayNode<T> current = this.GetItem(index);
        current.Previous.Next = current.Next;
        current.Next.Previous = current.Previous;
    }

    /// <summary>
    /// 获取指定位置的数据项
    /// </summary>
    /// <param name="index">位置</param>
    /// <returns>数据项</returns>
    public T this[int index] {
        get {
            TwoWayNode<T> current = GetItem(index);
            return current.Value;
        }
        set {
            TwoWayNode<T> current = GetItem(index);
            current.Value = value;
        }
    }

    private TwoWayNode<T> GetItem(int index) {
        TwoWayNode<T> current = this.Head;
        int tempIndex = 0;
        while(tempIndex < index) {
            current = current.Next;
            tempIndex++;
        }
        return current;
    }

    #endregion
}

双链表测试：

[TestClass]
public class TwoWayLinkListTest {
    /// <summary>
    /// 已知顺序表L，写一算法将其倒置
    /// 11，23，36，45，80，60，40，6
    /// </summary>
    [TestMethod]
    public void Revers() {
        TwoWayLinkList<int> l = new TwoWayLinkList<int>();
        l.Add(11);
        l.Add(23);
        l.Add(36);
        l.Add(45);
        l.Add(80);
        l.Add(60);
        l.Add(40);
        l.Add(6);

        TwoWayNode<int> node = l.Head;
        l.Head = null;
        while(node != null) {
            TwoWayNode<int> next = node.Next;
            node.Next = l.Head;
            l.Head = node;
            node = next;
        }

        foreach(var i in l) {
            Console.WriteLine(i);
        }
    }


    /// <summary>
    /// 有数据类型为整形的顺序表La和Lb，其数据元素均按从小到大的升序排列。
    /// 编写一个算法将它们合并成一个表Lc，要求Lc中数据元素也按升序排列。
    /// 1,2,5,7
    /// 3,4,6,8,9
    /// </summary>
    [TestMethod]
    public void Merge() {
        TwoWayLinkList<int> la = new TwoWayLinkList<int>();
        la.Add(1);
        la.Add(2);
        la.Add(5);
        la.Add(7);

        TwoWayLinkList<int> lb = new TwoWayLinkList<int>();
        lb.Add(3);
        lb.Add(4);
        lb.Add(6);
        lb.Add(8);
        lb.Add(9);

        TwoWayNode<int> aNode = la.Head;
        TwoWayNode<int> bNode = lb.Head;

        TwoWayLinkList<int> lc = new TwoWayLinkList<int>();


        while(aNode != null && bNode != null) {
            if(aNode.Value <= bNode.Value) {
                lc.Add(aNode.Value);
                aNode = aNode.Next;
            }
            else {
                lc.Add(bNode.Value);
                bNode = bNode.Next;
            }
        }

        while(aNode != null) {
            lc.Add(aNode.Value);
            aNode = aNode.Next;
        }

        while(bNode != null) {
            lc.Add(bNode.Value);
            bNode = bNode.Next;
        }

        foreach(var i in lc) {
            Console.WriteLine(i);
        }
    }

    /// <summary>
    /// 已知一个存储整数的顺序表La，试构造顺序表Lb，要求顺序表Lb中只包含顺序表La中所有值不相同的数据元素。
    /// 11，23，23，36，45，36，80，11，60，40，6, 6
    /// </summary>
    [TestMethod]
    public void Purge() {
        TwoWayLinkList<int> la = new TwoWayLinkList<int>();
        la.Add(11);
        la.Add(23);
        la.Add(23);
        la.Add(36);
        la.Add(45);
        la.Add(36);
        la.Add(80);
        la.Add(11);
        la.Add(60);
        la.Add(40);
        la.Add(6);
        la.Add(6);

        TwoWayLinkList<int> lb = new TwoWayLinkList<int>();

        lb.Add(la.Head.Value);
        TwoWayNode<int> aNode = la.Head.Next;

        while(aNode!=null) {
            TwoWayNode<int> bNode = lb.Head;
            while(bNode!=null) {
                if(aNode.Value==bNode.Value) {
                    break;
                }
                bNode = bNode.Next;
            }
            if(bNode==null) {
                lb.Add(aNode.Value);
            }
            aNode = aNode.Next;
        }

        foreach(var i in lb) {
            Console.WriteLine(i);
        }
    }
}