数据结构与算法之排序: LeetCode 41. 缺失的第一个正数 (Ts, Py, Go版)

「 网络安全常用术语解读 」软件成分分析SCA详解:从发展背景到技术原理再到业界常用检测工具推荐 软件成分分析(Software Composition Analysis,SCA)是一种用于识别和分析软件内部组件及其关系的技术,旨在帮助开发人员更好地了解和管理其软件的构建过程,同时可帮助安全人员揭秘软件内部结构的神秘面纱。SCA技术的发展与软件行业的快速发展密不可分,下面将介绍SCA的发展背景、技术原理以及当前主流SCA工具。 阅读详情

缺失的第一个正数

  • https://leetcode.cn/problems/first-missing-positive/

描述

  • 给你一个未排序的整数数组 nums ,请你找出其中没有出现的最小的正整数。

  • 请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

示例 1

输入:nums = [1,2,0]
输出:3

示例 2

输入:nums = [3,4,-1,1]
输出:2

示例 3

输入:nums = [7,8,9,11,12]
输出:1

Typescript 版算法实现


1 )一般思路

function firstMissingPositive(nums: number[]): number {
  // 判断当前传入数组,如果为空,直接返回1
  if (!nums.length) return 1;
  // 过滤掉非正整数
  nums = nums.filter(item => item > 0);
  // 再次判断过滤后的数组,如果为空,直接返回1
  if (!nums.length) return 1;
  // 升序,目的:方便从左到右取最小值arr[0]
  nums.sort((a: number, b: number) => a - b);
  // 如果第一个元素不为1,返回1
  if (nums[0] !== 1) return 1;
  // 从左边开始遍历,只要下一个元素和当前元素差值 > 1说明当前元素的下一个值(+1)就是所求
  const n: number = nums.length;
  for (let i:number = 0; i < n - 1; i++) {
    if (nums[i + 1] - nums[i] > 1) return nums[i] + 1;
  }
  // 如果数组是连续的正整数 [1,2,3,4,5,6]
  return nums[n - 1] + 1;
}
  • 这个算法不是最优解,做了很多不需要的事情,比如 filter 和 sort
  • 不需要完全进行排序,如果数据量过大,将会有很大的浪费
  • 找最小值,给整个数组排序是非必要的

2 )基于选择排序改造

function firstMissingPositive(nums: number[]): number {
  // 判断当前传入数组,如果为空,直接返回1
  if (!nums.length) return 1;
  // 过滤掉非正整数
  nums = nums.filter(item => item > 0);
  const n: number = nums.length;
  // 再次判断过滤后的数组,如果为空,直接返回1
  if (!n) return 1;
  let min: number;
  // 实现选择排序,先拿到最小值,如果第一个元素不是1直接返回1,如果是1,就要比相邻元素差值
  for (let i: number = 0; i <= n; i++) {
    min = nums[i]; // 最小值取第一项元素
    for (let j: number = i + 1; j <= n; j++) {
      // 下一项如果小于当前的最小值,则交换最小值,得到最新最小值
      if (nums[j] < min) [min, nums[j]] = [nums[j], min];
    }
    // 记录下当前轮的最小值
    nums[i] = min;
    // 下面是业务性判断, 遍历一次,但是最小值不是1,则返回最小正整数1
    if (i === 0 && min !== 1) return 1;
    // 遍历超过1轮,则对比前面的相邻两元素的差值
    if (i > 0 && (nums[i] - nums[i - 1] > 1)) return nums[i - 1] + 1;
  }
  // 最终返回最后一项的值 + 1
  return nums[n - 1] + 1;
}
  • 这个场景,适合选择排序,因为使用选择排序,在第一轮循环就能拿到最小值
  • 但是,在数据量较大的场景下,这个基于选择排序的查找, 在 leetcode 上会存在 超出时间限制 的问题

3 )基于Map哈希表来处理

