Python练习题

冒泡排序

def bubbleSort(list):
    for i in range(len(list)):
        for j in range(i,len(list)):
            if list[i] > list[j]:
                list[i],list[j] = list[j],list[i]
    print list

求100以内的质数的倒数和

def prime(x):
    list = []
    for i in range(2,x):
        for j in range(2,i):
            if i%j == 0 :
                break
        else:
            list.append(i)
    return list

if __name__=='__main__':
    list = prime(100)
    print list
    sum = 0
    for i in range(len(list)):
        sum += 1/float(list[i])
    print sum

斐波那契数列

#递归

def fibonacci2(first,second,n):
    if n == 0 :
        return first
    elif n == 1:
        return second
    else:
        return fibonacci2(first,second,n-1)+fibonacci2(first,second,n-2)

if __name__=="__main__":
    for i in range(10):
        print(fibonacci2(1,1,i))

#迭代

def fibonacci(first,second,n):
    #result = 0
    #do something
    if n == 0 :
        return first
    elif n == 1:
        return second
    else:
        #sum = first + second
        sum = 0
        for i in range(n):
            sum = first + second
            first,second = second,sum
    return sum

if __name__=="__main__":
    for i in range(10):
        print(fibonacci(1,1,i))

最大公约数

def gcd(self,m,n):
    if not n:
        return m
    else:
        return self.gcd(n,m%n)

最小公倍数

def lcm2(self,x,y):
    if x*y == 0:
        return 0
    else:
        return int(x*y/self.gcd(x,y))

def lcm3(self,x,y):
    if x*y == 0:
        return 0

    if x > y:
        greater = x
    else:
        greater = y

    while greater%x or greater %y:
        greater+=1

    return greater

字符串翻转

s = "happy"
print s[::-1]

打开文档

file = open（“filename”，“rwx”）

打开excel

import xlwt

book = xlwt.Workbook(encoding='utf-8', style_compression=0)

快速排序

def quick_sort(qlist):
    if qlist == []:
        return []
    else:
        qfirst = qlist[0]
        qless = quick_sort([l for l in qlist[1:] if l < qfirst])
        qmore = quick_sort([m for m in qlist[1:] if m >= qfirst])
        return qless + [qfirst] + qmore
qlist = quick_sort([4,5,6,7,3,2,6,9,8])
print qlist

#返回n以内所有数的阶乘的和
def fn(n):
    if n==1 :
        return 1
    else:
        return n*fn(n-1)

#求一个数的质因数
def zhiyinshu(m):
    if m<2:
        exit(0)
    else:
        for i in range(2,m+1):
            if m%i==0:
                print i
                return zhiyinshu(m/i)

#鸡兔同笼
总数x只，脚y只

def jitu(x,y):
    for ji in range(x+1):
        for tu in range(x+1):
            if (2 * ji + 4 * tu == y) and(ji+tu == x):
                print ji,tu
jitu(35,94)

# 原地删除有序数组重复项[1,2,2,4,5,6]

def del_dup(nums):

# 处理空数组情况

if not nums:

return 0

# 慢指针，指向当前不重复元素的最后位置

slow = 0

# 快指针遍历数组

for fast in range(1, len(nums)):

# 如果快指针元素与慢指针元素不同

if nums[fast] != nums[slow]:

# 慢指针前进一位

slow += 1

# 将快指针元素复制到慢指针位置

nums[slow] = nums[fast]

# 返回不重复元素的长度

return slow + 1

'''

题目：给定整数数组 nums 和目标值 target，返回两个相加等于 target 的下标，同一个元素不能用两次。思路：哈希表存值:下标，遍历一边即可。

'''

def twoSum(nums, target):

# 哈希表，存储数值到下标的映射

hash_map = {}

# 遍历数组，同时获取索引和值

for idx, num in enumerate(nums):

# 计算目标值与当前值的差值

diff = target - num

