在实现栈，队列等线性数据结构时，区分开逻辑层和存储层下标两个概念，可以让写代码的思路更清晰。
今天开始，啃读算法导论第10章。既然是啃就要有啃的样子，我决定将例题和习题全部用C++实现一遍，总结同一类问题的共性。
10.1节介绍了栈，队列，双端队列及一些组合形式，为了突出体现思路，让代码更加简洁明了，暂且另元素的类型是int，存储结构都采用定长数组吧。
- 例题1 :栈
下面的代码就实现了一个简单的栈，栈内可容纳元素个数有上限。在实现每个类型的时候都应该问问自己，为什么需要维护这些数据成员，多一个会不会更好？少一个可行吗？
因为栈是一种逻辑数据结构，而每种逻辑数据结构的实现都需要依赖一种物理存储结构的支持，这里我选择了数组，所以我需要维护一个数组及其总长度（m_array和m_totalLength）。
由于Push、Pop、Top方法中待处理元素的位置信息，不是由参数给定的，而是由栈自身维护的，所以我还需要记录当前待处理元素（这里指的是栈顶元素）的下标(m_top)，其取值范围是[-1, m_totalLength-1]。
m_top的作用之一是用来计算栈顶元素所对应的数组元素的下标f(m_top)，从而将逻辑层操作转化成存储层的操作，这里我将映射法则定义为f(m_top) = m_top。
m_top的作用之二是计算:当前栈内元素个数 = m_top + 1，从而判断栈是否为空或已满。
这已经是数据成员最精简的版本，一个也不能少。
class Stack
{
public:
Stack(int len); //len表示栈的最大长度
~Stack();
void Push(int val); //压栈，若栈已满，报错”Overflow“
void Pop(); //出栈，若栈为空，报错”Underflow“
int Top() const; //读取栈顶，若栈为空，报错”Empty“
bool IsEmpty() const; //栈是否为空
bool IsFull() const; //栈是否已满
private:
int* m_array; //数组
const int m_totalLength; //栈的最大长度，也是数组的总长度
int m_top; //栈顶元素下标
};
Stack::Stack(int len)
:m_totalLength(len),
m_array(new int[len]),
m_top(-1)
{}
Stack::~Stack()
{
delete[] m_array;
}
void Stack::Push(int val)
{
if(IsFull())
cerr << "Overflow" << endl;
else
m_array[++m_top] = val;
}
void Stack::Pop()
{
if(IsEmpty())
cerr << "Underflow" << endl;
else
--m_top;
}
int Stack::Top() const
{
if(IsEmpty())
{
cerr << "Empty" << endl;
return -1;
}
else
return m_array[m_top];
}
bool Stack::IsEmpty() const
{
return m_top == -1;
}
bool Stack::IsFull() const
{
return m_top == m_totalLength - 1;
}- 例题2：队列
同样的，队列可同时容纳元素个数有上限。我都需要保存哪些数据成员呢？
数组及其总长度（m_array, m_totalLength）
入队，出队方法中待处理元素位置信息，这里指的是队头和队尾元素的下标，同样需要由方法内部维护（m_begin, m_end）。
m_begin, m_end的作用之一是计算队头、队尾所对应数组元素下标，依据逻辑含义应是只增不减的，而依据环形队列的映射法则计算出的数组元素下标是在[0, m_totalLength)区间内循环取值的。
m_begin, m_end的作用之二是计算当前容纳元素个数，作为判断操作合法性的边界条件。
具体实现中，在不影响上述两作用的前提下，必须对m_begin,m_end的值加以限制。（见方法Dequeue）
由于入队，出队方法的被调用频率不同且无关，必须被记录至两个变量中，所以数据成员不能更少了。
class Queue
{
public:
Queue(int len);
~Queue();
void Enqueue(int val);
void Dequeue();
int Front() const;
int Back() const;
bool IsEmpty() const;
bool IsFull() const;
private:
int IndexInArray(indexInQueue) const;
private:
int* m_array;
const int m_totalLength;
int m_begin; //index of front element
int m_end; //index of the one next to back element
};
Queue::Queue(int len)
: m_totalLength(len),
m_array(new int[len]),
m_begin(0),
m_end(0)
{
}
Queue::~Queue()
{
delete[] m_array;
}
void Queue::Enqueue(int val)
{
if(IsFull())
cerr << "Overflow" << endl;
else
{
m_array[IndexInArray(m_end)] = val;
++m_end;
}
}
void Queue::Dequeue()
{
if(IsEmpty())
cerr << "Underflow" << endl;
else
{
++m_begin;
//限制m_begin,m_end取值范围
if(m_begin >= m_totalLength)
{
m_begin -= m_totalLength;
m_end -= m_totalLength;
}
}
}
int Queue::Front() const
{
if(IsEmpty())
{
cerr << "Empty" << endl;
return -1;
}
return m_array[IndexInArray(m_begin)];
}
int Queue::Back() const
{
if(IsEmpty())
{
cerr << "Empty" << endl;
return -1;
}
return m_array[IndexInArray(m_end - 1)];
}
bool Queue::IsEmpty() const
{
return m_begin == m_end;
}
bool Queue::IsFull() const
{
return m_end - m_begin == m_totalLength;
}
int Queue::IndexInArray(indexInQueue) const
{
assert(indexInQueue >= 0);
return indexInQueue % m_totalLength;
}- 习题10.1-2 用一个数组存储两个栈，只有当两个栈总长度达到数组总长度时，才算作栈已满。
我们把数组视为环形数组。
因为需要把一个数组分给两个栈使用，所以我们需要设置一个分界线，两个栈分别以分界线处两个相邻元素为起点，分别向左右两个方向生长，直到二者总长度达到数组总长度为止。
如此说来，除了数组和总长度外，还需要保存一个常量（分界线的位置m_divide）和两个变量（两个栈顶元素下标m_top[A],m_top[B]）。
m_top[A]和m_top[B]保存的是逻辑层的栈内下标，它的作用和Stack::m_top以及Queue::m_begin，Queue::m_end都是一样的，一是计算对应的数组元素下标，二是计算边界条件，判断调用合法性。
class DoubleStack
{
public:
enum StackID //用A，B标识两个栈
{
A = 0,
B = 1
};
DoubleStack(int len);
~DoubleStack();
void Push(StackID id, int val);
void Pop(StackID id);
int Top(StackID id) const;
bool IsEmpty(StackID id) const;
bool IsFull() const; //两个栈会同时到达满栈条件，所以这里无需传入StackID
private:
int TopIndexInArray(StackID id) const;
private:
int* m_array;
const int m_totalLength;
int m_top[2];
const int m_divide;
};
DoubleStack::DoubleStack(int len)
: m_array(new int[len]),
m_totalLength(len),
m_divide(len/2) //any value within [0, m_totalLength) is ok
{
m_top[A] = -1;
m_top[B] = -1;
}
DoubleStack::~DoubleStack()
{
delete[] m_array;
}
void DoubleStack::Push(StackID id, int val)
{
if(IsFull())
{
cout << "Overflow" << endl;
return;
}
++ m_top[id];
m_array[TopIndexInArray(id)] = val;
}
void DoubleStack::Pop(StackID id)
{
if(IsEmpty(id))
{
cerr << "Underflow" << endl;
return;
}
-- m_top[id];
}
int DoubleStack::Top(StackID id) const
{
if(IsEmpty(id))
{
cerr << "Empty" << endl;
return -1;
}
return m_array[TopIndexInArray(id)];
}
bool DoubleStack::IsEmpty(StackID id) const
{
return m_top[id] == -1;
}
bool DoubleStack::IsFull() const
{
return m_top[A] + m_top[B] + 2 == m_totalLength;
}
int DoubleStack::TopIndexInArray(DoubleStack::StackID id) const
{
//let m_array[m_divide] belongs to stack B
if(id == A)
return (m_divide - (m_top[A] + 1) + m_totalLength) % m_totalLength;
else
return (m_divide + m_top[B]) % m_totalLength;
}- 以上三个类型的实现有一些共同的逻辑，是时候来总结一下了。
- 需要保存哪些信息？和普通线性表不同，调用栈的Push，Pop方法时，被操作的元素所处的位置是调用方和被调用方之间的一种约定，这里约定为栈顶的元素。类似的，双方约定调用队列的Enqueue、Dequeue所操作的元素分别为队尾和队头。既然这一信息不是由参数传入，就需要类型自行维护。总结一下，需要保存的是待操作元素的位置信息。每个栈有一个，每个队列有两个。
- 逻辑层信息和存储层信息，选择保存哪一个？假设你有一个菜谱，如果你想照着它炒出一盘菜，你还需要存放和操作食材的厨房。每个逻辑数据结构就好像一个菜谱，如果你想用程序实现它并运行起来，你还需要一个存储和操作它的介质，那就是物理存储结构，比如数组。数组是存储层的结构，而栈是逻辑层的结构，随之而产生的是每个元素都有两个位置信息，我叫它们逻辑层下标和存储层下标。两者构成一对映射，通常是满射。通过映射法则，两者可以互相求得。所以我们只需要在数据成员中保存一方，就可以在需要时计算出另一方。我在上面的实现中，都选择了保存逻辑下标，并将计算存储下标的工作封装在一个函数中，这样做的好处是：1. 几乎每个接口都有逻辑层的处理，但不是每个都需要动用存储层逻辑，所以保存逻辑层信息可以使得接口在逻辑层的处理更直接高效。例如，IsEmpty接口就无需计算存储层下标；2. 当你想改换一种物理存储结构时，例如从数组改为链表，你只需要修改从逻辑层下标到物理层下标的映射过程，灵活性较好。
- 映射法则可以很灵活。通常，考虑效率和易读性，栈下标x到数组下标f(x)的映射法则往往定义为:f(x) = x。如果你很任性，就想玩些花样，其实你完全可以把数组当做环形数组，将数组的任意位置作为起始点，比如f(x) = x + 2,就是用数组的第三个元素存储第一个入栈的元素，满栈前最后两个入栈的元素放在数组第一个，第二个元素上。或者你还可以倒过来存储，f(x) = 数组总长度 - 1 - x;甚至你可以毫无规律地将逻辑下标{0， 1， 2， 3}映射成存储下标{3， 1， 2， 0}，只要它是满射，只要你开心。为什么我要这样折腾这个映射法则呢？因为有时候，它可以帮助我们灵活地解决问题。例如下面的习题10.1-2，如何将两个栈的逻辑下标映射到一个数组的存储下标上去，既要彼此不干扰，又可以最大限度利用数组，这便是映射法则的用武之地了。具体实现见函数DoubleStack::TopIndexInArray。
- 10.1-4 同例题2
- 10.1-5 双端队列
按照前面总结的规律，需要保存的是待操作元素的位置信息，这里有两个待操作元素的位置会移动，所以保存它们在逻辑层的下标，m_begin, m_end，分别表示队头和队尾元素的下一个元素的下标。
class Deque
{
public:
Deque(int len);
~Deque();
void Push_back(int );
void Push_front(int );
void Pop_back();
void Pop_front();
int Front() const;
int Back() const;
bool IsEmpty() const;
bool IsFull() const;
private:
int IndexInArray(int indexInDeque) const;
private:
int* m_array;
const int m_totalLength;
int m_begin; //the index of front element
int m_end; //the index of one after the back element
};
Deque::Deque(int len)
: m_totalLength(len),
m_array(new int[len]),
m_begin(len/2),//as long as m_begin = m_end,any value > 0 is ok
m_end(len/2)
{}
Deque::~Deque()
{
delete[] m_array;
}
void Deque::Push_back(int val)
{
if(IsFull())
{
cerr << "Overflow" << endl;
return;
}
m_array[IndexInArray(m_end)] = val;
//set an upper limit to m_end
if(++m_end > 2 * m_totalLength)
{
m_end -= m_totalLength;
m_begin -= m_totalLength;
}
}
void Deque::Push_front(int val)
{
if(IsFull())
{
cerr << "Overflow" << endl;
return;
}
//set a lower limit to m_begin
if(--m_begin < 0)
{
m_begin += m_totalLength;
m_end += m_totalLength;
}
m_array[IndexInArray(m_begin)] = val;
}
void Deque::Pop_back()
{
if(IsEmpty())
{
cerr << "Underflow" << endl;
return;
}
--m_end;
}
void Deque::Pop_front()
{
if(IsEmpty())
{
cerr << "Underflow" << endl;
return;
}
++m_begin;
}
int Deque::Front() const
{
if(IsEmpty())
{
cerr << "Empty" << endl;
return -1;
}
return m_array[IndexInArray(m_begin)];
}
int Deque::Back() const
{
if(IsEmpty())
{
cerr << "Empty" << endl;
return -1;
}
return m_array[IndexInArray(m_end-1)];
}
bool Deque::IsEmpty() const
{
return m_begin == m_end;
}
bool Deque::IsFull() const
{
return m_end - m_begin == m_totalLength;
}
int Deque::IndexInArray(int indexInDeque) const
{
return indexInDeque % m_totalLength;
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
