MOOC数据结构与算法Python版-第四周编程作业
1 有序队列（10分）
题目内容：
一开始给出了一个由小写字母组成的字符串 S。我们规定每次移动中，选择最左侧的字母，将其从原位置移除，并加到字符串的末尾。这样的移动可以执行任意多次
返回我们移动之后可以拥有的最小字符串（注：在Python3中，字符串的大小可用不等号比较）。
输入格式:
S。S为仅含有小写字母的字符串，长度不超过100000。
输出格式：
一个与S等长的字符串。
输入样例：
"cba"
输出样例：
acb
代码模板(建议复制粘贴使用)：
- def func(S):
- # your code here
- return output
- S = eval(input())
- print(func(S))
时间限制：500ms内存限制：32000kb
解题思思路1：
应用队列的先进先出特点，设置最开始的字符串为最小值，不断的将最后一个字母出队列，然后再将这个字母入队列，与设置的字符串进行比较，若小于的话，则替换最小值，若大于的话，继续出队列、入队列。直到将字符串的所有情况都遍历一遍。
程序代码1：
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)
def func(S):
q = Queue()
min_str = S
temp = 0
for i in S:
q.enqueue(i)
while(temp<=q.size()):
first = q.dequeue()
q.enqueue(first)
new_list = ''.join(q.items)[::-1]
if new_list < min_str:
min_str = new_list
temp = temp + 1
print(min_str)
解题思路2：
利用对字符串切片处理，直接将最后一个字母拼接到后面，然后进行比较得最小字符串。
程序代码2 ：
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]
代码模板(建议复制粘贴使用)：
- def func(mylist):
- # your code here
- return output
- mylist = eval(input())
- print(func(mylist))
时间限制：500ms内存限制：32000kb
解题思路：
应用队列先进先出的特点，先入队第一个元素进行计算，然后再加新的元素入队，同时循环判断队列首元素减去队尾元素是否大于10000，若大于的话，将队尾元素删除，否则返回队列的长度即为处于范围之间的元素个数。
这里一定要注意的是，已排序列表中可能会有相同的值，所以需要一个计数器来记录，重复值出现了几次。
程序代码：
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)
def func(mylist):
new_list = []
output = []
temp = 0
q = Queue()
for i in mylist:
q.enqueue(i)
# print(q.items)
while(temp 10000:
new_list.pop(0)
sum = 0
for i in reversed(q.items):
if i == new_list[-1]:
sum = sum + 1
else:
break
if sum != 0:
output.append(len(new_list)+sum)
else:
output.append(len(new_list))
temp = temp + 1
print(output)
mylist = eval(input())
func(mylist)
3 基数排序（10分）
题目内容：
实现一个基数排序算法，用于10进制的正整数从小到大的排序。
思路是保持10个队列(队列0、队列1......队列9、队列main)，开始，所有的数都在main队列，没有排序。
第一趟将所有的数根据其10进制个位(0~9)，放入相应的队列0~9，全放好后，按照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]
代码模板(建议复制粘贴使用)：
- def func(mylist):
- # your code here
- return output
- mylist = eval(input())
- print(func(mylist))
时间限制：500ms内存限制：32000kb
解题思路：
基数排序是八大排序中的一种，排序过程如下：
上述中有一串数值为：3 44 38 5 47 15 36 26 27 2 46 4 19 50 48
首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：
0 ：50
1：
2：2
3：3
4：44 4
5：5 15
6：36 26 46
7：47 27
8：38 48
9：19
第二步
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
50 2 3 44 4 5 15 36 26 46 47 27 38 48 19
接着再进行一次分配，这次是根据十位数来分配：
0：2 3 4 5
1：15 19
2：26 27
3：36 38
4：44 46 47 48
5：50
6：
7：
8：
9：
第三步
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
2 3 4 5 15 19 26 27 36 38 44 46 47 48 50
这时候已经排序完成，如果最高位是3位数或者更多，则继续进行上面直到高位数排完为止。
时间效率 ：设待排序列为n个记录，d个关键码，关键码的取值范围为radix，则进行链式基数排序的时间复杂度为O(d(n+radix))，其中，一趟分配时间复杂度为O(n)，一趟收集时间复杂度为O(radix)，共进行d趟分配和收集。 空间效率：需要2*radix个指向队列的辅助空间，以及用于静态链表的n个指针。
程序代码：
def RadixSort(mylist):
i = 0 #初始为个位排序
n = 1 #最小的位数置为1（包含0）
max_num = max(mylist) #得到带排序数组中最大数
while max_num >= 10**n: #得到最大数是几位数
n += 1
while i < n:
bucket = {} #用字典构建桶
for x in range(10):
bucket.setdefault(x, []) #将每个桶置空
for x in mylist: #对每一位进行排序
radix =int((x / (10**i)) % 10) #得到每位的基数
bucket[radix].append(x) #将对应的数组元素加入到相应位基数的桶中
j = 0
for k in range(10):
if len(bucket[k]) != 0: #若桶不为空
for y in bucket[k]: #将该桶中每个元素
mylist[j] = y #放回到数组中
j += 1
i += 1
if __name__ == '__main__':
mylist = eval(input())
RadixSort(mylist)
print(mylist)