# 如果差值已在哈希表中，找到答案

if diff in hash_map:

return [hash_map[diff], idx]

# 将当前值和下标存入哈希表

hash_map[num] = idx

# 未找到符合条件的两个数

return []

'''

题目：给定一个大小为 n 的数组，找到数组中出现次数最多的元素（众数）。思路：哈希表存值:次数，遍历一边即可。

'''

def majorityElement(nums):

# 哈希表，存储元素到出现次数的映射

hash_map = {}

# 遍历数组，统计每个元素出现的次数

for num in nums:

hash_map[num] = hash_map.get(num, 0) + 1

# 返回出现次数最多的元素（众数）

return max(hash_map, key=hash_map.get)

'''

题目：给定一个大小为 n 的数组，将数组中的元素反转。思路：双指针，交换首尾元素，直到指针相遇。

'''

def reverse(nums):

# 初始化左右指针，分别指向数组的首尾

left, right = 0, len(nums) - 1

# 当左指针小于右指针时，交换元素

while left < right:

# 交换左右指针位置的元素

nums[left], nums[right] = nums[right], nums[left]

# 左指针向右移动

left += 1

# 右指针向左移动

right -= 1

# 返回反转后的数组

return nums

'''

题目：给定一个字符串 s，将字符串中的字符反转。思路：双指针，交换首尾字符，直到指针相遇。

'''

def reverseString(s):

"""返回反转后的字符串。"""

# 方法1：Python切片（更简洁）

# return s[::-1]

# 方法2：双指针（原地反转）

# 将字符串转换为列表（字符串不可变，需要转换）

s = list(s)

# 初始化左右指针

left, right = 0, len(s) - 1

# 当左指针小于右指针时，交换元素

while left < right:

# 交换左右指针位置的字符

s[left], s[right] = s[right], s[left]

# 左指针向右移动

left += 1

# 右指针向左移动

right -= 1

# 将列表转换回字符串

s = "".join(s)

return s

'''

题目：给定一个字符串 s，判断它是否是有效的回文字符串（忽略大小写、非字母数字）。思路：双指针，判断首尾字符是否相等，直到指针相遇。

'''

def isPalindrome(s):

"""判断字符串是否是回文字符串。"""

# 预处理1：将所有字符转为小写（统一大小写）

s = s.lower()

# 预处理2：过滤掉非字母数字字符，只保留有效字符

s = "".join(filter(str.isalnum, s))

# 方法1：双指针（两端向中间比较）

# 初始化左右指针

left, right = 0, len(s) - 1

# 当左指针小于右指针时，比较两端字符

while left < right:

# 如果左右字符不相等，不是回文

if s[left] != s[right]:

return False

# 左指针向右移动

left += 1

# 右指针向左移动

right -= 1

# 所有字符都匹配，返回True

return True

# 方法2：反转比较（更简洁）

# new_s = ''.join([c.lower() for c in s if c.isalnum()])

# return new_s == new_s[::-1]

'''

题目：给定一个字符串数组 strs，找到数组中的最长公共前缀。思路：双指针，判断首尾字符是否相等，直到指针相遇。

'''

def longestCommonPrefix(strs):

"""返回最长公共前缀。"""

# 处理空数组情况

if not strs:

return ""

# 以第一个字符串作为初始前缀

prefix = strs[0]

# 遍历数组中剩余的字符串

for i in range(1, len(strs)):

# 当前缀不为空且当前字符串不以该前缀开头时

while prefix and not strs[i].startswith(prefix):

# 去掉前缀的最后一个字符，缩短前缀

prefix = prefix[:-1]

# 返回最终的公共前缀

return prefix

'''

题目：给定两个字符串 s 和 t，判断 t 是否是 s 的字母异位词。思路：哈希表存值:次数，遍历一边即可。

逻辑：

1. 遍历字符串 s，将每个字符的次数存储在哈希表中

2. 遍历字符串 t，将每个字符的次数减 1

3. 遍历哈希表，如果次数为负数，说明 False

4. 遍历结束后，说明 True

'''

