算法导论第十章 栈队列和链表

　　本章讲述的是基本的数据结构，如栈、队列和链表。这些都是最最基本的数据结构，具体的就不再啰嗦。然后本章也没有什么需要特别注意的点，哦，有一个小节：指针和对象的实现，可以认真看一下，大概就是用其他的实现方式来代替指针和对象的实现，因为有些语言不支持指针和对象数据类型，那在实现这种链式的数据结构就无法表示，本节介绍的方法就是利用数组和数组下标来构造对象和指针，说白了，就是利用数组来表示链式对象。个人感觉意义不大，权当了解得了。

　　结合一些常见的笔试面试题，我就用3个习题来总结这一章吧。

1、习题10.1-6：说明如何用两个栈实现一个队列，并分析相关队列操作的运行时间。

　　两个栈实现一个队列和两个队列实现一个栈的思路都是一样的。

算法思路：

1）StackA和StackB，StackA作为存储栈，StackB作为辅助栈；

2）入队列操作：假如StackA中有元素，则首先将StackA中元素出栈放入StackB中，再把入队列元素放入StackA，然后再把StackB中的元素出栈放入StackA中

3）出队列操作：以上操作保证先入队列的元素先出，所以，直接从StackA中出栈即可。

如下直观的图示：

代码如下：

#include <iostream>
#include <stack>
#include <cstdlib>

using namespace std;

/************************************************************************/
/*    两个栈实现队列
/*    采用C++模板是实现
/************************************************************************/
template<class T>
class StackQueue
{
public:
    StackQueue(){}
    ~StackQueue(){}

    void Enqueue(const T& elem);
    T    Dequeue();
    bool Empty() const;

private:
    stack<T>    m_stackA;
    stack<T>    m_stackB;
};

template<class T>
void StackQueue<T>::Enqueue(const T& elem)
{
    if (m_stackA.empty())
        m_stackA.push(elem);
    else {
        while (!m_stackA.empty()) {
            m_stackB.push(m_stackA.top());
            m_stackA.pop();
        }
        m_stackA.push(elem);
    }

    while(!m_stackB.empty()) {
        m_stackA.push(m_stackB.top());
        m_stackB.pop();
    }
}

template<class T>
T StackQueue<T>::Dequeue()
{
    T retElem;
    if (!m_stackA.empty()) {
        retElem = m_stackA.top();
        m_stackA.pop();
    }
    return retElem;
}

template<class T>
bool StackQueue<T>::Empty() const
{
    if (m_stackA.empty())
        return true;
    else
        return false;
}

// int main()
// {
//     StackQueue<int> SQ;
//     for (int i = 1; i <= 5; i ++) {
//         SQ.Enqueue(i);
//     }
// 
//     for (int i = 1; i <= 5; i ++) {
//         cout << SQ.Dequeue();
//     }
//     return 0;
// }

2、习题10.1-7：说明如何用两个队列实现一个栈，并分析相关栈操作的运行时间。

　　该算法思路与上题一样，本处就不再赘述。直接贴代码吧：

#include <iostream>
#include <queue>

using namespace std;

/************************************************************************/
/*    两个队列实现一个栈
/*    使用C++模板的形式
/************************************************************************/
template<class T>
class QueueStack {
public:
    QueueStack(){}
    ~QueueStack(){}
    
    void Push(const T& elem);
    void Pop();
    T Top() const;

private:
    queue<T>    m_queueA;
    queue<T>    m_queueB;
};

template<class T>
void QueueStack<T>::Push(const T& elem)
{
    if (m_queueA.empty())
        m_queueA.push(elem);
    else {
        while (!m_queueA.empty()) {
            m_queueB.push(m_queueA.front());
            m_queueA.pop();
        }
        m_queueA.push(elem);
    }
    while (!m_queueB.empty()) {
        m_queueA.push(m_queueB.front());
        m_queueB.pop();
    }
}

template<class T>
void QueueStack<T>::Pop()
{
    if (!m_queueA.empty())
        m_queueA.pop();
}

template<class T>
T QueueStack<T>::Top() const
{
    T nElem;
    if (!m_queueA.empty())
        nElem = m_queueA.front();
    return nElem;
}