function firstMissingPositive(nums: number[]): number {
  if (!nums.length) return 1;
  // 创建一个map结构存储字典,将正整数存储到
  const m = new Map();
  let max: number = -Infinity; // 最大值
  // 一个循环中处理完毕
  nums.forEach(item => {
    // 非正整数跳出循环
    if (item <= 0) return;
    m.set(item, 1); // map 存储当前值
    max = Math.max(max, item); // 找到当前最大值
  });
  let minPositive: number = 1;
  while(minPositive <= max) {
    if (!m.get(minPositive)) return minPositive;
    minPositive ++;
  }
  return minPositive;
}
  • 将所有正整数放入哈希表,随后从 1 开始依次枚举正整数直到最大值,并判断其是否在哈希表里面
  • 时间复杂度为 O(n),空间复杂度为 O(n)
  • 这个哈希map所需时间取决于数组的长度,空间复杂度不符合要求, 有额外的map空间
  • 这是一个比较好的算法,也是官方提出的原始方案,但官方不推荐,是因为需求有空间的限定
  • 还有另一种思路是 从 1 开始依次枚举正整数,并遍历数组,判断其是否在数组中
    • 时间复杂度为 O(n2n^2n2)
    • 空间复杂度为 O(1)
    • 这也是官方提出的思路,不写对应的相关代码了,也是不符合需求的

4 )负号标记法改造数组,替代Map,改造标记字典

function firstMissingPositive(nums: number[]): number {
  const n: number = nums.length;
  const { abs } = Math;
  let i: number;
  // 第一轮循环将所有的非正整数都修改成 n + 1, 这时候 数组内都是正整数了,方便加负号标记了
  for (let i = 0; i < n; ++i) {
      if (nums[i] <= 0) nums[i] = n + 1;
  }
  // 第二轮循环将当前元素中 1 ~ n 之内的数对应的位置上的值修改成负值,这样就标记了该位置表示的值(下标)已经出现过了
  for (i = 0; i < n; ++i) {
      let num = abs(nums[i]); // 拿到当前下标对应的元素的绝对值
      if (num <= n) nums[num - 1] = -abs(nums[num - 1]);
  }
  // 最后一轮遍历是找数组中仍是正数的下标,该下标所在的位置就是所求
  for (i = 0; i < n; ++i) {
      if (nums[i] > 0) return i + 1;
  }
  // 以上运算都找不到正数,则都已经标记为负数,直接返回 n + 1
  return n + 1;
}
  • 官方提供方法
    • 首次缺失的正数,一定在 [1, N + 1]范围内
    • 数组本身有索引, 而每个索引都有对应的元素, 将数组的索引当做哈希的键值
    • 在对应元素上添加特殊符号(负号),来标记该位数字是否存在,负号表示存在
    • 比如1出现了,把第一个元素变成负数,2出现了,把第二个元素(索引值为1的元素)变成负数
    • 只要一个数字出现,它对应的第几个元素就标记为负数
    • 只要返回第一个正数的位置,就是缺失的第一个正数
  • 时间复杂度:O(N),其中 N 是数组的长度
  • 空间复杂度:O(1)

5 )置换法

function firstMissingPositive(nums: number[]): number {
  const n: number = nums.length;
  let i: number;
  // 第一轮遍历
  for (i = 0; i < n; ++i) {
      // 如果当前元素在 0 ~ n 之间, 当前元素 和 当前元素对应的位置 - 1 (下标) 不一致 则进行交换
      while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] != nums[i]) {
        [nums[nums[i] - 1], nums[i]] = [nums[i], nums[nums[i] - 1]]; // 交换
      }
  }
  // 第二轮遍历,找到第一个当前值与当前位置不匹配时的位置(备注: 位置比下标大1)
  for (i = 0; i < n; ++i) {
      if (nums[i] != i + 1) {
        return i + 1;
      }
  }
  return n + 1;
}
  • 这是官方提供
  • 将正确的元素放在正确的位置上,寻找第一个值与下标不匹配的元素
  • 如果数组中包含 x∈[1,N],那么恢复后,数组的第 x−1 个元素为 x
  • 在恢复后,数组应当有 [1, 2, …, N] 的形式,但其中有若干个位置上的数是错误的,每一个错误的位置就代表了一个缺失的正数
  • 以题目中的示例二 [3, 4, -1, 1] 为例,恢复后的数组应当为 [1, -1, 3, 4],我们就可以知道缺失的数为 2
  • 时间复杂度:O(N),其中 N 是数组的长度
  • 空间复杂度:O(1)

