博客园_文野

数据结构（C#语言版）——栈和队列

2011-01-16T12:35:00Z

栈和队列是计算机中常用的两种数据结构，是操作受限的线性表。栈的插入和删除等操作都在栈顶进行，它是先进后出的线性表。队列的删除、查找等操作在队头进行，而插入操作在队尾进行，它是先进先出的线性表。与线性表一样，栈和队列也有顺序存储与链式存储两种方式。

栈

        1: public interface IStack<T> {

       2:     /// <summary>

       3:     /// 获取栈的长度

       4:     /// </summary>

       5:     int Count { get; }

       6:  

       7:     /// <summary>

       8:     /// 清空栈

       9:     /// </summary>

      10:     void Clear();

      11:  

      12:     /// <summary>

      13:     /// 将一个数据压入栈

      14:     /// </summary>

      15:     /// <param name="value"></param>

      16:     void Push(T value);

      17:  

      18:     /// <summary>

      19:     /// 将一个数据弹出栈

      20:     /// </summary>

      21:     /// <returns></returns>

      22:     T Pop();

      23:  

      24:     /// <summary>

      25:     /// 获取栈顶部的数据，但不弹出

      26:     /// </summary>

      27:     /// <returns></returns>

      28:     T Peek();

      29: }

顺序栈


       1: public class SequenceStack<T> : IStack<T> {

       2:     private const int Step = 16;

       3:     private int _capacity;

       4:     private int _top = -1;

       5:     private T[] _datas;

       6:  

       7:     public SequenceStack() : this(Step) {}

       8:  

       9:     public SequenceStack(int capacity) {

        this._capacity = capacity;

        this._datas = new T[this._capacity];

    }

  

    public int Count {

        get { return this._top + 1; }

    }

  

    public void Clear() {

        this._top = -1;

    }

  

    public void Push(T value) {

        if(this._top+1>=this._datas.Length) {

            this._capacity += Step;

            T[] temps = new T[this._capacity];

            for(int i = 0; i < this._datas.Length; i++) {

                temps[i] = this._datas[i];

            }

            this._datas = temps;

        }

        this._datas[++this._top] = value;

    }

  

    public T Pop() {

        return this._datas[this._top--];

    }

  

    public T Peek() {

        return this._datas[this._top];

    }

}

链栈


       1: public class StackNode<T> {

       2:     private StackNode<T> _next;

       3:     private T _value;

       4:  

       5:     public StackNode() : this(default(T), null) {

       6:     }

       7:  

       8:     public StackNode(T value) : this(value, null) {

       9:     }

      10:  

      11:     public StackNode(T value, StackNode<T> next) {

      12:         this._value = value;

      13:         this._next = next;

      14:     }

      15:  

      16:     public StackNode<T> Next {

      17:         get { return this._next; }

      18:         set { this._next = value; }

      19:     }

      20:  

      21:     public T Value {

      22:         get { return this._value; }

      23:         set { this._value = value; }

      24:     }

      25: }


       1: public class LinkStack<T> : IStack<T> {

       2:     private int _count = 0;

       3:     StackNode<T> _top;

       4:  

       5:     public int Count {

       6:         get { return this._count; }

       7:     }

       8:  

       9:     public void Clear() {

      10:         this._top = null;

      11:         this._count = 0;

      12:     }

      13:  

      14:     public void Push(T value) {

      15:         this._top=new StackNode<T>(value, this._top);

      16:         this._count++;

      17:     }

      18:  

      19:     public T Pop() {

      20:         T result = this._top.Value;

      21:         this._top = this._top.Next;

      22:         this._count--;

      23:         return result;

      24:     }

      25:  

      26:     public T Peek() {

      27:         return this._top.Value;

      28:     }

      29: }

