数据结构之递归

递归

数据结构与算法递归

• 递归的定义：就是在运行的时候调用给自己
• 递归必须要有三个要素：1、边界条件，2、递归前进段，3、递归返回段

$n!$

class Solution:
	def Factorial(self,n):
		if n == 1:
			return 1
		else:
			return n*Factorial(n-1)

递归的二分法查找

• 不用递归方法的二分法查找

# 如果查找的数据是有序的，二分查找算法比顺序查找算法更高效
def binary_search(nums,v):
    nums.sort()
    n = len(nums)
    start = 0
    end = n-1
    while start < end:
        mid = (start + end)//2
        if nums[mid] == v:
            return True
        elif nums[mid] > v:
            end = mid - 1
        elif nums[mid] < v:
            start = mid + 1
    return False

• 用递归的二分法查找

def binary_search(nums,v):
    nums.sort()
    n = len(nums)
    mid = n//2
    if nums[mid] == v:
        return True
    elif nums[mid] > v:
        return binary_search1(nums[0:mid-1],v)
    else:
        return binary_search1(nums[mid+1:n-1],v)

使用递归实现整数的因式分解

rom random import randint

def factors(num, fac = []):
    # 每次都从2开始找因数
    for i in range(2,int(num**0.5)+1):
        if num%i==0:
            fac.append(i)
            factors(num//i,fac)
            break
    else:
        # 不可分解了，自身也是个因数
        fac.append(num)
facs = []
n=randint(2,10**8)
factors(n,facs)
result = '*'.join(map(str,facs))
if n ==eval(result):
    print(n,'='+result)
# 89295880 =2*2*2*5*797*2801

递归的归并排序

• 递归的归并排序

def merge_sort(nums):
    n = len(nums)
    if n <= 1:    
        return nums
    mid = n // 2
    left_li = merge_sort(nums[0:mid])
    right_li = merge_sort(nums[mid:])
    result = []
    left_point,right_point = 0,0
    while left_point < len(left_li) and right_point < len(right_li):
        if left_li[left_point] < right_li[right_point]:
            result.append(left_li[left_point])
            left_point += 1
        else:
            result.append(right_li[right_point])
            right_point += 1
    result += left_li[left_point:]
    result += right_li[right_point:]
    return result