Python3 版算法实现


1 )方案1

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        # 判断当前传入数组,如果为空,直接返回1
        if not nums:
            return 1
        # 过滤掉非正整数
        nums = [item for item in nums if item > 0]
        # 再次判断过滤后的数组,如果为空,直接返回1
        if not nums:
            return 1
        # 升序,目的:方便从左到右取最小值arr[0]
        nums.sort()
        # 如果第一个元素不为1,返回1
        if nums[0] != 1:
            return 1
        # 从左边开始遍历,只要下一个元素和当前元素差值 > 1说明当前元素的下一个值(+1)就是所求
        n = len(nums)
        for i in range(n - 1):
            if nums[i + 1] - nums[i] > 1:
                return nums[i] + 1
        # 如果数组是连续的正整数 [1,2,3,4,5,6]
        return nums[n - 1] + 1

2 )方案2

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        # 判断当前传入数组,如果为空,直接返回1
        if not nums:
            return 1
        # 过滤掉非正整数
        nums = [item for item in nums if item > 0]
        n = len(nums)
        # 再次判断过滤后的数组,如果为空,直接返回1
        if not n:
            return 1
        min_val = None
        # 实现选择排序,先拿到最小值,如果第一个元素不是1直接返回1,如果是1,就要比相邻元素差值
        for i in range(n):
            min_val = nums[i]  # 最小值取第一项元素
            for j in range(i + 1, n):
                # 下一项如果小于当前的最小值,则交换最小值,得到最新最小值
                if nums[j] < min_val:
                    min_val, nums[j] = nums[j], min_val
            # 记录下当前轮的最小值
            nums[i] = min_val
            # 下面是业务性判断, 遍历一次,但是最小值不是1,则返回最小正整数1
            if i == 0 and min_val != 1:
                return 1
            # 遍历超过1轮,则对比前面的相邻两元素的差值
            if i > 0 and (nums[i] - nums[i - 1] > 1):
                return nums[i - 1] + 1
        # 最终返回最后一项的值 + 1
        return nums[n - 1] + 1
  • Leetcode 上超出时间限制

3 )方案3

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        if not nums:
            return 1
        # 创建一个map结构存储字典,将正整数存储到
        m = {}
        max_val = float('-inf')  # 最大值
        # 一个循环中处理完毕
        for item in nums:
            # 非正整数跳出循环
            if item <= 0:
                continue
            m[item] = 1  # map 存储当前值
            max_val = max(max_val, item)  # 找到当前最大值
        min_positive = 1
        while min_positive <= max_val:
            if min_positive not in m:
                return min_positive
            min_positive += 1
        return min_positive

4 )方案4

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        n = len(nums)
        # 第一轮循环将所有的非正整数都修改成 n + 1, 这时候 数组内都是正整数了,方便加负号标记了
        for i in range(n):
            if nums[i] <= 0:
                nums[i] = n + 1
        # 第二轮循环将当前元素中 1 ~ n 之内的数对应的位置上的值修改成负值,这样就标记了该位置表示的值(下标)已经出现过了
        for i in range(n):
            num = abs(nums[i])  # 拿到当前下标对应的元素的绝对值
            if num <= n:
                nums[num - 1] = -abs(nums[num - 1])
        # 最后一轮遍历是找数组中仍是正数的下标,该下标所在的位置就是所求
        for i in range(n):
            if nums[i] > 0:
                return i + 1
        # 以上运算都找不到正数,则都已经标记为负数,直接返回 n + 1
        return n + 1

5 )方案5