队列


       1: public interface IQueue<T> {

       2:     /// <summary>

       3:     /// 获取队列的长度

       4:     /// </summary>

       5:     int Count { get; }

       6:  

       7:     /// <summary>

       8:     /// 清空队列

       9:     /// </summary>

      10:     void Clear();

      11:  

      12:     /// <summary>

      13:     /// 一个数据进入队列

      14:     /// </summary>

      15:     /// <param name="value"></param>

      16:     void Add(T value);

      17:  

      18:     /// <summary>

      19:     /// 一个数据弹出队列

      20:     /// </summary>

      21:     /// <returns></returns>

      22:     T Dequeue();

      23:  

      24:     /// <summary>

      25:     /// 获取最前面的数据，但不出队列

      26:     /// </summary>

      27:     /// <returns></returns>

      28:     T Peek();

      29: }

顺序队列


       1: public class SequenceQueue<T> : IQueue<T> {

       2:     private const int Step = 16;

       3:     private int _capacity;

       4:     private int _front = -1;

       5:     private int _rear = -1;

       6:     private T[] _datas;

       7:  

       8:     public SequenceQueue() : this(Step) { }

       9:  

    public SequenceQueue(int capacity) {

        this._capacity = capacity;

        this._datas = new T[this._capacity];

    }

  

    public int Count {

        get {

            if(this._front==-1 && this._rear==-1) {

                return 0;

            }

            if(this._front <= this._rear) {

                return this._rear - this._front + 1;

            }

            return this._datas.Length - this._front + this._rear + 1;

        }

    }

  

    public void Clear() {

        this._front = -1;

        this._rear = -1;

    }

  

    public void Add(T value) {

        if(this.Count==this._datas.Length) {

            this._capacity += Step;

            T[] temps = new T[this._capacity];

            for(int i = 0; i < this._datas.Length; i++) {

                temps[i] = this.Dequeue();

            }

            this._datas = temps;

            this._front = 0;

            this._rear = this._datas.Length - 1;

        }

        if(this._rear+1==this._datas.Length) {

            this._rear = 0;

        }

        else {

            this._rear++;

        }

        this._datas[this._rear] = value;

    }

  

    public T Dequeue() {

        if(this.Count==0) {

            throw new Exception("Queue is Empty");

        }

        T result = this._datas[this._front];

        if(this.Count==1) {

            this._front = -1;

            this._rear = -1;

        }

        else {

            if(this._front+1==this._datas.Length) {

                this._front = 0;

            }

            else {

                this._front++;

            }

        }

        return result;

    }

  

    public T Peek() {

        if(this.Count == 0) {

            throw new Exception("Queue is Empty");

        }

        return this._datas[this._front];

    }

}

链队列


       1: public class QueueNode<T> {

       2:     private QueueNode<T> _next;

       3:     private T _value;

       4:  

       5:     public QueueNode() : this(default(T), null) {

       6:     }

       7:  

       8:     public QueueNode(T value) : this(value, null) {

       9:     }

      10:  

      11:     public QueueNode(T value, QueueNode<T> next) {

      12:         this._value = value;

      13:         this._next = next;

      14:     }

      15:  

      16:     public QueueNode<T> Next {

      17:         get { return this._next; }

      18:         set { this._next = value; }

      19:     }

      20:  

      21:     public T Value {

      22:         get { return this._value; }

      23:         set { this._value = value; }

      24:     }

      25: }


       1: public class LinkQueue<T> : IQueue<T> {

       2:     private int _count = 0;

       3:     private QueueNode<T> _front;

       4:     private QueueNode<T> _rear;

       5:  

       6:     public int Count {

       7:         get { return _count; }

       8:     }

       9:  

    public void Clear() {

        this._count = 0;

    }

  

    public void Add(T value) {

        QueueNode<T> node = new QueueNode<T>(value);

        if(this._count==0) {

            this._front = this._rear = node;

        }

        else {

            this._rear.Next = node;

            this._rear = node;

        }

        this._count++;

    }

  

    public T Dequeue() {

        if(this.Count == 0) {

            throw new Exception("Queue is Empty");

        }

        T result = this._front.Value;

        this._front = this._front.Next;

        this._count--;

        return result;

    }

  

    public T Peek() {

        if(this.Count == 0) {

            throw new Exception("Queue is Empty");

        }

        return this._front.Value;

    }

}

