数据结构与算法Python版——第四周作业
1有序队列（10分）
题目内容：
一开始给出了一个由小写字母组成的字符串 S。我们规定每次移动中，选择最左侧的字母，将其从原位置移除，并加到字符串的末尾。这样的移动可以执行任意多次
返回我们移动之后可以拥有的最小字符串（注：在Python3中，字符串的大小可用不等号比较）。
输入格式:
S。S为仅含有小写字母的字符串，长度不超过100000。
输出格式：
一个与S等长的字符串。
输入样例：
“cba”
输出样例：
acb
分析：题目规定 “每次移动中，选择最左侧的字母，将其从原位置移除，并加到字符串的末尾”，这样的操作可以让人联想到 队列的属性：FIFO。
解题思路：
1.先定义队列的类（注意根据题目要求定义：列表左侧为队首（出队），列表右侧为队尾（进队））
2.将目前的字符串设置为最小字符串
3.利用队列对字符串进行变形操作，将每次变形后的字符串，与当前最小字符串比较，如果比当前最小字符串小，则替换最小字符串。
4.利用count计数，总共迭代len(S)-1次，将所有元素都排进队尾一次，形成的字符串全部比较一次。
class Queue(list):
def isEmpty(self):
return self==[]
def enqueue(self,item):
self.append(item)
def dequeue(self):
return self.pop(0)
def peek(self):
return self(-1)
def size(self):
return len(self)
def func(S):
q=Queue()
count=0
min_str=S #将当前的字符串设置为最小字符串
for c in S: #字符串中的所有元素进队
q.enqueue(c)
while count< q.size()-1: #总共迭代变换len(S)-1次
q.enqueue(q.dequeue()) #将队列最左侧的字符 从原位置移动到队列最右（末尾）
new_str="".join(q)
if new_str < min_str: #与当前最小字符串比较，如果比当前最小字符串小，则替换之
min_str = new_str
count+=1 #迭代一次，计数器+1
return min_str
S = eval(input())
print(func(S))
上面这种做法用到了队列的类，但是测试用例4因为运行时间超出，没有通过。
我在CSDN里面查了别人的作业，人家用的字符串切片的方法，优化了运行时间，还是同样的思路，只是把字符串直接当成队列来操作。
def func(S):
min_str=S
for i in range(len(S)):
S=S[1:]+S[0]
if S < min_str: #与当前最小字符串比较，如果比当前最小字符串小，则替换之
min_str = S
return min_str
S = eval(input())
print(func(S))
测试样例全部通过。
2最近的请求次数（10分）
题目内容：
计算每个事件发生之时，往前算10000毫秒内有多少个事件发生，包含当事件；也即对于列表中的每个元素k，算出整个列表中有多少个元素介于k-10000和k（两端均含）之间。
输入格式:
一个已排序列表mylist，所有元素为非负整数，记录各个请求的发生时间，单位为毫秒。
输出格式：
一个与mylist等长的列表。
输入样例：
[0,10,100,1000,10000,20000,100000]
输出样例：
[1,2,3,4,5,2,1]
解题方法：
解题方法1：一开始我是想到遍历列表的方法来做的，对列表中的每一个元素都进行以下操作：
把列表中的元素与当前元素一一比较，符合条件的话计数器+1，最后用列表的append方法，把计数器加进去。
A=[] #创建计数列表
def func(mylist):
for k in mylist: #对列表中的每一个元素都操作一遍
count=0
for j in mylist: #把列表中的每一个元素都比一遍
if k-10000<= j <= k:
count+=1 #列表中出现一个满足条件的元素，计数器+1
A.append(count)
return A
mylist = eval(eval(input()))
print(func(mylist))
但我忽略了这是一个已排序列表，我的这种解法时间复杂度太大O（n**2)，并且没用到任何队列的知识。
解题方法2：
分析：这是一个已排序列表，右边的值都比左边的大。那么在单次循环中，右边的值都不会比当前循环的元素小，不满足i<=k的条件，我们可以省去这部分操作，不去判断当前元素右侧的大值。
我们还需要判断，i>=k-10000的条件，如果列表中的第一个元素不满足，那我们把第一个元素去掉，接着继续判断第二个元素，依次类推，直到列表左侧的元素满足条件。这样，列表中剩下的元素的个数，就是对当前循环元素来说，符合条件的元素个数。
默认不用判断当前元素的右侧元素。
当前循环元素：0，列表是[0]，满足条件0>=0-10000，结果为[1]。
当前循环元素：10，列表是[0,10]，满足条件0>=10-10000，结果为[1，2]
当前循环元素：100，列表是[0,10,100]，满足条件0>=100-10000，结果为[1，2，3]
当前循环元素：1000，列表是[0,10,100,1000]，满足条件0>=1000-10000，结果为[1，2，3，4]
当前循环元素：10000，列表是[0,10,100,1000,10000]，满足条件0>=10000-10000，结果为[1，2，3，4，5]
当前循环元素：20000，列表是[0,10,100,1000,10000,20000]，0>=20000-10000——False，移除列表中的元素：0，当前列表[10,100,1000,10000,20000]；
继续判断：10>=20000-10000——False，移除列表中的元素：10，
当前列表[100,1000,10000,20000]；
继续判断：100>=20000-10000——False，移除列表中的元素：100，
当前列表[1000,10000,20000]；
继续判断：1000>=20000-10000——False，移除列表中的元素：1000，
当前列表[10000,20000]；
继续判断：10000>=20000-10000——True，不再移除，当前列表[10000,20000]；
结果为[1，2，3，4，5，2]
当前循环元素：100000，列表是[0,10,100,1000,10000,20000,100000]，0>=100000-10000——False，移除列表中的元素：0，当前列表[10,100,1000,10000,20000,100000]；
继续判断：10>=100000-10000——False，移除列表中的元素：10，
当前列表[100,1000,10000,20000,100000]；
继续判断：100>=100000-10000——False，移除列表中的元素：100，
当前列表[1000,10000,20000,100000]；
继续判断：1000>=100000-10000——False，移除列表中的元素：1000，
当前列表[10000,20000,100000]；
继续判断：10000>=100000-10000——False，移除列表中的元素：10000，
当前列表[20000,100000]；
继续判断：20000>=100000-10000——False，移除列表中的元素：20000，
当前列表[100000]；
继续判断：100000>=100000-10000——True，不再移除，当前列表[100000]；
结果为[1，2，3，4，5，2，1]
我们可以从上述过程中发现，列表添加元素是在列表的右端，列表移除元素是在列表的左端。
这符合队列的规律（新数据项的添加总发生在一端（通常称为“尾 rear”端） 而现存数据项的移除总发生在另一端（通常称为 “首front”端） ）
1.创建一个队列用来模拟过程，创建一个列表用来记录各个元素中满足条件的元素个数（i>=k-10000）
2.从左往右依次使列表的元素从队列的队首（右端）进入，判断队列的尾端（左端）元素是否满足i>=i-10000，如不满足，删除元素，继续判断左端元素，直到满足条件时停止，统计队列中的元素个数。
3.将统计的个数添加到记录列表中。
#作业2：最近的请求次数————优化运行时间
class Queue(list):
def enqueue(self,item):
self.append(item)
def dequeue(self):
return self.pop(0)
def size(self):
return len(self)
def isEmpty(self):
return self==[]
def func(mylist):
q=Queue() #创建一个队列类的实例对象
ls=[] #创建一个列表用来保存计数
for k in mylist:
q.enqueue(k) #元素进队
while q[0] < k-10000: #当左侧元素不满足条件时，一直进行删除操作
q.dequeue()
ls.append(q.size()) #注意：新生成的列表要求与原列表等长，所以放在原列表的循环下
return ls
mylist = eval(input())
print(func(mylist))
运行后，测试样例没有完全通过，发现，我少考虑了一种情况，就是在原列表中，当前循环元素的右侧元素可能与它相等，如果我们直接不判断它的相等右侧元素，那么统计次数就会比真实的少，所以我们不能忽略，那么我们更改一下列表当前循环元素入队的条件：
#作业2：最近的请求次数————优化运行时间
class Queue(list):
def enqueue(self,item):
self.append(item)
def dequeue(self):
return self.pop(0)
def size(self):
return len(self)
def isEmpty(self):
return self==[]
def func(mylist):
q=Queue() #创建一个队列类的实例对象
ls=[] #创建一个列表用来保存计数
for i in range(len(mylist)):
q.enqueue(mylist[i]) #元素进队
count = 0 #引入计数器，对列表中与当前循环元素相同的元素个数进行统计
for j in range(i+1,len(mylist)):
if mylist[j] == mylist[i]:
count+=1
while q[0] < mylist[i]-10000: #当左侧元素不满足条件时，一直进行删除操作
q.dequeue()
ls.append(q.size()+count) #注意：新生成的列表要求与原列表等长，所以放在原列表的循环下
return ls
mylist = eval(input())
print(func(mylist))
啊西，处理了元素重复问题，运行时间又超了…
搜了一下别人的解法，测试用例全部通过了。
人家没有通过定义队列的类来实现队列，可能减少了不少时间复杂度吧，下面是代码：
def func(mylist):
output = []
new_list = [] # 用列表来模拟队列
for i in range(len(mylist)):
new_list.append(mylist[i])
while new_list[-1] - new_list[0] > 10000:
new_list.pop(0)
count = 0
for j in range(i+1, len(mylist)):
if mylist[j] == mylist[i]:
count += 1
else:
break
output.append(len(new_list)+count)
return output
mylist = eval(input())
print(func(mylist))
原文链接：https://blog.csdn.net/Divine0/article/details/104971270
3基数排序（10分）
题目内容：
实现一个基数排序算法，用于10进制的正整数从小到大的排序。
思路是保持10个队列(队列0、队列1…队列9、队列main)，开始，所有的数都在main队列，没有排序。
第一趟将所有的数根据其10进制个位(09)，放入相应的队列09，全放好后，按照FIFO的顺序，将每个队列的数合并排到main队列。
第二趟再从main队列队首取数，根据其十位的数值，放入相应队列0~9，全放好后，仍然按照FIFO的顺序，将每个队列的数合并排到main队列。
第三趟放百位，再合并；第四趟放千位，再合并。
直到最多的位数放完，合并完，这样main队列里就是排好序的数列了。
输入格式:
一个列表mylist，其中mylist包含一些需要排序的正整数，正整数互不相同且均不超过100000，且个数在1至1000之间。
输出格式：
一个与mylist等长的列表。
输入样例：
[8, 91, 34, 22, 65, 30, 4, 55, 18]
输出样例：
[4, 8, 18, 22, 30, 34, 55, 65, 91]
问题分析：
有一主队列：[8, 91, 34, 22, 65, 30, 4, 55, 18] 要进行排序
第一轮
从左往右将它们从主队列依次出队，根据个位数的数值分配至编号0到9的子队列中：
0 ：30
1：91
2：22
3：
4：34 ， 4
5：65 ，55
6：
7：
8：8， 18
9：
接下来将这些子队列的元素依次出队，进入主队列：
[30，91，22，34，4，65，55，8，18]
可以看出这些数已经按个位数从大到小的顺序排好了
接着再进行一次分配，这次是根据十位数来分配：
0：4，8
1：18
2：22
3：30，34
4：
5：55
6：65
7：
8：
9：91
接下来将这些子队列的元素依次出队，进入主队列：
[4，8，18，22，30，34，55，65，91]
这时候已经排序完成。（在第二轮排序时已经不用管个位数的排序了（第一轮已经排好），所以目前的主队里，在各个数量级上都按从大到小排好了，我们再把各个数量级进行排序就行了）
在别的地方找到的示意图：
如果最高位是3位数或者更多，则继续进行上面直到高位数排完为止
有几位数就需要几轮的排序
1.先找出列表中的最大值
2.确定操作循环次数
n=1
while max(mylist)>10**n:
n+=1 #n已经被修改
for i in range(n): #总共将以下操作进行n次（出主队，进主队）
# your code（出主队，进主队）
那么如何来确定当前提取的数值该进入哪一个子队列呢：
应该是根据该数值在不同数位的基数来进入子队列
for j in range(len(mylist)): #从主队出队次数：队列中原有的元素个数，但不能用队列表示，因为下面的操作改变了队列
num=q_main.dequeue()
radix=int((num/(10**i))%10) #求出num各个数位的基数(技巧）,可以自己推一遍
q[radix].enqueue(num) #num根据基数进入相应的子队列
接下来遍历所有子队列，取出子队列中的数值，放进主队列中
#出子队，进主队
for i in range(10):
while not q[i].isEmpty(): #如果当前子队列不空，就一直让元素从子队列出来，然后进入主队列
q_main.enqueue(q[i].dequeue())
下面是完整代码：
#定义队列的类
class Queue(list):
def enqueue(self,item):
self.append(item)
def dequeue(self):
return self.pop(0)
def size(self):
return len(self)
def isEmpty(self):
return self==[]
def func(mylist):
#创建11个队列：
''' #用列表推导式创建10个队列'''
q=[Queue() for i in range(10)]
'''这个操作会生成一个列表，列表中有十个队列，q[0]~q[9]可以访问。
在之前的课中，我们还用过列表推导式x={j:None for j in range(100)}
l=[i for i in range(1000)]来创建字典，列表等方法'''
q_main=Queue() #创建主队列
for num in mylist: #列表中的元素进队
q_main.enqueue(num)
#计算列表中最大元素的位数——也是我们要进行操作的回合数
n=1
while max(mylist)>10**n:
n+=1 #n已经被修改
for i in range(n): #总共将以下操作进行n次（出主队，进主队）
#出主队,进子队
for j in range(len(mylist)): #出队len(mylist)次
num=q_main.dequeue()
radix=int((num/(10**i))%10) #求出num各个数位的基数(技巧）,可以自己推一遍
q[radix].enqueue(num) #num根据基数进入相应的子队列
#出子队，进主队
for i in range(10):
while not q[i].isEmpty(): #如果当前子队列不空，就一直让元素从子队列出来，然后进入主队列
q_main.enqueue(q[i].dequeue())
return q_main
mylist = eval(input())
print(func(mylist))
但测试样例3未通过，其他测试样例和时间复杂度正常，不知道为什么（可能以后还会回来再看？先就这样吧）