卡码网python语言基础课 | 题目 9.15总结

1.链表的基础操作I

题目描述：

构建一个单向链表，链表中包含一组整数数据。输出链表中的所有元素。

要求： 
1. 使用自定义的链表数据结构 
2. 提供一个 linkedList 类来管理链表，包含构建链表和输出链表元素的方法 
3. 在 main 函数中，创建一个包含一组整数数据的链表，然后调用链表的输出方法将所有元素打印出来

输入描述：

包含多组测试数据，输入直到文件尾结束。 

每组的第一行包含一个整数 n，表示需要构建的链表的长度。 

接下来一行包含 n 个整数，表示链表中的元素。

输出描述：每组测试数据输出占一行。 
按照顺序打印出链表中的元素，每个元素后面跟一个空格。

class Node:
    def __init__(self,data):
        self.data = data
        self.next = None

class LinkList:
    def __init__(self):
        self.head_node = None
        self.length = 0
    def insert(self,data):
        self.length += 1
        new_node = Node(data)
        if self.head_node is None:
            self.head_node = new_node
            return self.head_node

        current_node = self.head_node
        while current_node.next is not None:
            current_node = current_node.next

        current_node.next = new_node
        return new_node

    def print_link_list(self):
        current_node = self.head_node
        while current_node is not None:
            print(current_node.data,end=" ")
            current_node = current_node.next
        print()

while True:
    try:
        n = int(input())
        elements = list(map(int,input().split()))
    except:
        break

    link_list = LinkList()

    for data in elements:
        link_list.insert(data)

    link_list.print_link_list()

2.链表的基础操作II

题目描述：

请编写一个程序，实现以下操作： 

构建一个单向链表，链表中包含一组整数数据，输出链表中的第 m 个元素（m 从 1 开始计数）。 

要求： 
1. 使用自定义的链表数据结构 
2. 提供一个 linkedList 类来管理链表，包含构建链表、输出链表元素以及输出第 m 个元素的方法 
3. 在 main 函数中，创建一个包含一组整数数据的链表，然后输入 m，调用链表的方法输出第 m 个元素

输入描述：

第一行包含两个整数 n 和 k，n 表示需要构建的链表的长度，k 代表输入的 m 的个数。 

接下来一行包含 n 个整数，表示链表中的元素。 

接下来一行包含 k 个整数，表示输出链表中的第 m 个元素。

输出描述：

测试数据输出占 k 行。 

每行输出链表中的第 m 个元素。如果 m 位置不合法，则输出“Output position out of bounds.”。

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkList:
    def __init__(self):
        self.head_node = None
        self.length = 0

    def insert(self, data):
        self.length += 1
        new_node = Node(data)
        if self.head_node is None:
            self.head_node = new_node
            return self.head_node
        else:
            current_node = self.head_node
            while current_node.next is not None:
                current_node = current_node.next
            current_node.next = new_node
            return new_node
    # 获取第 n 个节点的方法
    def get(self, n):
        # 输入位置不合法
        if n < 1 or n > self.length:
            return None
        i = 1
        current_node = self.head_node
        while current_node is not None:
            # 找到第 n 个节点
            if i == n:
                return current_node
            i += 1
            current_node = current_node.next
        return None

n, k = map(int, input().split())
link_list = LinkList()
elements = list(map(int, input().split()))

for data in elements:
    link_list.insert(data)
    
m_values = list(map(int, input().split()))
for m in m_values:
    node = link_list.get(m) # 调用 get 方法，获取第 m 个节点
    if node is not None: # 如果节点 不为 None, 输出对应的 data
        print(node.data)
    else: # 否则，则为 m 位置不合法
        print("Output position out of bounds.")

3.链表的基础操作III

题目描述：

请编写一个程序，实现以下链表操作：构建一个单向链表，链表中包含一组整数数据。

1. 实现在链表的第 n 个位置插入一个元素，输出整个链表的所有元素。 
2. 实现删除链表的第 m 个位置的元素，输出整个链表的所有元素。

要求：

1. 使用自定义的链表数据结构。 
2. 提供一个 linkedList 类来管理链表，包含构建链表、插入元素、删除元素和输出链表元素的方法。 
3. 在 main 函数中，创建一个包含一组整数数据的链表，然后根据输入的 n 和 m，调用链表的方法插入和删除元素，并输出整个链表的所有元素。

输入描述：

每次输出只有一组测试数据。

每组的第一行包含一个整数 k，表示需要构建的链表的长度。

第二行包含 k 个整数，表示链表中的元素。

第三行包含一个整数 S，表示后续会有 S 行输入，每行两个整数，第一个整数为 n，第二个整数为 x ，代表在链表的第 n 个位置插入 x。

S 行输入...