本文链接

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

2011-01-09T12:48:00Z

线性表

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

        1: /// <summary>

       2: /// 线性表的基本操作接口

       3: /// 线性表(List)：由n(n>=0)个相同类型的数据元素构成的有限序列。

       4: /// 简记L=(D，R) D：数据元素的有限集合；R：数据元素之间关系的有限集合。

       5: /// </summary>

       6: /// <typeparam name="T">元素类型</typeparam>

       7: public interface IList<T>: IEnumerable<T> {

       8:     /// <summary>

       9:     /// 列表长度

    /// </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; }

}

顺序表

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

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

顺序表实现：


       1: public class SequenceList<T> : IList<T> {

       2:     private const int Step = 16;

       3:     private int _capacity;

       4:     private T[] _datas;

       5:     private int _last = -1;

       6:  

       7:     public SequenceList() : this(Step) {}

       8:  

       9:     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

}

顺序表测试：


       1: [TestClass]

       2: public class SequenceListTest {

       3:     /// <summary>

       4:     /// 已知顺序表L，写一算法将其倒置

       5:     /// 11，23，36，45，80，60，40，6

       6:     /// </summary>

       7:     [TestMethod]

       8:     public void Revers() {

       9:         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）。链表不要求逻辑上相邻的数据元素在物理存储位置上也相邻，因此，在对链表进行插入和删除时不需要移动数据元素，但同时也失去了顺序表可随机存储的优点。

单链表实现：


       1: public class OneWayNode<T> {

       2:     private OneWayNode<T> _next;

       3:     private T _value;

       4:  

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

       6:     }

       7:  

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

       9:     }

      10:  

      11:     public OneWayNode(T value, OneWayNode<T> next) {

      12:         this._value = value;

      13:         this._next = next;

      14:     }

      15:  

      16:     public OneWayNode<T> Next {

      17:         get { return this._next; }

      18:         set { this._next = value; }

      19:     }

      20:  

      21:     public T Value {

      22:         get { return this._value; }

      23:         set { this._value = value; }

      24:     }

      25: }


       1: public class OneWayLinkList<T> : IList<T> {

       2:     private OneWayNode<T> _head;

       3:  

       4:     #region Implementation of IEnumerable

       5:  

       6:     public IEnumerator<T> GetEnumerator() {

       7:         OneWayNode<T> node = this.Head;

       8:         while(node!=null) {

       9:             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

}

单链表测试：


       1: [TestClass]

       2: public class OneWayLinkListTest {

       3:     /// <summary>

       4:     /// 已知顺序表L，写一算法将其倒置

       5:     /// 11，23，36，45，80，60，40，6

       6:     /// </summary>

       7:     [TestMethod]

       8:     public void Revers() {

       9:         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);

        }

    }

}

双链表实现：


       1: public class TwoWayNode<T> {

       2:     private TwoWayNode<T> _next;

       3:     private TwoWayNode<T> _prev;

       4:     private T _value;

       5:  

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

       7:         

       8:     }

       9:  

    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; }

    }

}


       1: public class TwoWayLinkList<T> : IList<T> {

       2:     private TwoWayNode<T> _head;

       3:  

       4:     #region Implementation of IEnumerable

       5:  

       6:     public IEnumerator<T> GetEnumerator() {

       7:         TwoWayNode<T> node = this.Head;

       8:         while(node != null) {

       9:             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

}

双链表测试：


       1: [TestClass]

       2: public class TwoWayLinkListTest {

       3:     /// <summary>

       4:     /// 已知顺序表L，写一算法将其倒置

       5:     /// 11，23，36，45，80，60，40，6

       6:     /// </summary>

       7:     [TestMethod]

       8:     public void Revers() {

       9:         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);

        }

    }

}

本文链接

2011一月的三个故事

2011-01-03T06:23:00Z

