面试coding基础

最新推荐文章于 2024-04-08 04:13:37 发布

陈陈的肥猫

最新推荐文章于 2024-04-08 04:13:37 发布

阅读量139

点赞数

分类专栏： python 文章标签：面试深度优先算法

本文链接：https://blog.csdn.net/weixin_39685584/article/details/118877932

版权

python 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

快速排序

# 时间复杂度O(nlogn) 最差O(n^2)
def partition(arr, low, high):
    i = low - 1
    pivot = arr[high]

    for j in range(low, high):
        if arr[j] <= pivot:
            i = i + 1
            arr[i], arr[j] = arr[j], arr[i]

    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i+1


def quickSort(arr, low, high):
    if low < high:
        pi = partition(arr, low, high)
        quickSort(arr, low, pi-1)
        quickSort(arr, pi+1, high)


arr = [10, 7, 8, 5, 6, 20]
quickSort(arr, 0, len(arr)-1)
print(arr)

堆排序

# 时间复杂度O(nlogn) 最差O(nlogn)
# 建堆O(n) 每个调整O(logn)
def heapify(arr, n, i):
    largest = i
    l = 2 * i + 1
    r = 2 * i + 2

    if l < n and arr[largest] < arr[l]:
        largest = l
    if r < n and arr[largest] < arr[r]:
        largest = r

    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        heapify(arr, n, largest)


def heapSort(arr):
    n = len(arr)

    # 建大顶堆
    for i in range(n-1, -1, -1):
        heapify(arr, n, i)

    for i in range(n-1, 0, -1):
        arr[i], arr[0] = arr[0], arr[i]
        heapify(arr, i, 0)


arr = [10, 7, 8, 5, 6, 20]
heapSort(arr)
print(arr)

归并排序

# 时间复杂度O(nlogn) 最差O(nlogn)
def merge(arr, l, m, r):
    n1, n2 = m-l+1, r-m
    L, R = arr[l: m+1], arr[m+1: r+1]  # 临时数组

    i, j, k = 0, 0, l
    while i < n1 and j < n2:
        if L[i] <= R[j]:
            arr[k] = L[i]
            i += 1
        else:
            arr[k] = R[j]
            j += 1
        k += 1

    while i < n1:
        arr[k] = L[i]
        i += 1
        k += 1
    while j < n2:
        arr[k] = R[j]
        j += 1
        k += 1


def mergeSort(arr, l, r):
    if l < r:
        m = (l+r) // 2
        mergeSort(arr, l, m)
        mergeSort(arr, m+1, r)
        merge(arr, l, m, r)

arr = [10, 7, 8, 5, 6, 20]
mergeSort(arr, 0, len(arr)-1)
print(arr)

前中后序遍历(递归法)

class Solution:
	def Traversal(self, root: TreeNode) -> List[int]:
		if not root:
			return []
		# 前序
		return [root.val] + self.Traversal(root.left) + self.Traversal(root.right)

		# 中序
		# return self.Traversal(root.left) + [root.val] + self.Traversal(root.right)

		# 后序
		# return self.Traversal(root.left) + self.Traversal(root.right) + [root.val]

class Solution:
	def Traversal(self, root: TreeNode) -> List[int]:
		def dfs(cur):
			if not cur:
				return
			# 前序
			res.append(cur.val)
			dfs(cur.left)
			dfs(cur.right)
			
			# 中序
			# dfs(cur.left)
			# res.append(cur.val)
			# dfs(cur.right)

			# 后序
			# dfs(cur.left)
			# dfs(cur.right)
			# res.append(cur.val)
		
		res = []
		dfs(root)
		return res

前中后序遍历(迭代法)

# 前序遍历-迭代-LC144_二叉树的前序遍历
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        # 根结点为空则返回空列表
        if not root:
            return []
        stack = [root]
        result = []
        while stack:
            node = stack.pop()
            # 中结点先处理
            result.append(node.val)
            # 右孩子先入栈
            if node.right:
                stack.append(node.right)
            # 左孩子后入栈
            if node.left:
                stack.append(node.left)
        return result
        