class Solution:
    def firstMissingPositive(self, nums: List[int]) -> int:
        n = len(nums)
        # 第一轮遍历
        for i in range(n):
            # 如果当前元素在 0 ~ n 之间, 当前元素 和 当前元素对应的位置 - 1 (下标) 不一致 则进行交换
            while 0 < nums[i] <= n and nums[nums[i] - 1] != nums[i]:
                nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i] - 1]  # 交换
        # 第二轮遍历,找到第一个当前值与当前位置不匹配时的位置(备注: 位置比下标大1)
        for i in range(n):
            if nums[i] != i + 1:
                return i + 1
        return n + 1

Golang 版算法实现


1 )方案1

func firstMissingPositive(nums []int) int {
	// 判断当前传入数组,如果为空,直接返回1
	if len(nums) == 0 {
		return 1
	}
	// 过滤掉非正整数
	filteredNums := []int{}
	for _, item := range nums {
		if item > 0 {
			filteredNums = append(filteredNums, item)
		}
	}
	// 再次判断过滤后的数组,如果为空,直接返回1
	if len(filteredNums) == 0 {
		return 1
	}
	// 升序,目的:方便从左到右取最小值arr[0]
	sort.Ints(filteredNums)
	// 如果第一个元素不为1,返回1
	if filteredNums[0] != 1 {
		return 1
	}
	// 从左边开始遍历,只要下一个元素和当前元素差值 > 1说明当前元素的下一个值(+1)就是所求
	n := len(filteredNums)
	for i := 0; i < n-1; i++ {
		if filteredNums[i+1]-filteredNums[i] > 1 {
			return filteredNums[i] + 1
		}
	}
	// 如果数组是连续的正整数 [1,2,3,4,5,6]
	return filteredNums[n-1] + 1
}

2 )方案2

func firstMissingPositive(nums []int) int {
	// 判断当前传入数组,如果为空,直接返回1
	if len(nums) == 0 {
		return 1
	}
	// 过滤掉非正整数
	filteredNums := []int{}
	for _, item := range nums {
		if item > 0 {
			filteredNums = append(filteredNums, item)
		}
	}
	n := len(filteredNums)
	// 再次判断过滤后的数组,如果为空,直接返回1
	if n == 0 {
		return 1
	}
	var min int
	// 实现选择排序,先拿到最小值,如果第一个元素不是1直接返回1,如果是1,就要比相邻元素差值
	for i := 0; i < n; i++ {
		min = filteredNums[i] // 最小值取第一项元素
		for j := i + 1; j < n; j++ {
			// 下一项如果小于当前的最小值,则交换最小值,得到最新最小值
			if filteredNums[j] < min {
				min, filteredNums[j] = filteredNums[j], min
			}
		}
		// 记录下当前轮的最小值
		filteredNums[i] = min
		// 下面是业务性判断, 遍历一次,但是最小值不是1,则返回最小正整数1
		if i == 0 && min != 1 {
			return 1
		}
		// 遍历超过1轮,则对比前面的相邻两元素的差值
		if i > 0 && (filteredNums[i] - filteredNums[i-1] > 1) {
			return filteredNums[i-1] + 1
		}
	}
	// 最终返回最后一项的值 + 1
	return filteredNums[n-1] + 1
}

  • LeetCode 上超出时间限制

3 )方案3

func firstMissingPositive(nums []int) int {
	if len(nums) == 0 {
		return 1
	}
	// 创建一个map结构存储字典,将正整数存储到
	m := make(map[int]bool)
	maxVal := -1 << 31 // 最大值
	// 一个循环中处理完毕
	for _, item := range nums {
		// 非正整数跳出循环
		if item <= 0 {
			continue
		}
		m[item] = true // map 存储当前值
		maxVal = max(maxVal, item) // 找到当前最大值
	}
	minPositive := 1
	for minPositive <= maxVal {
		if !m[minPositive] {
			return minPositive
		}
		minPositive++
	}
	return minPositive
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

4 )方案4

import "math"