有时仔细想想，周金根的这种敏捷个人中所提倡的三个故事，无论是每年的、每月的、每周的还是每日的，真是又简单又难啊。简单，不就想三个故事嘛，甚至不用想，张口就能来，真是太简单了。难，太难了，因为这三个故事需要是我想要的，可达的，而且是不流于形式，如果我每次都写吃饭、睡觉外加创造人类，那也就没意义了。

我想我可以这么理解，每年的三个故事，是我一年的愿景、愿望，如果我愿意，还可以写个五年的三个故事；每月的三个故事是为达每年愿景分解后的目标，相对清晰化了；每周的三个故事，是为达每月的目标制定的具体计划；每天的三个故事就不用说了，具体实施。

我还真怕每次写这三个故事时写得一模一样，或差不多，不过不管怎么样，不要流于形式就好。

企业应用，工作流为王

在企业应用中，工作流是必不可少的一块。以前虽接触过一些工作流的应用，但都是在系统已有的工作流引擎的基础上进行配置应用，如果想深入对工作流理解及编写工作流引擎组件，WF是个不错的起点。

算法，从数据结构开始

从学写程序开始，到现在就没接触过算法。当在这个领域不断地深入下去，不断地学习研究，越发觉得算法的重要。我不仅要会写程序，还要写好程序。我的算法之旅，从数据结构开始。

Asp.net底层的那些东西

六年的B/S架构开发，六年的Asp.net应用，却对于Asp.net底层的、内部的那些机制不甚了了。在学习MVC之前把它们搞清楚，知其然也要知其所以然。Asp.net，从一个请求开始……

补充，也是给自己的提醒。

当目标确定后，其实每天、每周、每月干的都是一样的事，经历的是一样的过程。所以，这里的三个故事是对自己主要学习目标的一个确定，是如何安排好自己的学习与生活的。而在这之外，工作的，学习的，还有好多，比如准备一个星期学习一个设计模式、每个星期四节英语课、上下班地铁上看的书，罗列这些也无甚意义。

这里列的三个故事，就对学习、生活优先级比较高的三个故事，也是为了更好安排好自己，不要给自己太多安排，而搞得身心疲惫。

本文链接

我想要的2011

2011-01-02T09:42:00Z

生活看板

我不太会用图片处理工具，而且我觉得图片会分散我的注意力，我就建个我文字版的生活看板。

老婆、儿子，你们就是我的全部。我爱你们。I love you all。
架构师，你将离我不再遥远。
面向对象、领域驱动，那是信仰。
基础开发框架，你能证明我的Power。
做一个真正.Net下的Coder，好好学习，天天向上。
设计模式、架构模式、分析方法、UML
CLR、Asp.net、MVC
Linq、WF、WCF
Enterprise Library、NHibernate、Spring.net
数据库、JavaScript、Xml
一份好的工作，一份五位数的薪资，是我个人价值的证明。
English！English！English！
用博客分享我的心得，包装自己。
我是红魔死忠。

约束？！提醒？！反正是给自己的，做最好的自己，这不会有错……

保证睡眠，十一点前必须上床睡觉。红魔的比赛算个例外，呵呵。
每周只在周六收一次RSS订阅，并立即处理有价值的内容。
每天只浏览一次新闻，不要超过半小时。
认真对待工作，把每件事都做好，把每行代码都写好。因为实践后的积累都是自己的。
注意调整好自己的状态、心态，轻松的生活、轻松的学习、轻松的工作比什么都强。

本文链接

我的2011的三个故事

2011-01-02T03:37:00Z

