C++数据结构（栈的应用）（火车重排问题）

//非原创，不知道怎么转载 
//emmm这玩意我研究了一晚上哈哈哈哈哈
//这个是原网址，我只是做个笔记自己看的
//https://blog.csdn.net/jkay_wong/article/details/6830541

//为了重排车厢，需从前往后依次检查入轨上的所有车厢。
//如果正在检查的车厢就是下一个满足要求的车厢，可以直
//接把它放到出轨上。否则，则把它移动到缓冲轨上，直到
//按输出顺序要求轮到它的时候才可以将他放到出轨上。缓
//冲轨是按照栈的方式使用的，因为车厢的进出都是在缓
//冲轨的顶端进行的。

//在重排车厢过程中，仅允许以下活动：
//
//1、车厢可以从入轨的前部移动到一个缓冲轨的顶部或者是出轨的左端
//
//2、车厢可以从一个缓冲轨的顶部移动到出轨的左端

#include<iostream>
using namespace std;

template<class T>
class My_stack;

template<class T>
class Node       //节点类
{
private:
	T data;
	Node<T>* next;
public:
	Node()
	{
		next = NULL;
	}
	Node(T d)
	{
		data = d;
		next = NULL;
	}
	friend My_stack<T>;
};

//头结点不存数据的那种
template<class T>
class My_stack
{
private:
	Node<T>* head;
public:
	My_stack()
	{
		head = new Node<T>();
	}
	bool empty()const
	{
		return (head->next == NULL);
	}
	void push(T d)//入栈 用头插法，因为操作头结点容易
	{
		Node<T>* p = new Node<T>(d);
		p->next = head->next;
		head->next = p;
	}
	T top()//返回栈顶元素
	{
		if (empty())
		{
			cout << "stack is empty." << endl;
			exit(1);
		}
		Node<T>* p = head->next;
		T temp = p->data;
		return temp;
	}

	void pop()//弹出栈顶元素
	{
		//为啥不判断栈空不空呀 我觉得得判断一下子
		if (empty())
		{
			cout << "stack is empty." << endl;
			exit(1);
		}
		Node<T>* p = head->next;
		head->next = p->next;
		delete p;
	}

};

//------------以上是栈的准备（链表表示）------------------------
//------------以下要动真格的啦----------------------------------
//------------警告！不是演习！！---------------------------------


//minH:缓冲轨中编号最小的车厢  minS : 编号最小的车厢所在缓冲轨的编号
//H[]:是缓冲车栈数组   n:车厢的数目  k:缓冲轨道的数目
//c是轮到的车厢的号数
void OutPut(int& minH, int& minS, My_stack<int> H[], int k, int n);
bool Hold(int c, int& minH, int& minS, My_stack<int>H[], int k, int n);

//n:车厢的数目  k:缓冲轨道的数目
bool Rail_Road(int p[], int n, int k)
{
	//k个缓冲轨，车厢初始排序为p[1...n]

	//创建与缓冲轨对应的链栈
	My_stack<int>* H;
	H = new My_stack<int>[k];

	int NowOut = 1;//下一次要出轨的车厢

    //这里这么干是为了现将数定到不可能的数上。
	int minH = n + 1;//缓冲轨中编号最小的车厢
	int minS = k;//编号最小的车厢所在缓冲轨的编号

	//车厢重排序
	for (int i = 0; i < n; i++)
	{
		if (p[i] == NowOut)
		{
			cout << "Move car" << p[i] << " from input to output" << endl;
			NowOut++;

			//从缓冲轨中输出 用while就很妙了，如果缓冲栈里数是连着的，就一锅端了
			while (minH == NowOut)
			{
				OutPut(minH, minS, H, k, n);
				NowOut++;
			}
		}
		else {
			//将p[i]放入某个缓冲轨
			if (!Hold(p[i], minH, minS, H, k, n))
				return false;
		}
	}
	return true;
}

void OutPut(int& minH, int& minS, My_stack<int> H[], int k, int n)
{
	//该函数实现把一节车厢从缓冲轨送至出轨处
	//同时修改minH minS的值

	int c;

	//从栈中pop掉编号最小的车厢minH
	c = H[minS].top();
	H[minS].pop();

	cout << "Move car " << c << " from holding track " << minS + 1 << " to output " << endl;

	//检查所有链栈，搜索新的minH minS
	minH = n + 1;

	for (int i = 0; i < k; i++)
		if ((!H[i].empty()) && (H[i].top() < minH))
		{
			minH = H[i].top();
			minS = i;
		}
}

//c:轨道上轮到的车厢号数  minH:缓冲轨中编号最小的车厢  minS:编号最小的车厢所在缓冲轨的编号
//H[]:是缓冲车栈数组   n:车厢的数目  k:缓冲轨道的数目
bool Hold(int c, int& minH, int& minS, My_stack<int> H[], int k, int n)
{
	//该函数是将车厢c放入缓冲轨中
	//注意，这个函数minH等都是引用，所以外面可以实时知道缓冲轨中编号最小的车厢还有编号最小的车厢所在的缓冲轨的编号

	//为车厢c寻找最优缓冲轨
	//一开始附的值都是越界的，也就是不可能的
	int BestTrack = k;//初始化
	int BestTop = n + 1; //最优缓冲轨的栈顶车厢编号

	int x;

	//扫描缓冲轨
	for (int i = 0; i < k; i++)
	{
		if (!H[i].empty())
		{
			//这个优先级第一
			//x是栈的顶部元素
			x = H[i].top();
			//c一定要在比她大的，而且那个元素是最小的那个栈里放（好别扭呀）
			if (c < x && x < BestTop)
			{
				BestTop = x;
				BestTrack = i;
			}
		}
		else
		{
			//H[i]为空时//这个显然第二优先
			if (BestTrack == k)
				BestTrack = i;
		}
	}
	
	//这个优先级是最低的
	if (BestTrack == k) //没有可用的缓冲轨
		return false;

	H[BestTrack].push(c);
	cout << "Move car " << c << " from input to holding track " << BestTrack + 1 << endl;

	//必要时修改minH和minS
	if (c < minH)
	{
		minH = c;
		minS = BestTrack;
	}

	return true;

}


int main()
{
	int p[9] = {3,6,9,2,4,7,1,8,5 };
	if (Rail_Road(p, 9, 3))
		cout << "车厢重排序成功" << endl;
	else
		cout << "车厢重排序失败" << endl;
	return 0;
}