// int main()
// {
//     QueueStack<int> QS;
//     for (int i = 1; i <= 5; i ++) {
//         QS.Push(i);
//     }
// 
//     for (int i = 1; i <= 5; i ++) {
//         cout << QS.Top();
//         QS.Pop();
//     }
//     return 0;
// }

3、习题10.2-7：给出一个O(n)时间的非递归过程，实现对一个含n个元素的单链表的逆转，要求出存储链表本身所需空间外，该过程只能使用固定大小的存储空间。

　　由于限制了时间和空间，所以只能通过就地逆转来实现，结合单链表的特性，能想到的就是改变指针的指向，我们可以用三个指针来指向链表中的元素，使之满足这样的关系：p->q->r。也不太好描述，看下面一个图示吧：

代码如下：

#include <iostream>

using namespace std;

template<class T>
class Node 
{
public:
    template<class T> friend class SingleLink;

    //Node(Node *pNext = NULL):m_pNext(pNext) {}
    Node(T key = (T)0, Node *pNext = NULL):m_key(key), m_pNext(pNext) {}
    ~Node(){}

private:
    T m_key;
    Node *m_pNext;
};

template<class T>
class SingleLink
{
public:
    SingleLink(Node<T> *pHead = NULL):m_pHead(pHead) {}
    ~SingleLink(){}

    void Insert(const T& );
    void Delete(const T& );

    void Reverse();

    void Print();

private:
    Node<T> *m_pHead;
};

//有序地插入
template<class T>
void SingleLink<T>::Insert(const T& key)
{
    Node<T> *pInsert = new Node<T>(key);
    if (NULL == m_pHead)
        m_pHead = pInsert; 
    else {
        Node<T> *pTemp = m_pHead;
        Node<T> *qTemp = NULL;
        while (pTemp) {
            if (pTemp->m_key <= key) {
                qTemp = pTemp;
                pTemp = pTemp->m_pNext;
            }
            else break;
        }
        pInsert->m_pNext = pTemp;
        qTemp->m_pNext = pInsert;
    }
}

template<class T>
void SingleLink<T>::Delete(const T& key)
{
    if (NULL == m_pHead)
        return;

    if (m_pHead->m_key == key)
        m_pHead = NULL;
    else {
        Node<T> *pTemp = m_pHead;
        Node<T> *pDelete = m_pHead->m_pNext;
        while (pDelete) {
            if (pDelete->m_key != key) {
                pTemp = pDelete;
                pDelete = pDelete->m_pNext;
            }
            else {
                pTemp->m_pNext = pDelete->m_pNext;
                break;
            }
        }
    }
}

template<class T>
void SingleLink<T>::Reverse()
{
    //only one element
    if (NULL == m_pHead || NULL == m_pHead->m_pNext)
        return;
    
    //p->q->r
    Node<T> *p = NULL, *q = m_pHead, *r = NULL;
    while (true) {
        r = q->m_pNext;
        q->m_pNext = p;
        
        if (NULL == r) {
            m_pHead = q;        
            break;
        }
        p = q;
        q = r;
    }
}

template<class T>
void SingleLink<T>::Print()
{
    Node<T> *pTemp = m_pHead;
    while (pTemp) {
        cout << pTemp->m_key << " ";
        pTemp = pTemp->m_pNext;
    }
    cout << endl;
}

int main()
{
    SingleLink<int> SL;
    for (int i = 1; i <= 5; i ++)
        SL.Insert(i);
    SL.Print();
    SL.Insert(9);
    SL.Insert(7);
    SL.Print();
    SL.Delete(7);
    SL.Print();
    SL.Delete(6);
    SL.Print();
    SL.Reverse();
    SL.Print();
    return 0;
}

---

我的公众号 「Linux云计算网络」(id: cloud_dev)，号内有 10T 书籍和视频资源，后台回复 「1024」 即可领取，分享的内容包括但不限于 Linux、网络、云计算虚拟化、容器Docker、OpenStack、Kubernetes、工具、SDN、OVS、DPDK、Go、Python、C/C++编程技术等内容，欢迎大家关注。