坚持写博客，学习自我管理
随着年龄的增长，越发觉得自我管理的重要。我以前的工作、学习、生活，最大的两个问题就是无计划与不能坚持下来。
我要让自己变得有条理，学会坚持，把坚持的东西变成一种习惯，这不仅对我的工作、学习、生活产生助益，以后对洋洋也能产生正面的影响。父亲是儿子最好的老师嘛。
博客从注册之日起就一直想写的，把自己学的、用的、想的记录下来。但就象前面所讲，一直没能坚持下来。作为自我管理练习的一部分，就从坚持写博开始，也可让我的博客成为推销自己的一张名片。
学完新概念二册的英语
工作了那么多年后才发现英语是如此重要，在技术提高的同时，我要让英语成为我的另外一个突破口。
学英语是个循序渐进的过程，我要：第一，不急不躁；第二，合理稳定的学习计划。
2011，我要学完新概念英语一册剩下的部分及新概念英语二册，并能在工作生活中应用起来。
学英语，重在坚持。
打一个扎实的技术基础，掌握需求分析、架构设计的方法，开发一个基础框架
虽然已经做了六年的开发，但对很多技术，特别是很多基础，还是停留在一个比较肤浅的层面。所以2011，首要的是让自己打一个扎实的基础。这些基础技术包括设计模式、算法、.net（CLR的方方面面、Asp.net、Asp.net MVC、WCF、WF、Linq)、数据库、JavaScript、XML……。补好“腰”，不再让自己心有余而力不足。
我的职业目标是要成为个架构师，自己研究的方向定位在从需求分析到架构设计再到开发这几个阶段。2011，让自己明白什么是架构，怎样才能成为架构师，以领域驱动为主线，研究、学习、实践需求分析、架构设计的方法，并总结出一套自己分析、架构系统的方法。多“锻炼”，才能使自己更强大。
无论是基础知识的学习，还是架构的研究，最终都需要转换成代码，转换成可用的产品。框架学习、开发过程中最大的问题其实是注意力分散，所以首要让自己集中注意力。2011，学习三个开源框架（Enterprise Library、NHibernate、Spring.net），其它一律无视。按照介绍框架的那几本书，参考其它系统、总结自己的学习研究心得，开发一套基础开发框架。

本文链接

《悟透JavaScript》中的知识点

2010-10-26T06:53:00Z

简单的数据类型只有undefined, null, boolean, number和string。

typeof(undefined)返回的也是undefined。

typeof(null)返回object，但null并非object，具有null值的变量也并非object。

typeof(NaN)和typeof(Infinity)都返回Number。NaN参与任何数值计算的结果都是NaN，而且NaN!=NaN，Infinity/Infinity=NaN。

JavaScript里“===”表示“全等”，也就是数据值与数据类型都必须相等才是true。如undefined==null、”123”==123是true，但undefined===null、”123”===123是false。

JavaScript函数只是一个命了名的变量，变量类型即为function，变量的值就是我们编写的函数代码体。所以下面两段代码除了一点细微的差别，其内部实现完全相同。

定义式

   1: <script type="text/javascript">

   2:     function myfunc(){

   3:         alert("hello");

   4:     }

   5:     alert(typeof myfunc);

   6: </script>

变量式

   1: <script type="text/javascript">

   2:     var myfunc = function(){

   3:         alert("hello");

   4:     }

   5:     alert(typeof myfunc);

   6: </script>

细微的差别在于，Javascript执行引擎并非一行一行地分析和执行程序，而是一段一段地分析执行的。而且，在同一段程序的分析执行中，定义式的函数语句会被提取出来优先执行。函数定义执行完之后，才会按顺序执行其他语句代码。也就是说，两个相同函数名的定义式的函数在同一段程序中时，第一个函数将被第二个函数覆盖，所以代码段中所有调用此函数的地方执行的都是第二个函数定义中的语句。

   1: <script type="text/javascript">

   2:     var myfunc = function(){

   3:         alert("hello");

   4:     }

   5:     myfunc();

   6:     myfunc = function(){

   7:         alert('yeah');

   8:     }

   9:     myfunc();

  10: </script>

结果：第一个弹出“hello”，第二个弹出“yeah”。

   1: <script type="text/javascript">

   2:     function myfunc(){

   3:         alert("hello");

   4:     }

   5:     myfunc();

   6:     function myfunc(){

   7:         alert('yeah');

   8:     }

   9:     myfunc();

  10: </script>