func firstMissingPositive(nums []int) int {
	n := len(nums)
	// 第一轮循环将所有的非正整数都修改成 n + 1, 这时候 数组内都是正整数了,方便加负号标记了
	for i := 0; i < n; i++ {
		if nums[i] <= 0 {
			nums[i] = n + 1
		}
	}
	// 第二轮循环将当前元素中 1 ~ n 之内的数对应的位置上的值修改成负值,这样就标记了该位置表示的值(下标)已经出现过了
	for i := 0; i < n; i++ {
		num := int(math.Abs(float64(nums[i]))) // 拿到当前下标对应的元素的绝对值
		if num <= n {
			nums[num-1] = int(math.Abs(float64(nums[num-1])) * -1)
		}
	}
	// 最后一轮遍历是找数组中仍是正数的下标,该下标所在的位置就是所求
	for i := 0; i < n; i++ {
		if nums[i] > 0 {
			return i + 1
		}
	}
	// 以上运算都找不到正数,则都已经标记为负数,直接返回 n + 1
	return n + 1
}

5 )方案5

func firstMissingPositive(nums []int) int {
	n := len(nums)
	// 第一轮遍历
	for i := 0; i < n; i++ {
		// 如果当前元素在 0 ~ n 之间, 当前元素 和 当前元素对应的位置 - 1 (下标) 不一致 则进行交换
		for nums[i] > 0 && nums[i] <= n && nums[nums[i]-1] != nums[i] {
			nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1] // 交换
		}
	}
	// 第二轮遍历,找到第一个当前值与当前位置不匹配时的位置(备注: 位置比下标大1)
	for i := 0; i < n; i++ {
		if nums[i] != i+1 {
			return i + 1
		}
	}
	return n + 1
}
heygem本地部署报错:SQLite3 can only bind numbers, strings, bigints, buffers, and null...如何解决? 🏆本文收录于 《全栈Bug调优(实战版)》 专栏,该专栏专注于分享我在真实项目开发中遇到的各类疑难Bug及其深层成因,并系统提供高效、可复现的解决思路和实操方案。无论你是刚入行的新手开发者,还是拥有多年项目经验的资深工程师,本专栏都将为你提供一条系统化、高质量的问题排查与优化路径,助力你加速成长,攻克技术壁垒,迈向技术价值最大化与职业发展的更高峰🚀!    📌 特别说明: 文中部分技术问题来源于真实生产环境及网络公开案例,均经过精挑细选与系统化整理,并结合多位大厂资深架构师和一线开发多年实战经验沉淀, 阅读详情

相关推荐

发那科机器人抓手与物料搬运阀的配置与优化实践

本文详细介绍了发那科机器人抓手与物料搬运阀的配置与优化实践,包括基础配置指南、阀岛与输入模块的详细设置、测试程序编写与验证技巧,以及常见问题排查与性能优化建议。通过实际案例和经验分享,帮助技术人员快速掌握关键配置步骤,提升物料搬运系统的稳定性和效率。

weixin_33738555的博客 387

数据结构与算法笔记:字典序最大问题分析

字典序最大问题 问题描述 给定一个1到n的排列(无序状态的),依次插入到栈中,在每时每刻都可以多次从栈中弹出栈顶 问:应如何使得弹出栈顶的序列的字典序最大,并输出这个序列 问题分析 什么是字典序 比如两个序列:5,4,3,2,1和1,2,3,4,5 这两个中第一个的字典序最大 每个位置上的数字比其他序列上同一位置的数字要大 比如:第一位置中5比1大,第二位置中4比2大这样 即:字典序最大 = 从左向右看这个序列,每个数字都尽量大 题目给定一个1到n的排列,每个数字只出现一次 要使出栈的字典序最大

Wang的专栏 4393

【FOC无刷电机控制】六步换向、FOC,STM32cubemx从零开始搭建BLDC六步换相代码、FOC代码(基于霍尔传感器)

FOC、六步换相,无刷电机控制

xifan的博客 3万+

数据结构与算法笔记:农夫过河问题python3实现

问题描述 农夫(Human)过河。一个农夫带着一只狼(Wolf),一只羊(Sheep)和一些菜(Vegetable)过河。河边只有一条船,由于船太小,只能装下农夫和他的一样东西。在无人看管的情况下,狼要吃羊,羊要吃菜,请问农夫如何才能使三样东西平安过河? 要求: 输出一行,为最终的过河方式,方案格式为 过河人员、回来人员、过河人员、回来人员、…、过河人员。 过去和回来的人员之间,用空格隔开。 以四...

