第一次添加

内容包括PDF版教材，北大陈斌python数据结构课的课件以及pythonds数据结构实现的源代码

Author: zhou123033

2022数据结构与算法B/pythonds/__init__.py

@@ -0,0 +1,8 @@
+
+#__all__ = ["stack"]
+
+
+from .stack import Stack
+from .queue import Queue
+
+

2022数据结构与算法B/pythonds/__pycache__/__init__.cpython-32.pyc

@@ -0,0 +1,28 @@
+# Bradley N. Miller, David L. Ranum
+# Introduction to Data Structures and Algorithms in Python
+# Copyright 2005
+# 
+#deque.py
+
+
+class Deque:
+    def __init__(self):
+        self.items = []
+
+    def isEmpty(self):
+        return self.items == []
+
+    def addFront(self, item):
+        self.items.append(item)
+
+    def addRear(self, item):
+        self.items.insert(0,item)
+
+    def removeFront(self):
+        return self.items.pop()
+
+    def removeRear(self):
+        return self.items.pop(0)
+
+    def size(self):
+        return len(self.items)

2022数据结构与算法B/pythonds/basic/__init__.py

@@ -0,0 +1,21 @@
+# Bradley N. Miller, David L. Ranum
+# Introduction to Data Structures and Algorithms in Python
+# Copyright 2005
+# 
+#queue.py
+
+class Queue:
+    def __init__(self):
+        self.items = []
+
+    def isEmpty(self):
+        return self.items == []
+
+    def enqueue(self, item):
+        self.items.insert(0,item)
+
+    def dequeue(self):
+        return self.items.pop()
+
+    def size(self):
+        return len(self.items)

2022数据结构与算法B/pythonds/basic/__pycache__/__init__.cpython-32.pyc

@@ -0,0 +1,25 @@
+# Bradley N. Miller, David L. Ranum
+# Introduction to Data Structures and Algorithms in Python
+# Copyright 2005
+# 
+#stack.py
+
+class Stack:
+    def __init__(self):
+        self.items = []
+
+    def isEmpty(self):
+        return self.items == []
+
+    def push(self, item):
+        self.items.append(item)
+
+    def pop(self):
+        return self.items.pop()
+
+    def peek(self):
+        return self.items[len(self.items)-1]
+
+    def size(self):
+        return len(self.items)
+

2022数据结构与算法B/pythonds/basic/__pycache__/queue.cpython-32.pyc

@@ -0,0 +1,5 @@
+
+
+from .adjGraph import Graph
+from .adjGraph import Vertex
+from .priorityQueue import PriorityQueue

2022数据结构与算法B/pythonds/basic/__pycache__/stack.cpython-32.pyc

@@ -0,0 +1,122 @@
+#
+#  adjGraph
+#
+#  Created by Brad Miller on 2005-02-24.
+#  Copyright (c) 2005 Brad Miller, David Ranum, Luther College. All rights reserved.
+#
+
+import sys
+import os
+import unittest
+
+class Graph:
+    def __init__(self):
+        self.vertices = {}
+        self.numVertices = 0
+        
+    def addVertex(self,key):
+        self.numVertices = self.numVertices + 1
+        newVertex = Vertex(key)
+        self.vertices[key] = newVertex
+        return newVertex
+    
+    def getVertex(self,n):
+        if n in self.vertices:
+            return self.vertices[n]
+        else:
+            return None
+
+    def __contains__(self,n):
+        return n in self.vertices
+    
+    def addEdge(self,f,t,cost=0):
+            if f not in self.vertices:
+                nv = self.addVertex(f)
+            if t not in self.vertices:
+                nv = self.addVertex(t)
+            self.vertices[f].addNeighbor(self.vertices[t],cost)
+    
+    def getVertices(self):
+        return list(self.vertices.keys())
+        
+    def __iter__(self):
+        return iter(self.vertices.values())
+                
+class Vertex:
+    def __init__(self,num):
+        self.id = num
+        self.connectedTo = {}
+        self.color = 'white'
+        self.dist = sys.maxsize
+        self.pred = None
+        self.disc = 0
+        self.fin = 0
+
+    # def __lt__(self,o):
+    #     return self.id < o.id
+    
+    def addNeighbor(self,nbr,weight=0):
+        self.connectedTo[nbr] = weight
+        
+    def setColor(self,color):
+        self.color = color
+        
+    def setDistance(self,d):
+        self.dist = d
+
+    def setPred(self,p):
+        self.pred = p
+
+    def setDiscovery(self,dtime):
+        self.disc = dtime
+        
+    def setFinish(self,ftime):
+        self.fin = ftime
+        
+    def getFinish(self):
+        return self.fin
+        
+    def getDiscovery(self):
+        return self.disc
+        
+    def getPred(self):
+        return self.pred
+        
+    def getDistance(self):
+        return self.dist
+        
+    def getColor(self):
+        return self.color
+    
+    def getConnections(self):
+        return self.connectedTo.keys()
+        
+    def getWeight(self,nbr):
+        return self.connectedTo[nbr]
+                
+    def __str__(self):
+        return str(self.id) + ":color " + self.color + ":disc " + str(self.disc) + ":fin " + str(self.fin) + ":dist " + str(self.dist) + ":pred \n\t[" + str(self.pred)+ "]\n"
+    
+    def getId(self):
+        return self.id
+
+class adjGraphTests(unittest.TestCase):
+    def setUp(self):
+        self.tGraph = Graph()
+        
+    def testMakeGraph(self):
+        gFile = open("test.dat")
+        for line in gFile:
+            fVertex, tVertex = line.split('|')
+            fVertex = int(fVertex)
+            tVertex = int(tVertex)
+            self.tGraph.addEdge(fVertex,tVertex)
+        for i in self.tGraph:
+            adj = i.getAdj()
+            for k in adj:
+                print(i, k)
+
+        
+if __name__ == '__main__':
+    unittest.main()
+              

