MOOC数据结构与算法Python版-第四周编程作业

1 有序队列（10分）

题目内容：

一开始给出了一个由小写字母组成的字符串 S。我们规定每次移动中，选择最左侧的字母，将其从原位置移除，并加到字符串的末尾。这样的移动可以执行任意多次

返回我们移动之后可以拥有的最小字符串（注：在Python3中，字符串的大小可用不等号比较）。

 

输入格式:

S。S为仅含有小写字母的字符串，长度不超过100000。

 

输出格式：

一个与S等长的字符串。

 

输入样例：

"cba"

 

输出样例：

acb

 

代码模板(建议复制粘贴使用)：

 

1. def func(S):
2.     # your code here
3.     return output
4.      
5. S = eval(input())
6. 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]

 

代码模板(建议复制粘贴使用)：

 

1. def func(mylist):
2.     # your code here
3.     return output
4.      
5. mylist = eval(input())
6. 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<len(mylist)):
        first = q.dequeue()
        new_list.append(first)

        while new_list[-1] - new_list[0] > 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]

 

代码模板(建议复制粘贴使用)：

 

1. def func(mylist):
2.     # your code here
3.     return output
4.      
5. mylist = eval(input())
6. 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)