1.定義およびスタック操作
1.1定義はスタック
挿入（プッシュ）と削除一端（スタックの最上部）にのみ直線状の動作を（ポップ）。それは、高度な（ファーストインラストアウト）リニア形の後、あります。
1.2スタック操作
- スタック操作：データ要素の値のスタックを挿入します。
- ポップ操作：データ要素のスタックを取り除きます。
- それは空である：スタックは、データ要素を含むかどうかを決定します。
- 深いスタックを与えるために：スタックの数は、実際のデータ要素を含んで取得します。
- クリア：スタック内のすべてのデータ要素を削除します。
- トップ要素を取得します。
1.3スタックの実装（パイソン）
class Stack:
"""模拟栈"""
def __init__(self):
self.items = []
def isEmpty(self):
return len(self.items)==0
def push(self, item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
if not self.isEmpty():
return self.items[len(self.items)-1]
def size(self):
return len(self.items)
s=Stack()
print(s.isEmpty())
s.push(4)
s.push('dog')
print(s.peek())
s.push(True)
print(s.size())
print(s.isEmpty())
s.push(8.4)
print(s.pop())
print(s.pop())
print(s.size())
2.再帰
関数が自分自身の中に自分自身を呼び出す場合は、この関数は再帰関数です。
ハノイ問題の塔
私たちは、最下段のプレート以外のカラムは、カラムはその後、我々は再びちょうどプレート列cの下に列に移動され、成功したBピラーに、天板63が移動されていると仮定することができます。
我々は、カラムトレイ列cの最大の動きをした場合、B列は、列が空である、残りの63皿です。目標は今列を移動するために、B、C列のこれらの63枚のプレートになりそう。この質問とまったく同じ元の質問は、単に列Bの列、64ターン63のサイズを変更します。従って、同じ方法は、第一プレート62の上方列B、Cからのカラムを移動させるようにした後、最下列のプレートに移動、使用することができます。
この補間では、その後、Bは列B、Cにディスク62に最上位ディスク61上の列を移動し、最終的にディスクのカラムに移動し、バッファ列です。
法律は、我々はAまたはBが列バッファにそれぞれ、その後、補助コラム、そして最下段のディスクシフトに最下層のディスクを除いて、第1以外のディスクを移動していることを私たちを発見しましたCピラーに、このプロセスが繰り返されます。
この処理は、例えば、私たちが望むたびは、nモバイルディスクの問題を解決するために、再帰的にモバイルディスクを繰り返して、我々は最初の（n-1）と同じ問題がプレートの操作を実施し解決しなければなりません。
あなたは、関数、移動（nは、A、B書くことができ 、c）を。それは理解することができる：移動（プレートの数、開始点、バッファリング、エンド）。
次のようにのみ直接C、コードに移動ケースのプレート上の1です。
if n == 1:
print(a, '-->', c)
より多くのプレートA 2の場合よりもあります。
首先，需要把 n-1 个盘子搬到 b 柱子缓冲。打印出的效果是：a --> b。
move(n - 1, a, c, b)
再把最大的盘子搬到 c 柱子，也是最大尺寸的一个。打印出：a–>c。
move(1, a, b, c)
最后，把剩下 b 柱的 n-1 个盘子搬到 c 上，此时缓冲变成了起点，起点变成了缓冲。
move(n - 1, b, a, c)
利用 Python 实现汉诺塔问题
i = 0
def move(n, a, b, c):
global i
if (n == 1):
i += 1
print('移动第 {0} 次 {1} --> {2}'.format(i, a, c))
return
move(n - 1, a, c, b)
move(1, a, b, c)
move(n - 1, b, a, c)
move(3, "a", "b", "c")
# 移动第 1 次 a --> c
# 移动第 2 次 a --> b
# 移动第 3 次 c --> b
# 移动第 4 次 a --> c
# 移动第 5 次 b --> a
# 移动第 6 次 b --> c
# 移动第 7 次 a --> c
3.练习-车辆重排序
假设一列货运列车共有n节车厢，每节车厢将停放在不同的车站。假定n个车站的编号分别为1至n，货运列车按照第n站至第1站的次序经过这些车站。车厢的编号与它们的目的地相同。为了便于从列车上卸掉相应的车厢，必须重新排列车厢，使各车厢从前至后按编号1至n的次序排列。当所有的车厢都按照这种次序排列时，在每个车站只需卸掉最后一节车厢即可。
我们在一个转轨站里完成车厢的重排工作，在转轨站中有一个入轨、一个出轨和k个缓冲铁轨（位于入轨和出轨之间）。图（a）给出一个转轨站，其中有k个（k=3）缓冲铁轨H1，H2 和H3。开始时，n节车厢的货车从入轨处进入转轨站，转轨结束时各车厢从右到左按照编号1至n的次序离开转轨站（通过出轨处）。在图（a）中，n=9，车厢从后至前的初始次序为5，8，1，7，4，2，9，6，3。图（b）给出了按所要求的次序重新排列后的结果。
编写算法实现火车车厢的重排，模拟具有n节车厢的火车“入轨”和“出轨”过程。
def output(stacks, n):
global minVal, minStack
stacks[minStack].pop()
print('移动车厢 %d 从缓冲铁轨 %d 到出轨。' % (minVal, minStack))
minVal = n + 2
minStack = -1
for index, stack in enumerate(stacks):
if((not stack.isempty()) and (stack.top() < minVal)):
minVal = stack.top()
minStack = index
def inputStack(i, stacks, n):
global minVal, minStack
beskStack = -1 # 最小车厢索引值所在的缓冲铁轨编号
bestTop = n + 1 # 缓冲铁轨中的最小车厢编号
for index, stack in enumerate(stacks):
if not stack.isempty(): # 若缓冲铁轨不为空
# 若缓冲铁轨的栈顶元素大于要放入缓冲铁轨的元素，并且其栈顶元素小于当前缓冲铁轨中的最小编号
a = stack.top()
# print('stack.top()的类型是', a)
if (a > i and bestTop > a):
bestTop = stack.top()
beskStack = index
else: # 若缓冲铁轨为空
if beskStack == -1:
beskStack = index
break
if beskStack == -1:
return False
stacks[beskStack].push(i)
print('移动车厢 %d 从入轨到缓冲铁轨 %d。' % (i, beskStack))
if i < minVal:
minVal = i
minStack = beskStack
return True
def rail_road(list, k):
global minVal, minStack
stacks = []
for i in range(k):
stack = stack1.ArrayStack()
stacks.append(stack)
nowNeed = 1
n = len(list)
minVal = n + 1
minStack = -1
for i in list:
if i == nowNeed:
print('移动车厢 %d 从入轨到出轨。' % i)
nowNeed += 1
# print("minVal", minVal)
while (minVal == nowNeed):
output(stacks, n) # 在缓冲栈中查找是否有需求值
nowNeed += 1
else:
if(inputStack(i, stacks, n) == False):
return False
return True
if __name__ == "__main__":
list = [3, 6, 9, 2, 4, 7, 1, 8, 5]
k = 3
minVal = len(list) + 1
minStack = -1
result = rail_road(list, k)
while(result == False):
print('需要更多的缓冲轨道，请输入需要添加的缓冲轨道数量。')
k = k + int(input())
result = rail_road(list, k)
