# LeetCode初级算法的Python实现--排序和搜索、设计问题、数学及其他

## 1、排序和搜索

``````class Solution(object):
# 合并两个有序数组
def merge(self, nums1, m, nums2, n):
"""
:type nums1: List[int]
:type m: int
:type nums2: List[int]
:type n: int
:rtype: void Do not return anything, modify nums1 in-place instead.
"""
nums1[m:m + n] = nums2[:n]# 合并数组
nums1.sort()
# 第一个错误的版本
"""
:type n: int
:rtype: int
"""
minn=1
maxn=n
while True:
mid=int((minn+maxn)/2)# 二分
maxn=mid-1
minn=mid+1
else:
return mid+1
``````

# 打乱一个没有重复元素的数组。

``````class Solution(object):
def __init__(self, nums):
"""
:type nums: List[int]
"""
self.numsR = nums[:]
self.nums = nums

def reset(self):
"""
Resets the array to its original configuration and return it.
:rtype: List[int]
"""
self.nums = self.numsR[:]
return self.nums

def shuffle(self):
"""
Returns a random shuffling of the array.
:rtype: List[int]
"""
random.shuffle(self.nums)
return self.nums

# 最小栈
class MinStack(object):
def __init__(self):
"""
"""
self.nums = []

def push(self, x):
"""
:type x: int
:rtype: void
"""
self.nums.append(x)

def pop(self):
"""
:rtype: void
"""
self.nums.pop(len(self.nums) - 1)

def top(self):
"""
:rtype: int
"""
return self.nums[(len(self.nums) - 1)]

def getMin(self):
"""
:rtype: int
"""
return min(self.nums)
``````

## 3、数学

``````import random

class Solution(object):
#  Fizz Buzz
def fizzBuzz(self, n):
"""
:type n: int
:rtype: List[str]
"""
strList = []
for i in range(1, n + 1):
if i % 3 == 0 and i % 5 == 0:
strList.append("FizzBuzz")
elif i % 3 == 0:
strList.append("Fizz")
elif i % 5 == 0:
strList.append("Buzz")
else:
strList.append(str(i))
return strList

# 计数质数，将当前该数的的倍数标记，则未被标记的位置为质数，因为当前该数不是前面的数的倍数
def countPrimes(self, n):
"""
:type n: int
:rtype: int
"""
count = 0
flag = [False for i in range(n + 1)]
for i in range(2, n):
if flag[i] == False:
k = i
while k <= n:
flag[k] = True
k += i
count += 1
return count

# 3的幂
def isPowerOfThree(self, n):
"""
:type n: int
:rtype: bool
"""
if n <= 0:
return False
while n > 1:
n = n / 3.0
if n != int(n):
return False
return True

# 罗马数字转整数
def romanToInt(self, s):
"""
:type s: str
:rtype: int
"""
val = 0
data = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000, }
for i in range(0, len(s)):  # 如果遍历到最后一个字符或者当前字符代表的数大于后一个字符代表的数则加，反之减
if len(s) == i + 1 or data[s[i + 1]] <= data[s[i]]:
val += data[s[i]]
else:
val -= data[s[i]]
return val
``````

## 4、其他

``````class Solution(object):
# 位1的个数
def hammingWeight(self, n):
"""
:type n: int
:rtype: int
"""
res = bin(n).count('1')
return res

# 汉明距离
def hammingDistance(self, x, y):
"""
:type x: int
:type y: int
:rtype: int
"""
xbin = bin(x)[2:]
ybin = bin(y)[2:]
count = 0
if len(xbin) > len(ybin):  # 得到长度较短的
xbin, ybin = ybin, xbin
cha = len(ybin) - len(xbin)
for i in range(0, cha):  # 将较短的用0补全
xbin = '0' + xbin
for i in range(0, len(ybin))[::-1]:
if xbin[i] != ybin[i]:  # 判断
count += 1
return count

#  颠倒二进制位
def reverseBits(self, n):
nbin = bin(n)[2:]
for i in range(0, 32 - len(nbin)):
nbin = '0' + nbin
nbin = nbin[::-1]
result = int(nbin, 2)  # 转十进制
return result

# 帕斯卡三角形
def generate(self, numRows):
"""
:type numRows: int
:rtype: List[List[int]]
"""
if numRows == 0:
return []
result = [[1]]
for i in range(1, numRows):
block = [1]
for j in range(0, i - 1):
block.append(result[i - 1][j] + result[i - 1][j + 1])
block.append(1)
result.append(block)
return result