结果：两个都弹出“yeah”。

   1: <script type="text/javascript">

   2:     function myfunc(){

   3:         alert("hello");

   4:     }

   5:     myfunc();

   6: </script>

   7: <script type="text/javascript">

   8:     function myfunc(){

   9:         alert('yeah');

  10:     }

  11:     myfunc();

  12: </script>

结果：第一个弹出“hello”，第二个弹出“yeah”。

在JavaScript里的全局环境就是一个对象，这个对象是JavaScript运行环境的根。对于浏览器中的JavaScript来说，这个根对象就是window对象。对于全局的JavaScript来说，window对象就相当于当前作用域。

“var”定义的是作用域上的一个变量，而没有“var”的标识符却可能是全局根对象的一个属性。

当代码运行进入一个函数时，JavaScript会创建一个新的作用域，来作为当前作用域的子域，然后切换至这个新建的子作用域，开始执行函数逻辑。

本文链接

用Windows Live Writer写博客

2010-10-11T04:23:00Z

简述

Windows Live Writer是一个功能强大的写博客的客户端工具，它几乎可以向所有的日志服务器发布日志。由于文章是在本地编写，所以它能够防止文章在发布时发生内容丢失的情况，同时它还可以方便的进行内容排版、插入图片等。排版完成后点击发布，图片也会一并被传到服务器上。并且Windows Live Writer提供了很方便的插件编写工具，可以自己增加一些希望的功能，网上也有很多非常不错的插件下载。

下载安装

去官网下载Windows Live Writer的在线安装包。

由于官网下载的安装包不支持Windows2003，如果你用的是2003系统，可以下载下面的离线安装包，并根据里面的说明进行安装。

Windows Live Writer 2009 Build 14.0.8050.1202 简体中文版.rar

配置

Windows Live Writer的配置非常简单，看下图：

快捷键

Windows Live Writer的操作就跟使用Word一样，象剪切、撤消、段落与标题的设置、文字的颜色与对齐方式及插入超链接、表格、图片等，非常简单。

下面是一份Windows Live Writer的快捷键列表，写日志时会派上用场。

新建日志 Ctrl + N
新建页面 Ctrl + G
打开 Ctrl + O
保存草稿 Ctrl + S
发布 Ctrl + Shift + P
打印 Ctrl + P
插入链接 Ctrl + K
插入图片 Ctrl + L
检查拼写 F7
普通编辑模式 Ctrl + F11
Web 版式编辑模式 F11
Web 预览 F12
HTML 代码 Shift + F11
日志属性 F2
侧边工具栏 F9

常用插件

Windows Live Writer有很多功能强大的插件，下面是三个我常用的，在上面的离线安装包里有。

屏幕截取插件。

插入代码样式插件。插入的代码样式如下：

            1: using System;

           2:  

           3: public class TestClass{

           4:     public static void HelloPot(){

           5:         Console.WriteLine("Hello, POT");

           6:     }

           7: }

文件插入插件。

本文链接

我们是不是把MVC、ORM等技术的主次颠倒了？

2010-05-11T02:38:00Z

长时间以来，发现很多人，包括自己，在学习新技术时，出现很多本末倒置的现象，MVC与ORM就是两个比较典型的例子。

实现与理论分开。很多时候，理论思想的关注点与实现的关注点不一定是一样的，往往甚至某种思想，实现了某种框架，框架的作用是把边边角角的细节抽象出来，减少开发者在这些细枝末节上的精力，把注意力，精力花在核心思想的实现上。而我们往往去学习某种框架，然后就陷在框架的实现上，而忘了本来框架所支持的思想。

很多技术的名字顺序是非常有意义的。

比如MVC，首要的关注点是模型(M)，其次才是视图(V)。控制器(C)只是用来连接模型与视图的。而我们很多人在视图与控制器上花了大把的精力，但有谁去注意过模型呢，就算有处理模型的，大多也都是在为视图服务，严重的本末倒置。