def isAnagram(s, t):

"""判断两个字符串是否是字母异位词。"""

# 如果长度不同，肯定不是字母异位词

if len(s) != len(t):

return False

# 哈希表，存储字符到出现次数的映射

hash_map = {}

# 遍历字符串s，统计每个字符出现的次数（+1）

for c in s:

hash_map[c] = hash_map.get(c, 0) + 1

# 遍历字符串t，对每个字符的计数减1

for c in t:

hash_map[c] = hash_map.get(c, 0) - 1

# 如果某个字符计数变为负数，说明t包含s中没有的字符

if hash_map[c] < 0:

return False

# 遍历完成，所有字符计数都匹配，返回True

return True

'''

题目：给定一个字符串 s，判断它是否是有效的括号。思路：栈，判断括号是否匹配。

逻辑：

1. 遇到左括号 → 压入栈

2. 遇到右括号 → 检查栈顶是否是对应的左括号（通过 mapping[c] 获取）

3. 遇到其他字符 → 返回 False

4. 遍历结束后，栈必须为空才算有效

### 算法思路

使用栈数据结构处理括号匹配：

- 时间复杂度：O(n)，遍历字符串一次

- 空间复杂度：O(n)，最坏情况需要存储所有左括号

'''

def isValid(s):

"""判断字符串是否是有效的括号。"""

# 初始化栈，用于存储左括号

stack = []

# 创建右括号到左括号的映射关系

mapping = {")": "(", "]": "[", "}": "{"}

# 遍历字符串中的每个字符

for c in s:

# 如果是左括号，压入栈

if c in mapping.values():

stack.append(c)

# 如果是右括号

elif c in mapping:

# 检查栈是否为空，或栈顶左括号不匹配

if not stack or stack.pop() != mapping[c]:

return False

# 如果是非法字符，直接返回False

else:

return False

# 遍历结束后，栈为空说明所有括号都匹配

return not stack

'''

题目：给定一个字符串 s，它表示一个罗马数字，将其转换为整数。思路：遍历字符串，根据字符的值判断是否累加或累减。

逻辑：

'''

def romanToInt(s):

"""将罗马数字转换为整数。"""

# 定义罗马数字到整数的映射关系