# 有效的括号
def isValid(self, s):
"""
:type s: str
:rtype: bool
"""
while len(s) >= 0:  #
flag = False  # 标志如果下面三个都不存在 说明不是有效果括号，有的话则替换
if s.__contains__('()'):
s = s.replace('()', '')
flag = True
if s.__contains__('{}'):
s = s.replace('{}', '')
flag = True
if s.__contains__('[]'):
s = s.replace('[]', '')
flag = True
if len(s) == 0:
return True
if flag == False:
break
return False

# 缺失数字
def missingNumber(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
nums.sort()  # 排序
for i in range(0, len(nums) - 1):
if (nums[i] + 1) != nums[i + 1]:  # 如果当前值加一等于下一个
return nums[i] + 1
if nums[0] > 0:
return 0
return len(nums)``````

## LeetCode初级算法的Python实现--排序和搜索、设计问题、数学及其他的更多相关文章

1. LeetCode初级算法的Python实现--链表

LeetCode初级算法的Python实现--链表 之前没有接触过Python编写的链表,所以这里记录一下思路.这里前面的代码是和leetcode中的一样,因为做题需要调用,所以下面会给出. 首先定义 ...

2. LeetCode初级算法的Python实现--字符串

LeetCode初级算法的Python实现--字符串 # 反转字符串 def reverseString(s): return s[::-1] # 颠倒数字 def reverse(x): if x ...

3. LeetCode初级算法的Python实现--数组

LeetCode初级算法的Python实现--数组 # -*- coding: utf-8 -*- """ @Created on 2018/6/3 17:06 @aut ...

4. LeetCode初级算法的Python实现--动态规划

动态规划的本质是递归:所以做题之前一定要会递归:递归式就是状态转移方程:这里将会介绍使用动态规划做题的思维方式. 统一的做题步骤: 1.用递归的方式写出代码:(此方法写的代码在leetcode中一定会 ...

5. LeetCode初级算法--数组02：旋转数组

LeetCode初级算法--数组02:旋转数组 搜索微信公众号:'AI-ming3526'或者'计算机视觉这件小事' 获取更多算法.机器学习干货 csdn:https://blog.csdn.net/ ...

6. LeetCode初级算法--字符串01：反转字符串

LeetCode初级算法--字符串01:反转字符串 搜索微信公众号:'AI-ming3526'或者'计算机视觉这件小事' 获取更多算法.机器学习干货 csdn:https://blog.csdn.ne ...

7. LeetCode初级算法--链表01：反转链表

LeetCode初级算法--链表01:反转链表 搜索微信公众号:'AI-ming3526'或者'计算机视觉这件小事' 获取更多算法.机器学习干货 csdn:https://blog.csdn.net/ ...

8. LeetCode初级算法--动态规划01：爬楼梯

LeetCode初级算法--动态规划01:爬楼梯 搜索微信公众号:'AI-ming3526'或者'计算机视觉这件小事' 获取更多算法.机器学习干货 csdn:https://blog.csdn.net ...

9. LeetCode初级算法--排序和搜索01：第一个错误的版本

LeetCode初级算法--排序和搜索01:第一个错误的版本 搜索微信公众号:'AI-ming3526'或者'计算机视觉这件小事' 获取更多算法.机器学习干货 csdn:https://blog.cs ...

## 随机推荐

1. 【NOI2016】优秀的拆分 题解（95分）

题目大意: 求一个字符串中形如AABB的子串个数. 思路: 用哈希做到O(1)判断字符串是否相同,O(\$n^2\$)预处理,ans[i]为开头位置为i的形如AA的子串个数.再用O(\$n^2\$)枚举出AA ...

2. Number of 1 Bits

class Solution { public: int hammingWeight(uint32_t n) { string aaa = toBinary(n); ; ; i < sizeof ...

3. java提高篇(十五)-----关键字final

在程序设计中,我们有时可能希望某些数据是不能够改变的,这个时候final就有用武之地了.final是java的关键字,它所表示的是“这部分是无法修改的”.不想被改变的原因有两个:效率.设计.使用到fi ...

4. [Scheme]Understanding the Yin-Yang Puzzle

这题目确实比较杀脑细胞... 原题: (let* ((yin ((lambda (cc) (display "@") cc) (call-with-current-continua ...

5. 很受欢迎的Linux笔记（短小精悍）

http://blog.csdn.net/xsl1990/article/details/8274028 如何知道所使用的LINUX是哪个发行版? lsb_release -a 查找某个文件的另类方法 ...

6. Unity3D常见技术点(持续更新)

一:获取对象, 添加对象等 1:使用prefab生成对象 GameObject ballObj = GameObject.Instantiate(Resources.Load(, Quaternion ...

7. Makefile的简单例子

1.生成test可执行文件,源文件有prog.c prog.h cord.h test:prog.o code.o gcc -o test prog.o code.o prog.o:prog.c pr ...