首页 > 代码库 > 浅谈算法和数据结构: 一 栈和队列

浅谈算法和数据结构: 一 栈和队列

2024-10-21 06:03:02   212人阅读

原文出自：http://www.cnblogs.com/yangecnu/p/Introduction-Stack-and-Queue.html

1. 基本概念

概念很简单，栈 (Stack)是一种后进先出(last in first off，LIFO)的数据结构，而队列(Queue)则是一种先进先出 (fisrt in first out，FIFO)的结构，如下图：

技术分享

2. 实现

现在来看如何实现以上的两个数据结构。在动手之前，Framework Design Guidelines这本书告诉我们，在设计API或者实体类的时候，应当围绕场景编写API规格说明书。

1.1 Stack的实现

栈是一种后进先出的数据结构，对于Stack 我们希望至少要对外提供以下几个方法：

技术分享

Stack<T>()

创建一个空的栈

void Push(T s)

往栈中添加一个新的元素

T Pop()

移除并返回最近添加的元素

boolean IsEmpty()

栈是否为空

int Size()

栈中元素的个数

要实现这些功能，我们有两中方法，数组和链表，先看链表实现：

栈的链表实现：

我们首先定义一个内部类来保存每个链表的节点，该节点包括当前的值以及指向下一个的值，然后建立一个节点保存位于栈顶的值以及记录栈的元素个数;

class Node
{
    public T Item{get;set;}
    public Node Next { get; set; }
}
private Node first = null;
private int number = 0;

现在来实现Push方法，即向栈顶压入一个元素，首先保存原先的位于栈顶的元素，然后新建一个新的栈顶元素，然后将该元素的下一个指向原先的栈顶元素。整个Pop过程如下:

技术分享

实现代码如下：

void Push(T node)
{
    Node oldFirst = first;
    first = new Node();
    first.Item= node;
    first.Next = oldFirst;
    number++;
}

Pop方法也很简单，首先保存栈顶元素的值，然后将栈顶元素设置为下一个元素：

技术分享

T Pop()
{
    T item = first.Item;
    first = first.Next;
    number--;
    return item;
}

基于链表的Stack实现，在最坏的情况下只需要常量的时间来进行Push和Pop操作。

栈的数组实现：

我们可以使用数组来存储栈中的元素Push的时候，直接添加一个元素S[N]到数组中，Pop的时候直接返回S[N-1].

技术分享

首先，我们定义一个数组，然后在构造函数中给定初始化大小，Push方法实现如下，就是集合里添加一个元素：

T[] item;
int number = 0;

public StackImplementByArray(int capacity)
{
    item = new T[capacity];
}
public void Push(T _item)
{
    if (number == item.Length) Resize(2 * item.Length);
    item[number++] = _item;
}

Pop方法：

public T Pop()
{
    T temp = item[--number];
    item[number] = default(T);
    if (number > 0 && number == item.Length / 4) Resize(item.Length / 2);
    return temp;
}

在Push和Pop方法中，为了节省内存空间，我们会对数组进行整理。Push的时候，当元素的个数达到数组的Capacity的时候，我们开辟2倍于当前元素的新数组，然后将原数组中的元素拷贝到新数组中。Pop的时候，当元素的个数小于当前容量的1/4的时候，我们将原数组的大小容量减少1/2。

Resize方法基本就是数组复制：

private void Resize(int capacity)
{
    T[] temp = new T[capacity];
    for (int i = 0; i < item.Length; i++)
    {
        temp[i] = item[i];
    }
    item = temp;
}

当我们缩小数组的时候，采用的是判断1/4的情况，这样效率要比1/2要高，因为可以有效避免在1/2附件插入，删除，插入，删除，从而频繁的扩大和缩小数组的情况。下图展示了在插入和删除的情况下数组中的元素以及数组大小的变化情况：

技术分享 

分析：1. Pop和Push操作在最坏的情况下与元素个数成比例的N的时间，时间主要花费在扩大或者缩小数组的个数时，数组拷贝上。

2. 元素在内存中分布紧凑，密度高，便于利用内存的时间和空间局部性，便于CPU进行缓存，较LinkList内存占用小，效率高。

2.2 Queue的实现

Queue是一种先进先出的数据结构，和Stack一样，他也有链表和数组两种实现，理解了Stack的实现后，Queue的实现就比较简单了。

技术分享

Stack<T>()

创建一个空的队列

void Enqueue(T s)

往队列中添加一个新的元素

T Dequeue()

移除队列中最早添加的元素

boolean IsEmpty()

队列是否为空

int Size()

队列中元素的个数

首先看链表的实现：

Dequeue方法就是返回链表中的第一个元素，这个和Stack中的Pop方法相似：

public T Dequeue()
{
    T temp = first.Item;
    first = first.Next;
    number--;
    if (IsEmpety())
        last = null;
    return temp;
}

Enqueue和Stack的Push方法不同，他是在链表的末尾增加新的元素：

public void Enqueue(T item)
{
    Node oldLast = last;
    last = new Node();
    last.Item = item;
    if (IsEmpety())
    {
        first = last;
    }
    else
    {
        oldLast.Next = last;
    }
    number++;
}

同样地，现在再来看如何使用数组来实现Queue，首先我们使用数组来保存数据，并定义变量head和tail来记录Queue的首尾元素。

技术分享

和Stack的实现方式不同，在Queue中，我们定义了head和tail来记录头元素和尾元素。当enqueue的时候，tial加1，将元素放在尾部，当dequeue的时候，head减1，并返回。

public void Enqueue(T _item)
{
    if ((head - tail + 1) == item.Length) Resize(2 * item.Length);
    item[tail++] = _item;
}

public T Dequeue()
{
    T temp = item[--head];
    item[head] = default(T);
    if (head > 0 && (tail - head + 1) == item.Length / 4) Resize(item.Length / 2);
    return temp;
}

private void Resize(int capacity)
{
    T[] temp = new T[capacity];
    int index = 0;
    for (int i = head; i < tail; i++)
    {
        temp[++index] = item[i];
    }
    item = temp;
}

 

浅谈算法和数据结构: 一 栈和队列


联系
我们