# 中序遍历-迭代-LC94_二叉树的中序遍历
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        stack = []  # 不能提前将root结点加入stack中
        result = []
        cur = root
        while cur or stack:
            # 先迭代访问最底层的左子树结点
            if cur:     
                stack.append(cur)
                cur = cur.left		
            # 到达最左结点后处理栈顶结点    
            else:		
                cur = stack.pop()
                result.append(cur.val)
                # 取栈顶元素右结点
                cur = cur.right	
        return result
        
# 后序遍历-迭代-LC145_二叉树的后序遍历
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        stack = [root]
        result = []
        while stack:
            node = stack.pop()
            # 中结点先处理
            result.append(node.val)
            # 左孩子先入栈
            if node.left:
                stack.append(node.left)
            # 右孩子后入栈
            if node.right:
                stack.append(node.right)
        # 将最终的数组翻转
        return result[::-1]

并查集

class UnionFind:
    def __init__(self, n):
        # 下标是子节点， 值是父节点
        self.parent = list(range(n))

    def union(self, index1, index2):
        # index1 和 index2 子节点 所在树相连
        self.parent[self.find(index2)] = self.find(index1)

    def find(self, index):
        # index的父节点
        if self.parent[index] != index:
            self.parent[index] = self.find(self.parent[index])
        return self.parent[index]

二分查找

# 二分查找
def binary_search(nums, target):
    left, right = 0, len(nums)-1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] < target:
            left = mid + 1
        elif nums[mid] > target:
            right = mid - 1
        else:
            return mid
    return None


# 二分查找左边界
def left_bound(nums, target):
    left, right = 0, len(nums)-1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] < target:
            left = mid + 1
        elif nums[mid] > target:
            right = mid - 1
        else:
            right = mid - 1  # 锁定左边界
    # 检查左边界越界情况
    if left >= len(nums) or nums[left] != target:
        return None
    return left


# 二分查找右边界
def right_bound(nums, target):
    left, right = 0, len(nums)-1
    while left <= right:
        mid = (left + right) // 2
        if nums[mid] < target:
            left = mid + 1
        elif nums[mid] > target:
            right = mid - 1
        else:
            left = mid + 1  # 锁定右边界
    # 检查右边界越界情况
    if right < 0 or nums[right] != target:
        return None
    return right

Kmean

import random

class K_means():
    def __init__(self,datas,n_cluster):
        self.datas = datas
        self.n_cluster = n_cluster
        self.clusers_have = {}
        self.datas_belong = [0 for _ in range(len(datas))]
        self.cluser_points = []  # 聚类中心
        for i in range(self.n_cluster):
            self.cluser_points.append([random.uniform(0, 5), random.uniform(0, 5)])
            self.clusers_have[i] = []

    def l2_distance(self,x,y):
        return (x[0]-y[0])*(x[0]-y[0]) + (x[1]-y[1])*(x[1]-y[1])

    def fit(self,iter_num=100):
        for _ in range(iter_num):
            for cluser_idx in self.clusers_have.keys():
                self.clusers_have[cluser_idx] = []
            for i, data in enumerate(self.datas):
                for j, cluster_point in enumerate(self.cluser_points):
                    if j == 0:
                        min_distance = self.l2_distance(data, cluster_point)
                        nearest_cluster = j
                    else:
                        distance = self.l2_distance(data, cluster_point)
                        if distance < min_distance:
                            min_distance = distance
                            nearest_cluster = j
                self.datas_belong[i] = nearest_cluster
                self.clusers_have[nearest_cluster].append(i)
            for j, cluster_point in enumerate(self.cluser_points):
                new_point = [0, 0]
                for i in self.clusers_have[j]:
                    new_point[0] += datas[i][0]
                    new_point[1] += datas[i][1]
                new_point[0] /= len(self.clusers_have[j])
                new_point[1] /= len(self.clusers_have[j])
                self.cluser_points[j] = new_point
            print(self.cluser_points)

    def predict(self,new_point):
        for j,cluser_point in enumerate(self.cluser_points):
            if j == 0 :
                min_distance = self.l2_distance(new_point,cluser_point)
                nearest = j