数据结构C++ 栈——栈的应用

application.h ：

#pragma once
#include <iostream>

//括号匹配问题
void matchingPairs(std::string pairsString);

//汉诺塔问题
void Hanoi(int amount);

//列车车厢重排问题
bool Arrange(int order[], int ordered[], int carNum, int stackNum);

//开关盒布线问题
bool checkBox(int Box[], int Num);

application.cpp ：

#include "application.h"
#include "listStack.h"


void matchingPairs(std::string pairsString)
{
    listStack<int> Pairs;

    for (int i = 0; i < pairsString.size(); i++)
    {
        if (pairsString[i] == '(')            //遇到 '(' 进栈
        {
            Pairs.push(i);
        }
        else if (pairsString[i] == ')')        //遇到 ')' 出栈
        {
            try
            {
                std::cout << Pairs.top() << " " << i << std::endl;
                Pairs.pop();
            }
            catch (stackEmpty)
            {
                std::cout << "Stack is empty, Not have matching right Pairs at " << i << std::endl;
            }
        }
    }
    while (!Pairs.empty())
    {
        std::cout << "Stack is empty, Not have matching left Pairs " << Pairs.top() << std::endl;
        Pairs.pop();
    }
}

void moveHanoi(int amount, listStack<int> &sce, listStack<int>  &des, listStack<int> &tmp)
{
    if (amount <= 0)
        return;
    moveHanoi(amount - 1, sce, tmp, des);    //先将盘子移动到 第三座塔 上
    int plate = sce.top();
    des.push(plate);
    sce.pop();

    moveHanoi(amount - 1, tmp, des, sce);    //再从第三座塔移动到 目标塔 上
}

void Hanoi(int amount)
{
    listStack<int> HanoiStack[3];            //HanoiStack[0],HanoiStack[1],HanoiStack[2]分别代表三座塔

    for (int i = amount; i > 0; i--)        //0号塔 的初始化，“将盘子串在第一座塔上”
    {
        HanoiStack[0].push(i);
    }

    moveHanoi(amount, HanoiStack[0], HanoiStack[1], HanoiStack[2]);                //将 0号塔 上的盘子移动到 1号塔 上
}


int minCar;                //缓冲轨道上编号最小的车厢
int minCarInStack;        //缓冲轨道上编号最小的车厢所在的轨道号

bool fromOrderToStack(int car, listStack<int>* &Stack, int stackNum, int carNum)
{
    int bestStack = -1, bestTop = carNum + 1;
    for (int i = 0; i < stackNum; i++)        //轨道为空
    {
        if (Stack[i].empty())
        {
            if (bestStack == -1)
                bestStack = i;
        }
        else                                //轨道不为空
        {
            int stackTop = Stack[i].top();
            if (car < stackTop && stackTop < bestTop)
            {
                bestTop = stackTop;
                bestStack = i;
            }
        }
    }

    if (-1 == bestStack)
        return false;

    Stack[bestStack].push(car);        //车厢放入最合适的缓冲轨道内
    if (car < minCar)                //更新变量
    {
        minCar = car;
        minCarInStack = bestStack;
    }

    return true;
}

void fromStackToOrdered(listStack<int>* &Stack, int stackNum, int ordered[], int &nextCar, int carNum)
{
    int stackTop = Stack[minCarInStack].top();
    Stack[minCarInStack].pop();
    ordered[nextCar - 1] = stackTop;

    minCar = carNum + 1;
    for (int i = 0; i < stackNum; i++)
    {
        if (!Stack[i].empty() && Stack[i].top() < minCar)
        {
            minCar = Stack[i].top();
            minCarInStack = i;
        }
    }
}

bool Arrange(int order[], int ordered[], int carNum, int stackNum)
{
    listStack<int> *Stack = new listStack<int>[stackNum];

    int nextCar = 1;        //下一个该几号车厢
    minCar = carNum + 1;
    for (int i = 0; i < carNum; i++)
    {
        if (order[i] == nextCar)        //直接放到出轨道 { 9,5,7,3,2,8,4,1,6 };
        {
            ordered[nextCar - 1] = order[i];
            nextCar++;
            while (minCar == nextCar  && nextCar <= carNum)
            {
                fromStackToOrdered(Stack, stackNum, ordered, nextCar, carNum);
                nextCar++;
            }
        }
        else                            //将车厢放到缓冲轨道
        {
            if (!fromOrderToStack(order[i], Stack, stackNum, carNum))
                return false;
        }
    }

    delete[] Stack;
    return true;
}


bool checkBox(int Box[], int Num)
{
    listStack<int> Stack;

    for (int i = 0; i < Num; i++)
    {
        if (Stack.empty())
            Stack.push(Box[i]);
        else
        {
            if (Stack.top() == Box[i])
                Stack.pop();
            else
                Stack.push(Box[i]);
        }
    }

    if (!Stack.empty())
    {
        std::cout << "该开关盒布线方案无法实现" << std::endl;
        return false;
    }
    std::cout << "该开关盒布线方案可实现" << std::endl;
    return true;
}

 

转载于:https://www.cnblogs.com/peformer/p/8029416.html