Wang的专栏 3374

Android 13 GMS认证避坑:手把手教你搞定RKP配置,解决GTS测试fail

本文详细解析Android 13 GMS认证中的RKP(远程密钥配置)全流程,提供GTS测试失败的深度解决方案。从RKP核心概念到实战配置技巧,帮助开发者规避常见陷阱,确保设备顺利通过Google安全认证,特别适合需要快速掌握Android13 GMS认证的工程师参考。

weixin_29796279的博客 468

5G初始注册流程详解(2)-Registration Request

1:了解注册的本质,5G终端为什么要注册? 2:SUCI,SUPI,5G-GUTI的区别? 3:为什么会有COMPLETE REGISTRATION REQUEST呢?

weixin_53220301的博客 3795

数据结构与算法笔记:计算思维之经典农夫过河问题C++实现

农夫、羊、狼、菜的过河问题 问题描述 角色:农夫,羊,狼,菜 条件1:船很小,只能装下农夫和其他一个角色 条件2:无人看管,羊吃菜,狼吃羊 问:如何让其他三种角色被农夫平安带着过河? 相关分析 我们可以先用人脑尝试一下相关渡河策略 1 ) 先渡狼,人回来再渡菜,人回来再渡羊 2 ) 先渡菜,人回来再渡狼,人回来再渡羊 以上两种很好想到,而且我们可以知道羊这种角色是不能先渡河过去的,羊需要最后再渡 如果先渡了羊了,之后再渡任何其他角色,都要将羊带回来 可以参考小游戏:http://gameschool

Wang的专栏 3314

树莓派 SPI操作

扩展板配备一款0.96inch,128864分辨率的oled显示屏,通过SPI控制,先上显示效果图。由于程序过长,在这里我就不把代码全部贴出来了,只是简单讲解一下spi的操作函数。管脚如下如所有,左边方框的管脚分别为MOSI MISO SCLK,左边CE0,CE1为两个片选管脚,分别对应上图中的spidev0.0,spidev0.1两个设备。下载spidev库,复制到树莓派,并行运行如下命令解压安装。spi设备,此处设备为/dev/spi-decv0.0。在/dev路径下面,我们可以发现两个spi设备。

weixin_46529898的博客 917

数据结构与算法笔记:图搜索之DFS详解

图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) !!!本文详解!!! 深度优先搜索DFS 深度优先遍历DFS, 这个策略其实是非常stupid or simple的,比BSF要简单的多 同样,我们可以通过一个故事来开始 在古希腊神话中, Ariadne是Crete的国王Minos的公主,她给忒修斯(Theseus)一个线团 使得忒修斯成功进入迷宫杀死牛头怪兽,但事后忒修斯抛弃了她 这是一个有道德意义的故事又或者存在不同的版本, 但不是我们的研究的对象

Wang的专栏 3119

livox avia平台搭建

livox雷达数据采集平台搭建

Shilong的博客 1311

基于XDMA 的PCIE读写DDR

基于XDMA 的PCIE读写DDR 概述:   想实现基于FPGA的PCIe通信,查阅互联网各种转载…基本都是对PCIe的描述,所以想写一下基于XDMA的PCIe通信的实现(PCIe结构仅做简单的描述(笔记),了解详细结构移至互联网)。 实现功能:PC通过PCIE读写DDR,同时用户通过逻辑代码可以读取被写入DDR内的数据(我是通过VIO实现DDR任意地址,任意数据大小的读取。)。 实践实践!!! 说明: 参考文档: PCI Express Base Specification Revision 3.0 P

Crazzy_M的博客 1万+

数据结构与算法笔记:计算思维之人鬼渡河问题

