Python头哥今天是第几天的答案 头歌python

目录

文章目录

• 目录
• 顺序查找（依频率查找）

• 任务描述

• 计算器
• 链表的构造
• 线性表的构造
• 图遍历

---

顺序查找（依频率查找）

思路：用字典进行存储，考字典的操作

任务描述

本关任务：顺序查找是一种简单的查找算法，它遍历待查找的元素列表，按照元素出现的频次进行查找。给定一个包含 N 个整数的列表，设计一个 Python 算法，查找列表中出现频次最高的元素，并返回该元素。

def find_most_frequent_element(arr):
    ########## Begin ##########
    dic = {}
    max_num = 0
    index = 0
    for i in arr:
        if i in dic:
            dic[i] = dic[i] + 1
        else:
            dic[i] = 1
        if max_num < dic[i]:
            index=i
            max_num = dic[i]

    return index

    ##########  End  ##########


# 输入数据
N = int(input())  # "请输入列表中元素的个数："
arr = list(map(int, input().split()))  # 请输入N个用空格分隔的整数

# 求解并输出结果
result = find_most_frequent_element(arr)
print("列表中出现频次最高的元素是:", result)

这里的i in dict中，i指的是字典中的key。
字典的循环：

for key in dict:

for key in book.keys():
    print(key)
 
 for value in book.values():
    print(value)

for item in dict.items():
	key=item[0]
	value=item[1]
	
for key,value in dict.items ()

计算器

主要是考强制类型转换

class Solution:
    def solve(self, op, num_1, num_2):
        '''
        :type op, num_1, num_2: str, int, int
        :rtype : Str
        '''
        
        #请在此添加代码，实现计算并返回表达式的结果，要求结果保留2位小数
        #********** Begin *********#
        if op=='+':
            result= num_1+num_2
        if op=='-':
            result= num_1-num_2

        if op=='*':
            result= num_1*num_2

        if op=='/':
            result= num_1/num_2
        return '%.2f'%result

        #********** End *********#

链表的构造

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


class LinkedList:
    def __init__(self):
        self.head = None
        self.p=None


    def add_node(self, value):
        ########## Begin ##########
        node=Node(value)
        if self.head==None:
            self.head=node
            self.p=self.head
        else:
            self.p.next=node
            self.p=node
            

        


        ##########  End  ##########
        
    def print_list(self):
        current = self.head
        while current:
            print(current.value, end=" ")
            current = current.next


if __name__ == "__main__":
    # 获取用户输入的整数列表
    input_list = list(map(int, input().split())) # 请输入整数列表，以空格分隔

    # 构造链表
    linked_list = LinkedList()
    for num in input_list:
        linked_list.add_node(num)

    # 打印链表节点值
    linked_list.print_list() #链表的节点值

线性表的构造

思路：用列表list存储

class LinearList:
    def __init__(self):
        self.data = []

    def add_element(self, element):
        ########## Begin ##########
        self.data.append(element)

        ##########  End  ##########

    def get_element(self, index):
        ########## Begin ##########
        if index<len(self.data):
            return self.data[index]
        else:

            return "Error: Index out of range."

        ##########  End  ##########

    def remove_element(self, index):
        ########## Begin ##########
        result=[]
        for i in range(len(self.data)):
            if i!=index:
                result.append(self.data[i])
        self.data=result

        ##########  End  ##########


# 测试用例
if __name__ == "__main__":
    # 初始化线性表
    linear_list = LinearList()

    # 添加元素并输出
    linear_list.add_element(10)
    linear_list.add_element(20)
    linear_list.add_element(30)
    print(linear_list.get_element(0))  # 输出：10
    print(linear_list.get_element(2))  # 输出：30

    # 删除元素并输出
    linear_list.remove_element(1)
    print(linear_list.get_element(2))  # 输出：Error: Index out of range.

删除列表元素：
del list1[2]

图遍历

1.深度遍历
思路：
定义一个矩阵表示各个边之间的关系
定义一个数组存储表示是否遍历到所有的点（visited）
定义一个列表存储遍历到的点（result）
定义start表示出发的地点
基本想法：首先从start开始出发进行深度遍历（遍历矩阵中的start行，如果值为1且visited[start]为False，则将列下标存储到visited中。然后start从该下标开始重新遍历）

def dfs(adj_matrix, start, visited, result):
    ########## Begin ##########

    num=adj_matrix[start]
    result.append(start)
    visited[start]=True
    index=0
    while index<=len(adj_matrix[start]):
            for i in range(len(adj_matrix[start])):
                if adj_matrix[start][i]==1 and visited[i]==False:
                    result.append(i)
                    visited[i]=True
                    start=i
                    break
            index=index+1

    for k in range(len(visited)):
        if visited[k]==False:
            for j  in range(len(adj_matrix[k])):
                if adj_matrix[k][j]==1 and visited[j]==True:
                    visited[k]=True
                    result.append(k)
                
            
            
    return result


    ##########  End  ##########

if __name__ == "__main__":
    N = int(input())  # 输入城市景点的数量
    adj_matrix = [list(map(int, input().split())) for _ in range(N)]  # 输入邻接矩阵
    start = int(input())  # 输入起始景点的编号

    visited = [False] * N
    result = []
    dfs(adj_matrix, start - 1, visited, result)

    print(*[x + 1 for x in result])  # 输出深度优先遍历的结果

参加了计算机挑战杯，大题有一题函数题没有做出来。成功进入决赛。继续记录刷题哈哈哈哈