#Page111 队列 击鼓传花
from pythonds.basic.queue import Queue #import对应模块
def hotPotato(namelist, num):#参数为人队列和次数
simqueue = Queue()#创建新的队列
for name in namelist:#对于namelist中的每个元素
simqueue.enqueue(name)#把其压入此队列中
#压入所有姓名
while simqueue.size() > 1:#如果不到最后（因为最后要求只剩一个人）
for i in range(num):#
simqueue.enqueue(simqueue.dequeue())#把列头pop出来，再塞到队尾，重复num次
simqueue.dequeue()#每完成Num次，永久弹出列头，直到simqueue.size()=1
return simqueue.dequeue()#直到最终把剩下的那个人的名字展示出来
#page122 回文检查
from pythonds.basic.deque import Deque #import双端队列模块
def palchecker(aString):#输入是一串字符串
chardeque = Deque()#创建双端队列
for ch in aString:
chardeque.addRear(ch)#把输入的字符串每个字符依次添加到队尾
stillEqual = True
while chardeque.size() > 1 and stillEqual:#双闸控制的while语句
first = chardeque.removeFront()#弹出头部
last = chardeque.removeRear()#弹出尾部
if first != last:
stillEqual = False#不相等的话就直接跳出循环
return stillEqual#表示是否回文匹配完全成功
#时间复杂度为O（n）的两列表合并且排序算法
for k = 1 to n
if B(i)<C(i)
D(k)=B(i)
i++
else [C(j)<B(i)]
D(k)=C(j)
j++
End
#进制任意转化
def toStr(n,base):#参数是十进制数字，以及要转换到的进制
convertString = '0123456789ABCDEF'
if n < base:#如果此数小于要转换成的进制，那么就直接
return convertString[n]
else:
return toStr(n//base,base) + convertString[n%base]
#利用栈的特性进行进制转化
from pythonds.basic.stack import Stack#导入stack模块
rStack = Stack()
def toStr(n,base):
convertString = '0123456789ABCDEF'
while n > 0:#控制语句，当输入的数字大于0才有意义
if n < base:#如果n小于要转换成的进制
rStack.push(convertString[n])#就直接压入栈中
else:
rStack.push(convertString[n%base])#否则就压入余数
n = n//base #没压制一次余数之后，都要利用\\运算符，因为此循环总要有个控制结束的语句
res = ''#创建空字符串
while not rStack.isEmpty():#当此栈为非空时
res = res + str(rStack.pop())#依次弹出，这样即利用了栈的性质，因为第一个压入的实际上是结果的最后一位
return res
#可视化递归 turtle模块
import turtle
myTurtle = turtle.Turtle()
myWin = turtle.Screen()
def drawSpiral(myTurtle,lineLen):
if lineLen > 0:
myTurtle.forward(lineLen)
myTurtle.right(90)
drawSpiral(myTurtle,lineLen-5)#呈正方形螺旋湮灭，最后不满足条件了就停止
drawSpiral(myTurtle,100)
myWin.exitonclick()
import turtle
def tree(branchLen,t):#到达最深层再退回来,退回来，在执行左边，在退回来
if branchLen>5:
t.forward(branchLen)
t.right(20)
tree(branchLen-15,t)#执行第一个递归，即重复这个递归之上的语句，直到最底层（或者说最深层）
t.left(40)
tree(branchLen-15,t)#
t.right(20)
t.backward(branchLen)#从后面的执行过程可以看出，这种递归是先
def main():
t = turtle.Turtle()
myWin = turtle.Screen()
t.left(90)
t.up()
t.backward(100)
t.down()
t.color('green')
tree(75,t)
myWin.exitonclick()
main()
#汉诺塔
def moveTower(height,fromPole,toPole,withPole):
if height>=1:
moveTower(height-1,fromPole,withPole,toPole)
moveDisk(fromPole,toPole)
moveTower(height-1,withPole,toPole,fromPole)
def moveDisk(fp,tp):
print('moving disk from',fp,'to',tp)#虽然具体实现过程还是迷迷糊糊的，但是通过证明此代码完全没问题
moveTower(3,1,2,3)
#迷宫的设计与其蕴含的递归思想
#代码数量繁杂，因此暂时不写
#二分搜索 binary_search递归版本
def binary_search(arr,start,end,hkey):#四个参数 要搜寻的已经排过序的数列，数列的开始index和结束index，要搜寻的目标元素
if start > end:#如果此数列未经过排序，是不行的
return -1
mid = start + (end - start) / 2#如果通过了第一步，那么就找中点的index值
if arr[mid] > hkey:#如果index mid在数列arr中大于要搜寻的目标，证明在左半区
return binary_search(arr, start, mid - 1, hkey)#递归调用，将end改为mid-1
if arr[mid] < hkey:#如果大于，则是右半区
return binary_search(arr, mid + 1, end, hkey)
return mid#最后结果输出是mid值？这个二分搜索必须是连续的整数？还是说这段code的本意就是定位此元素所在的位置？
#二分查找的非递归版本
def binarySearch(alist,item):
first = 0
last = len(alist)-1
found = False
while first<=last and not found:#如果队列没结束而且也没有找到匹配，就执行以下
midpoint = (first+last)//2
if alist[midpoint] == item:
found = True
else:
if item < alist[midpoint]:#说明在右半段
last = midpoint-1#将结束搜索点前移
else:
first = midpoint+1#说明在左半段#将开始搜索点后移
return found
#硬币找零问题（目的是找出所需硬币总数最小的找零方案）
#初级code
def recMC(coinValueList,change):#相当于倒序查找，人脑想先比配最大的，比如25美分，但是程序用1美分开始，减去一美分，看看余下的是不是能被25,10,5整除，不能的话再减去一美分，再试，能的话就减去整除所消耗的结果。其实刚开始我们就要看能不能整除，不能的话在执行减一的迭代操作。
minCoins = change
if change in coinValueList:#如果是直接在里面，一个硬币就够了
return 1
else :
for i in [c for c in coinValueList if c<=change]:#如果至少需要的change多于一个，对coinValueList进行遍历
numCoins = 1 + recMC(coinValueList,change-i)
if numCoins < minCoins:#如果找零硬币的个数小于要找零的金额
minCoins = numCoins#先执行迭代，然后检查接下来的语句？迭代难道不是个无底洞吗，直到迭代到最基层，但是最基层的控制语句在哪里体现呢？
return minCoins
print(recMC[1,5,10,25],63)
#但是上述方法有些繁杂，所以不妨记住一些过去的结果，可以避免重新计算以前的结果：what's that supposed to mean?
def recDC(coinValueList,change,knownResults):
minCoins = change
if change in coinValueList:
knownResults[change]=1
return 1
elif knownResults[change]>0:#第一次试执行此语句的时候，是必然不满足的？
return knownResults[change]
else:
for i in [c for c in coinValueList if c<=change]:
numCoins = 1 + recDC(coinValueList,change-i,knownResults)
if numCoins < minCoins:
minCoins = numCoins
knownResults[change] = minCoins
return minCoins#真让人头大，看不懂
#更优的解，采用动态规划算法来解决找零问题：很明显，这个函数没有用到递归，所以递归虽好，有时候还是比不上迭代哦
def dpMakeChange(coinValueList,change,minCoins):#假设change=63
for cents in range(change+1):#cents的数额从0到63增加
coinCount = cents
for j in [c for c in coinValueList if c <=cents]:#当coinValueList中的值小于逐步增长的c时，这个cent=1234的时候只有1满足，cent=56789的时候有1和5满足
if minCoins[cents-j]+1 < coinCount:#minCoins到底是什么东西？
coinCount[cents] = minCoins[cents-j]+1
minCoins[cents] = coinCount
return minCoins[change]#返回从0到找零值的所有值的解
#双闸控制的while语句，很实用
pos = 0
found = False
while pos < len(alist) and not found:
if alist == item:
found = True
else:
pos = pos+1
#以上就是遍历搜索的两个控制条件：第一是搜索完全长，那么停止，要么是找到了所需的项目，那么也停止
#冒泡排序
def bubbleSort(alist):#按从小到大排列
for passnum in range(len(alist)-1,0,-1):#倒序输入alist长度的range
for i in range(passnum):#进行第一次遍历，长度为n-1,第二次为n-2...
if alist[i]>alist[i+1]:#如果前一项大于后一项
temp=alist[i]
alist[i]=alist[i+1]
alist[i+1]=temp #调换顺序
alist=[54,26,93,17,77,31,44,55,20]
bubbleSort(alist)
print(alist)#证明排序之后，改变了原列表顺序
#短冒泡排序
def shortBubbleSort(alist):
exchanges = True
passnum = len(alist)-1
while passnum > 0 and exchanges:
exchanges = False
for i in range(passnum):#第一次遍历，的确是n-1次
if alist[i]>alist[i+1]:#如果有需要交换的，如果这次遍历从头到尾不需要交换，那么exchanges这个变量就保持false状态。这次遍历不需要交换说明这次遍历中遍历的数据都已经排好，再加上后面已经排好的，整个list就完全排好了，直接结束while 语句，输出alist即可。
exchanges = True
temp=alist[i]
alist[i]=alist[i+1]
alist[i+1]=temp
passnum = passnum -1
alist = [17, 20, 26, 31, 44, 54, 55, 77, 93]
shortBubbleSort(alist)
print(alist)
#选择排序
def selectionSort(alist):
for fillslot in range(len(alist)-1,0,-1):
positionOfMax = 0#每次遍历开始前都要初始化一下
for location in range(1,fillslot+1):#遍历每一个位置，找到其中最大的，赋值给positionOfMax
if alist[location]>alist[positionOfMax]:
positionOfMax = location
temp = alist[fillslot]
alist[fillslot] = alist[positionOfMax]
alist[positionOfMax] = temp#每次遍历完一遍，就把这个最大值所对应的位置的元素跟index=fillslot的元素进行调换（注意，fillslot每遍历一遍都会减一）
alist=[54,26,93,17,77,31,44,55,20]
selectionSort(alist)
print(alist)
#插入排序
def insertSort(alist):
for index in range(1,len(alist)):#目前要被插入的队列只有最前面的那个元素，即Index=0
currentValue = alist[index]#依次取index=1,2....的值
position = index#初始化position至当前index
while position>0 and alist[position-1]>currentValue:#如果没到开头且前一个值大于当前值,(遍历前面已经排好序的列表，直到到开头或者找到一个合适的位置)
alist[position]=alist[position-1]#就把前一个值赋值给当前位置
position = position-1#将当前定位减一，即依次向前移
alist[position]=currentValue#把这个要插入的值排在前面已经拍好序列的position的位置
alist=[54,26,93,17,77,31,44,55,20]
insertSort(alist)
print(alist)
#希尔排序
def shellSort(alsit):
sublistcount = len(alist)//2
while sublistcount > 0 :
for startposition in range(sublistcount):
gapInsertionSort(alist,startposition,sublistcount)
print('After increment of size',sublistcount,'The list is',alist)
sublistcount = sublistcount//2
def gapInsertionSort(alist,start,gap):
for i in range(start+gap,len(alist),gap):
currentvalue = alist[i]
position = i
while position>=gap and alist[position-gap]>currentvalue:
alist[position]=alist[position-gap]
position = position-gap
alist[position]=currentvalue
alist=[54,26,93,17,77,31,44,55,20]
shellSort(alist)
print(alist)
#归并排序（Merge Sort Method)
def mergeSort(alist):
print('Splitting ',alist)
if len(alist)>1:
mid = len(alist)//2
lefthalf = alist[:mid]
righthalf = alist[mid:]#分裂的过程,分成左右半边
mergeSort(lefthalf)
mergeSort(righthalf)#执行递归的操作，将会一直分裂下去，直到成1
i=0
j=0
k=0
while i <len(lefthalf) and j <len(righthalf):#控制条件是i和j只要有一个遍历完成结束
if lefthalf[i] < righthalf[j]:#如果左边列第i个小于右边列第J个，就将较小的赋值给合并后排序集合，用完了这个i就i=i+1
alist[k] = lefthalf[i]
i = i+1
else:#右边j元素小，就赋值j，然后用完了这个j，就j=j+1
alist[k]=righthalf[j]
j = j+1
k =k+1
while i <len(lefthalf):#由于上一个控制语句最后返回要么是i已经最大，或者j已经到达最大，所以这个和下一个控制语句都是做结尾的工作（因为lefthalf和righthalf 都是已经排好序的，所以谁要是被剩下了，就把剩下的元素直接添加到alist结尾即可
alist[k]=lefthalf[i]
i=i+1
k=k+1
while j<len(righthalf):
alist[k]=righthalf[j]
j=j+1
k=k+1
print('Merging ',alist)
alist=[54,26,93,17,77,31,44,55,20]
mergeSort(alist)
print(alist)#由最后输出的结果可以很好的得出各语句执行的顺序
#快速排序
def quickSort(alist):#只接受一个参数，但是接下来把要用到的其他二级参数都转化了出来，就不用用户手动输入这些数据了
quickSortHelper(alist,0,len(alist)-1)
def quickSortHelper(alist,first,last):#这个函数的用意是每次在splitpoint处将alist递归分割
if first<last:
splitpoint = partition(alist,first,last)#splitpoint计算过程，这个partition函数返回pivot插入点所在的index，作为分裂点
quickSortHelper(alist,first,splitpoint-1)
quickSortHelper(alist,splitpoint+1,last)
def partition(alist,first,last):
pivotvalue = alist[first]#由于最开始是零，因此第一个选取的pivot点是第一个元素
leftmark = first + 1#左指针定在了povit后面
rightmark = last#last值为len(alist)-1,即最后一个元素的index号
done = False
while not done:
while leftmark<=rightmark and alist[leftmark]<=pivotvalue:#如果左指针对应的这个数小于枢纽数，那么就位置不变，指针向下一位移动（向右移）否则就进行不下去。最终的状态是直到移到不能移，即需要swap的位置
leftmark = leftmark +1
while alist[rightmark]>=pivotvalue and rightmark>=leftmark:#如果右指针对应的这个数大于枢纽数，位置不变，指针向下一位移动（向左移）
rightmark = rightmark-1
if rightmark<leftmark:#说明全长不需要排列就好了或者经过swap后全长都排列好了
done = True#结束while not done 循环
else:#这个是一般情况，就swap一下
temp = alist[leftmark]
alist[leftmark] = alist[rightmark]
alist[rightmark] = temp
temp = alist[first]#把rightmark对应的元素和pivot置换一下，即把pivot换到合适的位置
alist[first] = alist[rightmark]
alist[rightmark] = temp
return rightmark#每次使用此partition函数都相当于遍历了一遍然后返回rightmark的index
alist=[54,26,93,17,77,31,44,55,20]
quickSort(alist)
print(alist)
#树的结构
myTree = ['a',['b',['d',[],[]],['e',[],[]],['c',['f',[],[]],[]]]]
print(myTree)
print('left subtree = ',myTree[1])
print('root=',myTree[0])
print('right subtree =',myTree[2])
def BinaryTree(r):
return [r,[],[]]#简单的构造一个具有根节点和两个子列表为空的列表
#插入左子节点
def insertLeft(root,newBranch):
t= root.pop(1)#树就像是一个栈，弹出root第二个元素，左子节点
if len(t) > 1:#如果内容长度大于1
root.insert(1,[newBranch,t,[]])
else:
root.insert(1,[newBranch,[],[]])
return root#注意，要插入一个左子节点，我们首先获得与当前左子节点对应的列表。然后我们添加新的左子树，添加旧的左子树作为新子节点的左子节点
#插入右子节点
def insertRight(root,newBranch):
t= root.pop(2)#树就像是一个栈，弹出root第三个元素，右子节点
if len(t) > 1:#如果有内容的话，就插入节点然后再安回来
root.insert(2,[newBranch,t,[]])
else:#如果没内容的话就直接插入
root.insert(2,[newBranch,[],[]])
return root
def getRootVal(root):#获取根节点
return root[0]
def setRootVal(root,newVal):#设置根节点的值
root[0] = newVal
def getLeftChild(root):#获得左分支
return root[1]
def getRightChild(root):#获得右分支
return root[2]
##################以上是列表表示树的结构###############################
##################以下是节点表示树的结构###############################
class BinaryTree:
def __init__(self,rootObj):
self.key = rootObj
self.leftChild = None
self.rightChild = None
def insertLeft(self,newNode):
if self.leftChild ==None:#插入左子节点，如果左子节点没内容，就直接将新节点赋值
self.leftChild = BinaryTree(newNode)
else:#若已经有内容，则插入这个节点并将现有子节点放到树的下一层
t = BinaryTree(newNode)
t.leftChild = self.leftChild
self.leftChild = t
def insertRight(self,newNode):
if self.rightChild ==None:#插入左子节点，如果左子节点没内容，就直接将新节点赋值
self.rightChild = BinaryTree(newNode)
else:#若已经有内容，则插入这个节点并将现有子节点放到树的下一层
t = BinaryTree(newNode)
t.rightChild = self.rightChild
self.rightChild = t
def getRightChild(self):
return self.rightChild
def getLeftChild(self):
return self.leftChild
def setRootVal(self,obj):
self.key = obj
def getRootVal(self):
return self.key
r = BinaryTree('a')
print(r.getRootVal())
print(r.getLeftChild())
#利用栈和双叉树，创建四则运算分析树
from pythonds.basic.stack import Stack
from pythonds.trees.binaryTree import BinaryTree#导入Stack和BinaryTree模块
def buildParseTree(fpexp):#参数是正常的数学表达式
fplist = fpexp.split()
pStack = Stack()
eTree = BinaryTree('')#创建空的二叉树
pStack.push(eTree)#把此二叉树推到栈中
currentTree = eTree
for i in fplist:#下面是四则运算的实现过程
if i == '(':
currentTree.insertLeft('')#插入空的左子节点
pStack.push(currentTree)#推到栈中
currentTree = currentTree.getLeftChild()#把指针移到左子节点上
elif i not in ['+','-','*','/',')']:#如果i是操作数
currentTree.setRootVal(i)#那么就将这个操作数作为一个object,写入当前节点
currentTree.insertRight('')#并且插入父节点的右节点
pStack.push(currentTree)#将完成这些操作 的currentTree压入栈中
currentTree = currentTree.getRightChild()#指针指到右子节点
elif i == ')':#如果是此操作符
currentTree = pStack.pop()#将pstack弹出，返回到current里面，使得当前节点返回父节点
else:
raise ValueError
return eTree#返回etree
pt = buildParseTree('((10+5)*3)')
#pt.postorder()
def evaluate(parseTree):#对树所进行的递归算法基本情况是检查叶节点
opers = {'+':operator.add,'-':operator.sub,'*':operator.mul,'/':operator.truediv}
leftC = parseTree.getLeftChild()
rightC = parseTree.getRightChild()
if leftC and rightC:
fn = opers[parseTree.getRootVal()]
return fn(evaluate(leftC),evaluate(rightC))
else:
return parseTree.getRootVal()
#遍历树结构方法一 前序遍历
def preorder(tree):#(这种方式更好)
if tree:#基本情况只是检查树是否存在
print(tree.getRootVal())
preorder(tree.getLeftChild())
preorder(tree.getRightChild())
#或者把preorder作为BinaryTree类的一个方法
def preorder(self):
print(self.key)
if self.leftChild:
self.leftChild.preorder()
if self.rightChild:
self.rightChild.preorder()
#遍历数结构方法二 后序遍历
def preorder(tree):#(这种方式更好)
if tree != None:#基本情况只是检查树是否存在
preorder(tree.getLeftChild())
preorder(tree.getRightChild())
print(tree.getRootVal())
def postordereval（tree):#后序遍历实例
opers = {'+':operator.add,'-':operator.sub,'*':operator.mul,'/':operator.truediv}
res1 = None
res2 = None
if tree:
res1 = postordereval（tree.getLeftChild())
res2 = postordereval（tree.getRightChild())#先获取左右节点
if res1 and res2:
return opers[tree.getRootVal()](res1,res2)#最后通过操作符的函数调用在根节点中组合他们
else:
return tree.getRootVal()
#遍历数结构方法三 中序遍历
def preorder(tree):#(这种方式更好)
if tree != None:#基本情况只是检查树是否存在
preorder(tree.getLeftChild())
print(tree.getRootVal())
preorder(tree.getRightChild())
def printexp(tree):#实例，恢复表达式
sVal = ''
if tree:
sVal = '(' + printexp(tree.getLeftChild())#获取左子树
sVal = sVal + str(tree.getRootVal())#获取根节点
sVal = sVal + printexp(tree.getRightChild())+')'#再获取右子树
return sVal
#实现二叉树的最小堆结构
from pythonds.trees.binheap import BinHeap
bh = BinHeap()
bh.insert(5)
bh.insert(7)
bh.insert(3)
bh.insert(11)
print(bh.delMin())
print(bh.delMin())
print(bh.delMin())
print(bh.delMin())
#二叉堆类的定义
class BinHeap:
def __init__(self):
self.heapList = [0]#这个零放在这里为了之后简单的整数除法
self.currentSize = 0
def percUp(self,i):
while i//2 >0:#也就是说，i不取0不取1都可以,即向上swap 到最顶层为止
if self.heapList[i] < self.heapList[i//2]:#子节点小于父节点
tem = self.heapList[i//2]#将执行swap 操作
self.heapList[i//2] = self.heapList[i]
self.heapList[i] = tmp
i = i//2#子节点大于父节点，就不执行任何操作
def insert(self,k):
self.heapList.append(k)
self.currentSize = self.currentSize + 1
self.percUp(self.currentSize)#我们写Insert函数的时候当然是先写insert,困难的部分由辅助函数处理，但是运行的时候辅助函数要先表示出来
def percDown(self,i):#i 是父节点，i*2是其子节点 本函数确保最大的子节点总是沿着树向下移动
while (i*2)<= self.currentSize:
mc = self.minChild(i)#minChild返回最小的节点的那个Index
if self.heapList[i] > self.heapList[mc]:#若父节点大于子节点，那么就交换
tmp = self.heapList[i]#将执行swap 操作
self.heapList[i] = self.heapList[mc]
self.heapList[mc] = tmp
i = mc
def minChild(self,i):
if i*2 +1 >self.currentSize:#如果子节点编号超出了树的大小，说明不存在
return i*2#返回左节点
else:
if self.heapList[i*2]<self.heapList[i*2+1]:#如果左节点小于右节点，返回左节点
return i*2
else:#否则返回右节点
return i*2+1
def delMin(self):
retval = self.heapList[1]
self.heapList[1] = self.heapList[self.currentSize]
self.currentSize = self.currentSize -1
self.heapList.pop()
self.percDown(1)
return retval
def buildHeap(self,alist):#从键列表构建一个新的堆
i = len(alist)//2
self.currentSize = len(alist)
self.heapList = [0] + alist[:]
while (i>0):
self.percDown(i)
i = i-1 #都不带返回值的？什么意思？
bh = BinHeap()
bh.buildHeap([9,5,6,2,3])#直接利用添加列表构建一个最小堆二叉树
print(bh.delMin())#先被删除的是2
print(bh.delMin())#再被删除的是3
#二叉搜索树
class TreeNode:
def __init__(self,key,val,left=None,right=None,parent=None):
self.key = key
self.payload =val
self.leftChild = left
self.rightChild = right
self.parent =parent
def hasLeftChild(self):
return self.leftChild
def hasRightChild(self):
return self.rightChild
def isLeftChild(self):
return self.parent and self.parent.leftChild == self
def isRightChild(self):
return self.parent and self.parent.rightChild == self
def isRoot(self):
return not self.parent#返回boolean
def isLeaf(self):
return not (self.rightChild or self.leftChild)#返回boolean
def hasAnyChildren(self):
return self.rightChild or self.leftChild
def hasBothChildren(self):
return self.rightChild and self.leftChild
def replaceNodeData(self,key,value,lc,rc):
self.key = key
self.payload = value
self.leftChild = lc
self.rightChild = rc
if self.hasLeftChild():
self.leftChild.parent = self
if self.hasRightChild():
self.rightChild.parent = self
class BinarySearchTree:
def __init__(self):
self.root = None
self.size = 0
def length(self):
return self.size
def __len__(self):
return self.size
def put(self,key,val):
if self.root:
self._put(key,val,self.root)
else:
self.root = TreeNode(key,val)
self.size = self.size + 1
def _put(self,key,val,currentNode):
if key<currentNode.key:
if currentNode.hasLeftChild():
self._put(key,value,currentNode.leftChild)
else:
currentNode.leftChild = TreeNode(key,val,parent=currentNode)
else:
if currentNode.hasRightChild():
self._put(key,val,currentNode.rightChild)
else:
currentNode.rightChild = TreeNode(key,val,parent=currentNode)
def __setitem__(self,k,v):
self.put(k,v)
def get(self,key):
if self.root:
res = self._get(key,self.root)
if res :
return res.payload
else:
return None
else:
return None
def _get(self,key,currentNode):
if not currentNode:
return None
elif currentNode.key ==key:
return currentNode
elif key< currentNode.key:
return self._get(key,currentNode.leftChild)
else:
return self._get(key,currentNode.rightChild)
def __iter__(self):
return self.root.__iter__()
#################y有时间再补全####################
#邻接表的实现
class Vertex:#Vertex Shell
def __init__(self,key):
self.id = key
self.connectedTo = {}
def addNeighbor(self,nbr,weight = 0):#添加邻接点和权重
self.connectedTo[nbr] = weight
def __str__(self):
return str(self.id +'connectedTo: ' + str([x.id for x in self.connectedTo]))
def getConnections(self):#看connect到的另外几个节点是什么
return self.connectedTo.keys()
def getId(self):#获取有无此id的key
return self.id
def getWeight(self,nbr):#获取目标的权重
return self.connectedTo[nbr]
class Graph:#graph类实现了添加顶点，获取节点，添加边，in方法，遍历的magic method
def __init__(self):
self.vertList = {}
self.numVertices = 0
def addVertex(self,key):
self.numVertices = self.numVertices + 1
newVerex = Vertex(key)
self.vertList[key] = newVerex
return newVerex
def getVertex(self,n):
if n in self.vertList:
return self.vertList[n]
else:
return None
def __contains__(self,n):
return n in self.vertList
def addEdge(self,f,t,cost=0):
if f not in self.vertList:
nv = self.addVertex(f)
if t not in self.vertList:
nv = self.addVertex(t)
self.vertList[f].addNeighbor(self.vertList[t],cost)
def getVertices(self):
return self.vertList.keys()
def __iter__(self):
return iter(self.vertList.values())
g = Graph()
for i in range(6):
g.addVertex(i)
print(g.vertList)
g.addEdge(0,1,5)
g.addEdge(0,5,2)
g.addEdge(1,2,4)
g.addEdge(2,3,9)
g.addEdge(3,4,7)
g.addEdge(3,5,3)
g.addEdge(4,0,1)
g.addEdge(5,4,8)
g.addEdge(5,2,1)
for v in g:
for w in v.getConnections():
print('(%s,%s)'%(v.getId(),w.getId()))
#字梯问题 构建图
from pythonds.graphs import Graph
def buildGraph(wordFile):
d = {}
g = Graph()
wfile = open(wordFile,'r')#以读取方式打开文件
for line in wfile:
word = line[:-1]
for i in range(len(word)):#创建buckets of words that differ by one letter
bucket = word[:i]+'-'+word[i+1:]#对每个位置都创建一个空格
if bucket in d:
d[bucket].append(word)#把初始的附在每个桶里
else:
d[bucket] = [word]
for bucket in d.keys():#add vertices and edges for words in the same bucket
for word1 in d.keys():
for word2 in d[bucket]:
if word1 != word2:
g.addEdge(word1,word2)
return g
#现在我们可以把注意力转向最短解
from pythonds.graphs import Graph,Vertex
from pythonds.basic import Queue
def bfs(g,start):
start.setDistance(0)
start.setPred(None)
vertQueue = Queue()
vertQueue.enqueue(start)
while (vertQueue.size()>0):
currentVert = vertQueue.dequeue()
for nbr in currentVert.getConnections():
if (nbr.getColor()=='white'):
nbr.setColor('gray')
nbr.setDistance(currentVert.getDistance()+1)
nbr.setPred(currentVert)
vertQueue.enqueue(nbr)
currentVert.setColor('black')
#骑士之旅 深度优先搜索
from pythonds.graphs import Graph
def knightGraph(bdSize):#在整个板上进行一次遍历
ktGraph = Graph()
for row in range(bdSize):
nodeId = posToNodeId(row,col,bdSize)
newPositions = genLegalMoves(row,col,bdSize)#为板上的位置创建一个移动列表，所有的移动在图形中转化为边
for e in newPositions:
nid = posToNodeId(e[0],e[1],bdSize)
ktGraph.addEdge(nodeId,nid)
return ktGraph
def posToNodeId(row,column,board_size):#把位置转化成node ID
return (row*board_size)+column
def genLegalMoves(x,y,bdSize):#利用当前骑士的位置 生成八个合法的可能的移动中的一个
newMoves =[]
moveOffsets = [(-1,-2),(-1,2),(-2,-1),(-2,1),(1,-2),(1,2),(2,-1),(2,1)]
for i in moveOffsets:#遍历所有可能移动
newX = x + i[0]
newY = y + i[1]
if legalCoord(newX,bdSize) and legalCoord(newY,bdSize):
newMoves.append((newX,newY))
return newMoves
def legalCoord(x,bdSize):#
if x>=0 and x< bdSize:#如果还在棋盘范围内，那么就是可以继续操作
return True
else:#否则不行
return False
#深度优先搜索算法一 解决骑士问题
from pythonds.graphs import Graph,Vertex
def knightTour(n,path,u,limit):#四个参数，n表示树中的当前深度。path,表示到此为止访问过的顶点的列表 u,图中希望探索的顶点。limit 路径中的节点数 这个函数是递归的
u.setColor('gray')#未访问的节点是白色的，访问过是灰色的
path.append(u)
if n < limit:
nbrList = list(u.getConnections())
i = 0
done = False
while i<len(nbrList) and not done:
if nbrList[i].getColor()=='white':
done = knightTour(n+1,path,nbrList[i],limit)
i = i+1
if not done:
path.pop()
u.setColor('white')
else:#如果返回一个正好包含所有节点的路径，就说明成功了
done = True
return done
#最短加权路径的Dijkstra算法
from pythonds.graphs import PriorityQueue, Graph, Vertex
def dijkstra(aGraph, start):#参数是图 和 给定的开始节点
pq = PriorityQueue()#优先级队列（这种类储存键值对的元组，值用于确定优先级即确定键在队列中的位置，键是顶点。在这个算法中，我们使用到顶点的距离作为优先级，因为探索下一个顶点总要探索距离最近的顶点
start.setDistance(0)
pq.buildHeap([v.getDistance(),v] for v in aGraph)
while not pq.isEmpty():
currentVert= pq.delMin()
for nextVert in currentVert.getConnections():
newDist = currentVert.getDistance() + currentVert.getWeight(nextVert)
if newDist < nextVert.getDistance():
nextVert.setDistance(newDist)
nextVert.setPred(currentVert)
pq.decreaseKey(nextVert, newDist)#使用优先级队列类中的decreaseKey方法
#贪心算法のprim算法：
from pythonds.graphs import PriorityQueue, Graph, Vertex
def prim(G,start):
pq = PriorityQueue()
for v in G:
v.setDistance(sys.maxsize)
v.setPred(None)
start.setDistance(0)
pq.buildHeap([v.getDistance(),v] for v in G)
while not pq.isEmpty():
currentVert = pq.delMin()
for nextVert in currentVert.getConnections():
newCost = currentVert.getWeight(nextVert)
if nextVert in pq and newCost<nextVert.getDistance():
nextVert.setPred(currentVert)
nextVert.setDistance(newCost)
pq.decreaseKey(nextVert,newCost)
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