人鬼渡河问题 1 ) 问题描述 目标:将东岸的3人3鬼通过一只小船安全转移到西岸,希望摆渡次数尽可能少 条件 船的容量有限,一次最多只能坐2人(或2鬼或1人1鬼) 无论是在河的东岸还是在河的西岸,一旦鬼数多于人数,则人将被鬼吃掉 怎样渡河的大权掌握在人的手中 说明:划船的时间忽略不计。船一靠岸即将船与岸视为一体,人和鬼即使还没有下 船也视为已上岸 任务:编写程序,求出一种渡河方案 备注:图片托管于github,请确保网络的可访问性 2 ) 分析 目标是找

Wang的专栏 2447

【AI编程】Trae 环境搭建与配置从使用到项目实战详解

Trae 环境搭建与配置从使用到项目实战详解

congge 5652

数据结构与算法之二叉树: LeetCode 701. 二叉搜索树中的插入操作 (Ts版)

1 ) 方案1:模拟。2 ) 方案2:递归。

Wang的专栏 2270

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

数据结构与算法笔记:计算思维之下楼梯台阶和象棋跳马问题

下台阶问题 1 ) 问题描述 从楼上走到楼下共有 h 个台阶,每一步有三种走法 走一个台阶; 走二个台阶; 走三个台阶。 问:一共可以走出多少种方案? 即共要多少步? 每一步走几级台阶? 2 ) 分析 初始思路 我们根据题目给定的场景,先简单模拟一下,设定 h=4h=4h=4 备注:图片托管于github,请确保网络的可访问性 如上图所示, 这里有4阶楼梯, 红色数字代表每一步走几级台阶 这里枚举了4层台阶的所有可能情况, 但是不管具体有几级台阶,下

Wang的专栏 2113

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

Python笔记:滑动验证码的识别算法

概述 用程序识别极验滑动验证码的验证,包括分析识别思路、识别缺口位置、生成滑块拖动路径、模拟实现滑块拼合通过验证等步骤。 准备工作 使用Python库是Selenium,浏览器为Chrome。请确保已安装Selenium库和ChromeDriver浏览器驱动。 关于极验滑动验证码: 极验滑动验证码官网为:http://www.geetest.com/ 验证方式为拖动滑块拼合图像,若图像完全拼合...

Wang的专栏 2104

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

数据结构与算法之堆: LeetCode 295. 数据流的中位数 (Ts版)

/ 返回 1.5 ((1 + 2) / 2)中位数是有序整数列表中的中间值。如果列表的大小是偶数,则没有中间值,中位数是两个中间值的平均值。3 ) 方案3:有序集合 + 双指针。2 ) 方案2:优先队列-优化版。1 ) 方案1:优先队列。

Wang的专栏 1907

数据结构与算法笔记:计算思维之谁做的好事与刑侦作案问题

谁做的好事 清华附中有四位同学中的一位做了好事,不留名,表扬信来了之后,校长问这四位是谁做的好事。 A说:不是我。 B说:是C。 C说:是D。 D说:他胡说。 已知:三个人说的是真话,一个人说的是假话。 现在请你根据这些信息,编写程序找出做了好事的人。 分析 将四个人说的四句话(自然语言)转换成计算机可以计算的式子, 可使用循环枚举的方式来判断 (1) 思路一:通过字符表示人 先定义一个字符变量 thisman 表示要寻找的做了好事的人的“名字(代号)”(A、B、C、D),即 char this

Wang的专栏 1833

数据结构与算法笔记:图搜索之BFS详解

图搜索 Graph Search 图搜索的分类 BFS广度优先(宽搜) DFS深度优先(深搜) 广度优先搜索BFS 我们可以用比喻来说明广度优先搜索算法 在一片草木枯黄的深秋草原上,在草原的某一处出现了一处野火 一开始的时候野火集中于一点之上,在这点野火耗尽当前植被变成灰烬之前点燃了周围的植被 比如节点s是初始火种,假设我们手中有一个秒表,每过1秒,我们的大火会向外迈进一步 这个过程只能向外,不能向内,因为只能点燃植被,不能把灰烬点燃 蓝色的点是即将变为灰烬的点,红色的点是刚被点燃的点,灰色的圆形或

Wang的专栏 1794

数据结构与算法之动态规划: LeetCode 1494. 并行课程 II (Ts版)