roman_map = {"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}

# 初始化结果为0

result = 0

# 遍历字符串中的每个字符

for i in range(len(s)):

# 如果当前字符的值大于等于下一个字符的值，直接累加

if i == len(s) - 1 or roman_map[s[i]] >= roman_map[s[i+1]]:

result += roman_map[s[i]]

else:

# 如果当前字符的值小于下一个字符的值，说明这是一个减法操作

result -= roman_map[s[i]]

# 返回最终结果

return result

'''

题目：将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

思路：虚拟头节点 + 双指针，比较两个链表的节点值，依次连接较小的节点。

'''

class ListNode:

"""链表节点类，每个节点包含一个值和指向下一个节点的指针。"""

def __init__(self, val=0, next=None):

# 节点存储的值

self.val = val

# 指向下一个节点的指针

self.next = next

def mergeTwoLists(list1, list2):

"""合并两个升序链表，返回合并后的升序链表。

Args:

list1: 第一个升序链表的头节点（或列表，会自动转换）

list2: 第二个升序链表的头节点（或列表，会自动转换）

Returns:

合并后的升序链表（以列表形式返回，便于打印查看）

"""

# 辅助函数：将列表转换为链表

def build_list(arr):

# 空列表返回空链表

if not arr:

return None

# 虚拟头节点，简化构建过程

dummy = ListNode(0)

# 当前指针，用于逐个连接节点

curr = dummy

# 遍历数组，依次创建节点并连接

for val in arr:

curr.next = ListNode(val)

curr = curr.next

# 返回真正的头节点（跳过虚拟头节点）

return dummy.next

# 辅助函数：将链表转换为列表（用于打印）

def list_to_arr(head):

# 存储结果的列表

res = []

# 当前指针，从头部开始遍历

curr = head

# 遍历链表，将每个节点的值加入列表

while curr:

res.append(curr.val)

curr = curr.next

return res

# 如果输入是列表，先转换为链表

if isinstance(list1, list):

list1 = build_list(list1)

if isinstance(list2, list):

list2 = build_list(list2)

# 虚拟头节点，用于简化边界处理（避免单独处理第一个节点）

dummy = ListNode(0)

# 当前指针，用于构建新链表

curr = dummy

# 当两个链表都不为空时，比较节点值，选择较小的加入新链表

while list1 and list2:

if list1.val <= list2.val:

# list1节点值较小，将其连接到新链表末尾

curr.next = list1

# list1指针后移

list1 = list1.next

else:

# list2节点值较小，将其连接到新链表末尾

curr.next = list2

# list2指针后移

list2 = list2.next

# 新链表的当前指针后移

curr = curr.next

# 连接剩余未遍历完的链表（其中一个已经为空，直接拼接另一个的剩余部分）

curr.next = list1 if list1 else list2

# 返回合并后的链表（转换为列表便于打印查看）

return list_to_arr(dummy.next)

# 冒泡排序

def bubbleSort(arr):

"""冒泡排序，将数组按升序排序。

Args:

arr: 待排序的数组（列表）

Returns:

None，将数组原地排序

"""

# 数组长度

n = len(arr)

# 外层循环：控制排序轮数，每轮将一个最大的元素"冒泡"到末尾

for i in range(n):

# 内层循环：比较相邻元素，每轮只需比较前n-1-i个元素（末尾已排好序）

for j in range(n - 1 - i):

# 如果前一个元素大于后一个元素，交换位置

if arr[j] > arr[j + 1]:

# 交换相邻两个元素

arr[j], arr[j + 1] = arr[j + 1], arr[j]

# 打印当前数组状态（调试用）

print(arr)

# 返回排序后的数组

return arr

# 快速排序

def quickSort(arr):

"""快速排序，将数组按升序排序。

Args:

arr: 待排序的数组（列表）

Returns:

None，将数组原地排序

"""

# 数组长度

n = len(arr)

# 递归出口：数组长度小于等于1，无需排序

if n <= 1:

return arr

# 选择基准元素（这里选择第一个元素）

pivot = arr[0]

# 分区数组，将小于基准的元素放到基准左边，大于等于基准的元素放到基准右边

left = [x for x in arr[1:] if x < pivot]

right = [x for x in arr[1:] if x >= pivot]

# 递归排序左边和右边的子数组

quickSort(left)

quickSort(right)

# 合并排序后的子数组和基准元素

arr = left + [pivot] + right

# 返回排序后的数组

return left + [pivot] + right

# 二叉树遍历

def inorderTraversal(root):

"""中序遍历二叉树，返回节点值的列表。

Args:

root: 二叉树的根节点

Returns:

包含二叉树所有节点值的列表

"""

# 递归出口：空节点返回空列表

if not root:

return []

# 递归遍历左子树

left = inorderTraversal(root.left)

# 递归遍历右子树

right = inorderTraversal(root.right)

# 合并左子树、根节点值、右子树

return left + [root.val] + right

# 图遍历

def dfs(graph, start):

"""深度优先遍历图，从start节点开始。

Args:

graph: 图的邻接表表示，键为节点，值为相邻节点的列表

start: 起始节点

Returns:

None，将图的节点标记为已访问

"""

# 标记当前节点为已访问

graph[start] = True

# 递归遍历当前节点的所有相邻节点

for neighbor in graph[start]:

if not graph[neighbor]:

dfs(graph, neighbor)

# 打印当前节点（调试用）

print(start)

# 统计字符串每个字符出现次数

def countChars(s):

"""统计字符串每个字符出现次数。

Args:

s: 输入字符串

Returns:

字典，键为字符，值为字符出现的次数

"""

# # 初始化一个空字典，用于存储字符出现次数

# char_count = {}

# # 遍历字符串中的每个字符

# for char in s:

# # 如果字符不在字典中，初始化次数为0

# if char not in char_count:

# char_count[char] = 0

# # 增加字符出现次数

# char_count[char] += 1

# # 返回字符出现次数的字典

# return char_count

char_count = {}

arr = list(s)

for char in arr:

char_count[char] = char_count.get(char, 0) + 1

return char_count

# 找出数组第二大的数

def findSecondLargest(arr):

"""找出数组第二大的数。

Args:

arr: 输入数组（列表）

Returns:

数组中第二大的数

"""

# 初始化两个变量，用于存储最大数和第二大的数

first = second = float('-inf')

# 遍历数组中的每个元素

for num in arr:

# 如果当前元素大于最大数，更新最大数和第二大的数

if num > first:

second = first

first = num

# 如果当前元素在最大数和第二大的数之间，更新第二大的数

elif first > num > second:

second = num

# 返回第二大的数

return second

# 斐波那契数列（递归 + 迭代两种写法）

def fibonacci_recursive(n):

"""递归计算斐波那契数列的第n项。

Args:

n: 第n项的索引，从0开始

Returns:

斐波那契数列的第n项

"""

# 递归出口：第0项和第1项返回1

if n <= 1:

return 1

# 递归计算第n项

return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)