在 S 行输入后，后续会输入一个整数 L，表示后续会有 L 行输入，每行一个整数 m，代表删除链表中的第 m 个元素。

L 行输入...

输出描述：

包含多组输出。

每组第一行输出构建的链表，链表元素中用空格隔开，最后一个元素后没有空格。

然后是 S 行输出，每次插入一个元素之后都将链表输出一次，元素之间用空格隔开，最后一个元素后没有空格；

如果插入位置不合法，则输出“Insertion position is invalid.”。

然后是 L 行输出，每次删除一个元素之后都将链表输出一次，元素之间用空格隔开，最后一个元素后没有空格；如果删除元素后链表的长度为0，则不打印链表。

如果删除位置不合法，则输出“Deletion position is invalid.”。

如果链表已经为空，执行删除操作时不需要打印任何数据。

# 定义链表节点
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
# 定义链表
class LinkedList:
    def __init__(self):
        self.head_node = None
        self.length = 0
    # 尾部插入方法
    def insert(self, data):
        self.length += 1
        new_node = Node(data)
        if self.head_node is None:
            self.head_node = new_node
            return self.head_node
        else:
            current_node = self.head_node
            while current_node.next is not None:
                current_node = current_node.next
            current_node.next = new_node
            return new_node
    # 获取 第 n 个节点
    def get(self, n):
        if n < 1 or n > self.length:
            return None
        i = 1
        current_node = self.head_node
        while current_node is not None:
            if i == n:
                return current_node
            i += 1
            current_node = current_node.next
        return None
    # 在 提供的位置插入节点
    def insert_at(self, n, data):
        new_node = Node(data)
        if n == 1:
            new_node.next = self.head_node
            self.head_node = new_node
            self.length += 1
            return new_node
        else:
            pre_node = self.get(n - 1)
            if pre_node is not None:
                new_node.next = pre_node.next
                pre_node.next = new_node
                self.length += 1
                return new_node
        return None
    # 删除节点
    def delete(self, n):
        if self.head_node is None:
            return None
        if n == 1:
            deleted_node = self.head_node
            self.head_node = self.head_node.next
            self.length -= 1
            return deleted_node
        else:
            pre_node = self.get(n - 1)
            if pre_node is not None and pre_node.next is not None:
                deleted_node = pre_node.next
                pre_node.next = pre_node.next.next
                self.length -= 1
                return deleted_node
        return None
    # 打印链表节点
    def print_link_list(self):
        current_node = self.head_node
        while current_node is not None:
            if current_node.next is not None:
                print(current_node.data, end=' ')
            else:
                print(current_node.data)
            current_node = current_node.next

k = int(input())
# 新建链表
link_list = LinkedList()
elements = list(map(int, input().split()))
# 将元素插入到链表中
for data in elements:
    link_list.insert(data)

s = int(input())
for _ in range(s):
    n, x = map(int, input().split())
    # 在索引 n 处插入链表节点
    node = link_list.insert_at(n, x)
    if node is not None:
        link_list.print_link_list()
    else:
        print("Insertion position is invalid.")

l = int(input())
for _ in range(l):
    m = int(input())
    # 在索引 m 处删除链表节点
    deleted_node = link_list.delete(m)
    if deleted_node is not None:
        link_list.print_link_list()
    else:
        print("Deletion position is invalid.")

16.出现频率最高的字母

题目描述：给定一个只包含小写字母的字符串，统计字符串中每个字母出现的频率，并找出出现频率最高的字母，如果最高频率的字母有多个，输出字典序靠前的那个字母。

输入描述：包含多组测试数据，每组测试数据占一行。

输出描述：

有多组输出，每组输出占一行。 

n = int(input())

for _ in range(n):
    s = input()
    temp = [0]*26

    for char in s:
        a = ord(char) - ord("a")
        temp[a] += 1

    maxFreq = 0
    maxFreqChar = -1

    for i in range(26):
        if temp[i] > maxFreq:
            maxFreq = temp[i]
            maxFreqChar = i

    res = chr(ord('a')+maxFreqChar)
    print(res) 

17.判断集合成员

题目描述：请你编写一个程序，判断给定的整数 n 是否存在于给定的集合中。

输入描述：

有多组测试数据，第一行有一个整数 k，代表有 k 组测试数据。

每组数据第一行首先是一个正整数 m，表示集合中元素的数量（1 <= m <= 1000）。 

接下来一行包含 m 个整数，表示集合中的元素。 

最后一行包含一个整数 n，表示需要进行判断的目标整数。

输出描述：

包含多组输出，每组输出占一行。 

如果集合中存在 m，输出“YES”，否则输出“NO”。

k = int(input())
for _ in range(k):
    m = int(input())
    elements = set(map(int,input().split()))
    n = int(input())
    if n in elements:
        print('YES')
    else:
        print('NO')