给你一个整数 n 表示某所大学里课程的数目,编号为 1 到 n ,数组 relations 中, relations[i] = [xi, yi] 表示一个先修课的关系,也就是课程 xi 必须在课程 yi 之前上。解释:上图展示了题目输入的图。一个最优方案是:第一学期上课程 2 和 3,第二学期上课程 4 ,第三学期上课程 1 ,第四学期上课程 5。然后第二个学期上课程 1 ,第三个学期上课程 4。在一个学期中,你 最多 可以同时上 k 门课,前提是这些课的先修课在之前的学期里已经上过了。

Wang的专栏 1749

数据结构与算法笔记:求直方图最大面积算法分析

直方图最大面积 问题描述 有n列的直方图,第j列高度为hjh_jhj​, 求一个面积最大的子矩阵 备注:图片托管于github,请确保网络的可访问性 格式要求 输入第一行正整数n,第二行n个空格隔开的非负整数 数据范围: 所有直方图的列不会超过30000 关键算法实现 1 ) 算法1:时间复杂度为: O(n3)O(n^3)O(n3)的实现 分析 矩形面积为底和高的乘积 底部从a到b,那么底边长为: b-a+1 高为:min{hi∣a≤i≤b}min \{h

Wang的专栏 1664

数据结构与算法之LRU: 实现 LRU 缓存算法功能 (Ts, Py, Go版)

LRU - Lease Recently Used 最近使用如果内存优先,只缓存最近使用的,删除 ‘沉睡’ 数据核心 api: get set分析。

Wang的专栏 1599

数据结构与算法之贪心: LeetCode 455. 分饼干 (Ts, Py, Go版)

对每个孩子 i,都有一个胃口值 g[i],这是能让孩子们满足胃口的饼干的最小尺寸;并且每块饼干 j,都有一个尺寸 s[j]。如果 s[j] >= g[i],我们可以将这个饼干 j 分配给孩子 i ,这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子,并输出这个最大数值。假设你是一位很棒的家长,想要给你的孩子们一些小饼干。但是,每个孩子最多只能给一块饼干。2 )排序 + 双指针 + 贪心。1 )排序 + 遍历。

Wang的专栏 1568

动态规划(Dynamic Programming)详解:从入门到 LeetCode Hot 100

将一个复杂问题拆分成多个规模更小的子问题,通过保存子问题的计算结果,避免重复计算,最终得到原问题的答案。先看一个经典问题。dp[i] = 以第 i 个元素结尾的最优结果例如最长递增子序列。最长递增子序列不一定以最后一个元素结尾,因此必须遍历整个数组取最大值。dp[i] = 前 i 个元素的最优结果这种情况下,最终答案通常就是dp[n]。关键在于理解 dp 数组的定义。动态规划的核心并不是背诵某个固定模板,而是建立正确的状态定义,并通过状态转移方程解决问题。dp[i] 或 dp[i][j] 表示什么?

zengjiajun2006的博客 893

Hash表:两数之和、字母异位词分组、最长连续序列 [力扣 Hot100]

三道高频哈希表应用题:两数之和(利用HashMap快速查找补数)、字母异位词分组(排序后作为键分组)、最长连续序列(通过HashSet去重并仅从序列起点扩展)。核心思想均为借助哈希结构优化查找效率,避免重复计算。同时提及双指针等其他解法思路,体现算法设计中“空间换时间”的典型策略。

2403_87560480的博客 228

力扣73 矩阵置零

该解法通过标记含0的行和列来实现矩阵置零。遍历矩阵,用布尔数组记录有0的行和列;再遍历一次,若当前行或列被标记,则置为0。时间复杂度O(mn),空间复杂度O(m+n)。

Pniubi的博客 37
上一篇: 数据结构与算法之排序: LeetCode 922. 按奇偶排序数组 II (Ts, Py, Go版)
下一篇: AIGC: 关于ChatGPT这个智能工具带来的几点思考
Wang's Blog
博客等级 码龄12年 7438粉丝 2422原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Wang's Blog

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值