2022数据结构与算法B/pythonds/basic/deque.py

@@ -0,0 +1,117 @@
+# Bradley N. Miller, David L. Ranum
+# Introduction to Data Structures and Algorithms in Python
+# Copyright 2005
+# 
+import unittest
+
+# this implementation of binary heap takes key value pairs,
+# we will assume that the keys are all comparable
+
+class PriorityQueue:
+    def __init__(self):
+        self.heapArray = [(0,0)]
+        self.currentSize = 0
+
+    def buildHeap(self,alist):
+        self.currentSize = len(alist)
+        self.heapArray = [(0,0)]
+        for i in alist:
+            self.heapArray.append(i)
+        i = len(alist) // 2            
+        while (i > 0):
+            self.percDown(i)
+            i = i - 1
+                        
+    def percDown(self,i):
+        while (i * 2) <= self.currentSize:
+            mc = self.minChild(i)
+            if self.heapArray[i][0] > self.heapArray[mc][0]:
+                tmp = self.heapArray[i]
+                self.heapArray[i] = self.heapArray[mc]
+                self.heapArray[mc] = tmp
+            i = mc
+                
+    def minChild(self,i):
+        if i*2 > self.currentSize:
+            return -1
+        else:
+            if i*2 + 1 > self.currentSize:
+                return i*2
+            else:
+                if self.heapArray[i*2][0] < self.heapArray[i*2+1][0]:
+                    return i*2
+                else:
+                    return i*2+1
+
+    def percUp(self,i):
+        while i // 2 > 0:
+            if self.heapArray[i][0] < self.heapArray[i//2][0]:
+               tmp = self.heapArray[i//2]
+               self.heapArray[i//2] = self.heapArray[i]
+               self.heapArray[i] = tmp
+            i = i//2
+ 
+    def add(self,k):
+        self.heapArray.append(k)
+        self.currentSize = self.currentSize + 1
+        self.percUp(self.currentSize)
+
+    def delMin(self):
+        retval = self.heapArray[1][1]
+        self.heapArray[1] = self.heapArray[self.currentSize]
+        self.currentSize = self.currentSize - 1
+        self.heapArray.pop()
+        self.percDown(1)
+        return retval
+        
+    def isEmpty(self):
+        if self.currentSize == 0:
+            return True
+        else:
+            return False
+
+    def decreaseKey(self,val,amt):
+        # this is a little wierd, but we need to find the heap thing to decrease by
+        # looking at its value
+        done = False
+        i = 1
+        myKey = 0
+        while not done and i <= self.currentSize:
+            if self.heapArray[i][1] == val:
+                done = True
+                myKey = i
+            else:
+                i = i + 1
+        if myKey > 0:
+            self.heapArray[myKey] = (amt,self.heapArray[myKey][1])
+            self.percUp(myKey)
+            
+    def __contains__(self,vtx):
+        for pair in self.heapArray:
+            if pair[1] == vtx:
+                return True
+        return False
+        
+class TestBinHeap(unittest.TestCase):
+    def setUp(self):
+        self.theHeap = PriorityQueue()
+        self.theHeap.add((2,'x'))
+        self.theHeap.add((3,'y'))
+        self.theHeap.add((5,'z'))
+        self.theHeap.add((6,'a'))
+        self.theHeap.add((4,'d'))
+
+
+    def testInsert(self):
+        assert self.theHeap.currentSize == 5
+
+    def testDelmin(self):
+        assert self.theHeap.delMin() == 'x'
+        assert self.theHeap.delMin() == 'y'
+    
+    def testDecKey(self):
+        self.theHeap.decreaseKey('d',1)
+        assert self.theHeap.delMin() == 'd'
+        
+if __name__ == '__main__':
+    unittest.main()

2022数据结构与算法B/pythonds/basic/queue.py

@@ -0,0 +1,8 @@
+
+
+
+from .balance import AVLTree
+from .bst import BinarySearchTree
+from .binheap import BinHeap
+
+