# 迭代计算第n项

def fibonacci_iterative(n):

"""迭代计算斐波那契数列的第n项。

Args:

n: 第n项的索引，从0开始

Returns:

斐波那契数列的第n项

"""

# 初始化前两项

a, b = 1, 1

# 迭代计算第n项

for i in range(2, n + 1):

a, b = b, a + b

# 返回第n项

return b

if __name__ == "__main__":

arr = [6,7,3,1,2,4]

# length = del_dup(arr)

# print(f"长度: {length}, 数组: {arr[:length]}")

# res = twoSum(arr, 5)

# print(res)

# print(longestCommonPrefix(["flower","flow","flight"]))

# print(longestCommonPrefix(["dog","racecar","car"]))

# print(longestCommonPrefix(["",""]))

# print(longestCommonPrefix(["a"]))

# print(longestCommonPrefix(["ab","a"]))

# print(longestCommonPrefix(["flower","flow","flight"]))

# print(longestCommonPrefix(["dog","racecar","car"]))

# print(longestCommonPrefix(["",""]))

# print(longestCommonPrefix(["a"]))

# print(longestCommonPrefix(["ab","a"]))

# print(majorityElement(arr))

# print(reverse(arr))

# print(reverseString("hello"))

# print(isPalindrome("race a car"))

# print(isPalindrome("A man, a plan, a canal: Panama"))

# print(isPalindrome(" "))

# print(isAnagram("anagram", "nagaram"))

# print(isAnagram("rat", "car"))

# print(isValid("()"))

# print(isValid("()[]{}"))

# print(isValid("(]"))

# print(isValid("([)]"))

# print(isValid("{[]}"))

# print(romanToInt("III"))

# print(romanToInt("IV"))

# print(romanToInt("IX"))

# print(romanToInt("LVIII"))

# print(romanToInt("MCMXCIV"))

# print(mergeTwoLists([1,2,4], [1,3,4]))

# print(mergeTwoLists([1,2,4], [3,4,5]))

# print(bubbleSort(arr))

# print(quickSort(arr))

print(countChars("hello world"))

posted @ 2018-12-03 15:12 sjxm2017 阅读(212) 评论(0) 收藏举报

刷新页面返回顶部

sjxm2017

Python练习题

公告