基本数据结构解析之Stack & Queue

Stack:

遵循后进先出原则，最后进来的第一个出去，查看详细(English)，中文

参考代码 CLR/SRC/BCL/System/Stack.cs

构造函数(初始化)

Stack() / Stack(int initialCapacity) / Stack(ICollection col) : this((col==null ? 32 : col.Count))

在Array中采用Object[]作为数据容器，同时会有一个默认的defaultCapbility = 10，如果initialCapacity 小于 defaultCapbility或者没有设置默认的capbility, 则初始化容量为10的Object数组

对应的代码:

private Object[] _array;     // Storage for stack elements
private int _size;           // Number of items in the stack.
private int _version;        // Used to keep enumerator in sync w/ collection.
  
private const int _defaultCapacity = 10;
  
public Stack() {
    _array = new Object[_defaultCapacity];
    _size = 0;
    _version = 0;
}
  
// Create a stack with a specific initial capacity.  The initial capacity
// must be a non-negative number.
public Stack(int initialCapacity) {
    if (initialCapacity < 0)
        throw new ArgumentOutOfRangeException("initialCapacity", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    if (initialCapacity < _defaultCapacity)
        initialCapacity = _defaultCapacity;  // Simplify doubling logic in Push.
    _array = new Object[initialCapacity];
    _size = 0;
    _version = 0;
}

Push/Pop

Push: 如果数据达到最大容量，则分配到容量*2新的数组，并将原来的数据拷贝到新数组, 之后将栈顶设为对应的值，而后栈顶索引自加

// Pushes an item to the top of the stack.
// 
public virtual void Push(Object obj) {
    if (_size == _array.Length) {
        Object[] newArray = new Object[2*_array.Length];
        Array.Copy(_array, 0, newArray, 0, _size);
        _array = newArray;
    }
    _array[_size++] = obj;
    _version++;
}

为了验证内存中的数据是否真如逻辑上所说，我在这里用WINDBG做了一下验证，有兴趣的读者可以去看看。

Pop: 将栈顶设为null, 索引自减

// Pops an item from the top of the stack.  If the stack is empty, Pop
// throws an InvalidOperationException.
public virtual Object Pop() {
    if (_size == 0)
        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EmptyStack"));
    _version++;
    Object obj = _array[--_size];
    _array[_size] = null;     // Free memory quicker.
    return obj;
}

Contains - 按索引进行顺序比较

public virtual bool Contains(Object obj) {
    int count = _size;
  
    while (count-- > 0) {
        if (obj == null) {
            if (_array[count] == null)
                return true;
        }
        else if (_array[count] != null && _array[count].Equals(obj)) {
            return true;
        }
    }
    return false;
}

Clear

public virtual void Clear() {
    Array.Clear(_array, 0, _size); // Don't need to doc this but we clear the elements so that the gc can reclaim the references.
    _size = 0;
    _version++;
}
  
[MethodImplAttribute(MethodImplOptions.InternalCall)]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static extern void Clear(Array array, int index, int length);
  

那Array.Clear调用在

Clone - 深拷贝, 直接复制数据到新的栈数组中

public virtual Object Clone() {
    Stack s = new Stack(_size);
    s._size = _size;
    Array.Copy(_array, 0, s._array, 0, _size);
    s._version = _version;
    return s;
}

Queue:

先进先出，第一个进来的第一个出去, 查看详细(English), 中文

构造函数

// Creates a queue with room for capacity objects. The default initial
// capacity and grow factor are used.
public Queue() 
    : this(32, (float)2.0) {
}
  
// Creates a queue with room for capacity objects. The default grow factor
// is used.
//
public Queue(int capacity) 
    : this(capacity, (float)2.0) {
}
  
// Creates a queue with room for capacity objects. When full, the new
// capacity is set to the old capacity * growFactor.
//
public Queue(int capacity, float growFactor) {
    if (capacity < 0)
        throw new ArgumentOutOfRangeException("capacity", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
    if (!(growFactor >= 1.0 && growFactor <= 10.0))
        throw new ArgumentOutOfRangeException("growFactor", Environment.GetResourceString("ArgumentOutOfRange_QueueGrowFactor", 1, 10));
  
    _array = new Object[capacity];
    _head = 0;
    _tail = 0;
    _size = 0;
    _growFactor = (int)(growFactor * 100);
}

和Array不太一样的是，增加了一个growfactor, 所谓growfactor,是指Array的当前索引到了容量顶峰需要增加的倍数. 比如

Queue q = new Queue(10, 2);
for(int i=0; i<q; i++)
{
    e.EnQueue(i);
}
  
e.EnQueue(3); // The Capbility size will be 20

原理和之前Array的扩张一样，他也会在达到最大容量时，新分配一块扩大之后的大小

Enque

包含两个过程: 1. 检查容量是否达到最大是否有扩容的需要 2. 移动尾部，比较有趣的是 _tail = (_tail + 1) % _array.Length. 说明这个队列是可以循环的 :)

// Adds obj to the tail of the queue.
//
public virtual void Enqueue(Object obj) {
    if (_size == _array.Length) {
        int newcapacity = (int)((long)_array.Length * (long)_growFactor / 100);
        if (newcapacity < _array.Length + _MinimumGrow) {
            newcapacity = _array.Length + _MinimumGrow;
        }
        SetCapacity(newcapacity);
    }
    
    _array[_tail] = obj;
    _tail = (_tail + 1) % _array.Length;
    _size++;
    _version++;
}

DeQueue

设置头节点为空，等待垃圾回收时释放空间。有个问题是: 垃圾回收时这些东西会空的地方是怎么处理的，是建立一个新的队列然后把数据拷贝过去吗？等待后面的验证。。[TODO]

// Removes the object at the head of the queue and returns it. If the queue
// is empty, this method simply returns null.
public virtual Object Dequeue() {
    if (_size == 0)
        throw new InvalidOperationException(Environment.GetResourceString("InvalidOperation_EmptyQueue"));
    
    Object removed = _array[_head];
    _array[_head] = null;
    _head = (_head + 1) % _array.Length;
    _size--;
    _version++;
    return removed;
}

Clear

// Removes all Objects from the queue.
public virtual void Clear() {
    if (_head < _tail)
        Array.Clear(_array, _head, _size);
    else {
        Array.Clear(_array, _head, _array.Length - _head);
        Array.Clear(_array, 0, _tail);
    }
    
    _head = 0;
    _tail = 0;
    _size = 0;
    _version++;
}

Clone 深拷贝

public virtual Object Clone() {
   Queue q = new Queue(_size);
   q._size = _size;
  
   int numToCopy = _size;
   int firstPart = (_array.Length - _head < numToCopy) ? _array.Length - _head : numToCopy;
   Array.Copy(_array, _head, q._array, 0, firstPart);
   numToCopy -= firstPart;
   if (numToCopy > 0)
       Array.Copy(_array, 0, q._array, _array.Length - _head, numToCopy);
  
   q._version = _version;
   return q;
}

未完待续

写着写着觉得越写越多，到这里也算是Stack和Queue的部分结束了，下一篇接着描述List, SortedList, HashTable, Dictionary. 哇好累啊 Orz..

posted on 2008-11-29 19:05 xwang 阅读(752) 评论(4) 编辑收藏举报

刷新页面返回顶部

Roboot - A New Wang