再来说ORM，这个更严重，甚至可以说很多人的使用就是一个错误。为什么要ORM？是为了解决O与R的阻配失抗。ORM，是对象模型到关系模型的映射。而我们有多少人在使用的所谓ORM是这样吗？很多都是先建表，然后生成对象，那是ORM吗？那应该叫ROM吧？顺序错了，往往就跟这个思想技术的本意相违背了。现在有很多号称强大的代码生成工具，也称全面支持ORM，完全面向对象。但在我看来，领域模型，业务逻辑是不可生成的，可生成的大部分通过抽象也是能得到解决的。我承认这些生成工具的强大，但在生成代码时，请别在说ORM，因为你做的是ROM！

本文链接

论单一职责

2010-04-28T05:27:00Z

对象设计不是关于标准化数据的，它是关于标准化行为的。

职责是什么？职责即对象的行为，而类继承与接口实现的区别是类是 is a 的关系，接口是 can do的关系，所以代表对象职责的应该是接口，而不是类。

这并不是说类就不应该是单一职责的，我们可以创建万能类。只是说，类应该表示一个完整的对象模型，而一个完整的对象模型就可能拥有多个职责，如果完全按照单一职责的原则来实现类，那么就会出现类爆炸以及不完整的现象，我们看到的只是某个模型的一个片段。当然，万能类肯定是不对的。

所以，如何来设计对象与接口，如何确定是否违反单一职责原则，都应该从行为即职责上去判断，不同职责的行为应该被抽象成不同的接口，而可能有几种职责，组成一个完成的对象模型，即类。

本文链接

对象结构

2010-04-23T15:47:00Z

根对象：领域模型中的聚合根。代表了领域模型中一个完整的领域概念，如订单。

子对象：从属于另一个对象（父对象），是父对象的一部分。子对象的生命周期小于等于父对象的生命周期，如订单项。

友元对象（独创概念）：被另一个对象引用的对象称之为友元对象。两个对象之间不存在父子关系，如订单项引用商品，订单引用客户。原则上，友元对象不应受引用友元对象的对象的约束。但根据业务规则，友元对象向外提供规则接口，其它对象可在规则接口基础上挂接业务规则，以影响友元对象的增删查改。引用友元对象的对象保持友元对象的一个主键甚至更多信息。保持友元对象的部分信息是为了使在友元对象在被修改或删除时，保持对象在引用时的完整性，如商品价格，订单项记录的商品价格是在引用商品时的当时价格，即使商品已经删除，订单项也仍然知道当时选择的是什么商品。

友元对象代理：通过引用友元对象的对象中保持的友元对象的信息，创建一个友元对象的代理对象，友元对象代理解决了友元对象延时获取的问题，只有在调用到友元对象的业务方法或其他信息时，才获取友元对象，而友元对象代理上的信息也保证了必要信息及对象结构的完整性。

===========================================================

2010-5-7

友元对象，仅仅是一个用来说明对象图中对象关系的一个概念，就象子对象、父对象等关系，对实现上没有特别限定与要求。友元对象代理，这是针对友元对象在仓储方面而提出的，即使用增加数据库的冗余度，来减少数据库的访问次数。也就是说，在使用友元对象的对象的数据存储表中保存友元对象的主键及其它一些关键信息，使用这些信息在对象被读取时，生成一个友元对象的代理，这个代理包含了这些信息，当真正需要使用友元对象的业务及其它一些信息时，才真正读取友元对象，并替换掉代理。

这说明，在真正领域建模时，描述的是对象图，模型之间的关系，它们是纯粹的。如果内存够大，CPU够快，又不需要网络之间的序列化或数据交换，也不会当机停电之类的，那么也就可以不用仓储，也就没有什么延时加载之类的说法。所以，在设计实现领域模型时，应该是纯粹的，至少尽量不受外界环境污染，为适应外界环境而提出的概念、开发的框架，是对领域模型的辅助，不应该影响领域模型。所以友元对象代理，是为解决频繁数据访问的，它不应该成为领域模型概念的一部分，它最多只仓储框架中实现的一部分。

本文链接