JavaScript算法描述【排序与搜索】六大经典排序|搜索旋转排序数组|在排序数组中查找元素的第一个和最后一个位置、数组中的第K个|

🐧主页详情：Choice~的个人主页

文章目录

    • 搜索旋转排序数组
      • 方法一 二分查询最大最小值
      • 思路
      • 详解
      • 代码
      • 方法二 二分查询中间数
  • 在排序数组中查找元素的第一个和最后一个位置、数组中的第K个最大元素和颜色分类
    • 在排序数组中查找元素的第一个和最后一个位置
      • 方法一 二分查找
    • 数组中的第K个最大元素
      • 方法一
      • 方法二
      • 方法三
      • 题外话
    • 颜色分类
      • 方法一 直接计算
      • 方法二 双指针遍历
      • 方法三 使用各种排序法

搜索旋转排序数组

假设按照升序排序的数组在预先未知的某个点上进行了旋转。

( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。

搜索一个给定的目标值，如果数组中存在这个目标值，则返回它的索引，否则返回 -1 。

你可以假设数组中不存在重复的元素。

你的算法时间复杂度必须是 O(log n) 级别。

示例 1:

输入: nums = [4,5,6,7,0,1,2], target = 0
输出: 4

示例 2:

输入: nums = [4,5,6,7,0,1,2], target = 3
输出: -1

方法一 二分查询最大最小值

思路

先算出 数组中最大最小值，利用 indexOf 计算之后要旋转位置，然后二分计算目标 target 位置

详解

  1. 计算数组中的最大最小值
  2. 定义变量，数组长度等
  3. 目标值大于数组最后一位时，数组查询位置从 0 到数字中在最大位置
  4. 目标值小于等于数组最后一位时，数组查询位置从数组中最小值的位置开始，到数组的最后一位，3.4 两部为了定位数组查询区间
  5. 循环二分查询，计算定位数组的中间值，数组的值等于目标查询结束
  6. 不等于的情况，如果目标大于中间值，则定位数组最小值等于中间值+1，目标小于中间值，则定位数组中最大值等于中间值-1，继续循环查询即可，知道定位数组查询完毕，没有结果的话，返回 -1 代表不存在

代码

const search = function (nums, target) {
  const min = Math.min.apply(null, nums);
  const max = Math.max.apply(null, nums);
  const len = nums.length;
  let pos;
  let lo;
  let hi;
  let mid;

  if (target > nums[len - 1]) {
    pos = nums.indexOf(max);
    lo = 0;
    hi = pos;
  } else {
    pos = nums.indexOf(min);
    lo = pos;
    hi = len - 1;
  }
  while (lo <= hi) {
    mid = Math.ceil((lo + hi) / 2);
    if (nums[mid] === target) return mid;
    if (nums[mid] < target) {
      lo = mid + 1;
    } else {
      hi = mid - 1;
    }
  }
  return -1;
};

复杂度分析：

  • 时间复杂度：O(log(n))O(log(n))

    过程会最多遍历一遍数组

  • 空间复杂度：O(1)O(1)

    只产生一次临时变量存储

方法二 二分查询中间数

思路

根据数组的中间数和左右节点的大小对比，来确定升序部分的位置，然后用二分法查询目标节点在数组中的位置

详解

  1. 计算数组长度，数组为0 直接返回-1
  2. 定义左右值分别为数组第一个和最后一个的下标
  3. 中间下标值为最大最小值的平均数
  4. 如果数组中间数等于目标直接返回下标
  5. 数组的中间值小于数组最后一个值，后半部分还处于升序，如果目标值在这部分数组中，则左下标等于中间值+1，代表目标值在后半部分数组，反着重新定义右下标为中间值-1，目标在前半数组
  6. 数组中间值大于数组最后一个值，代表前半部分数组处于升序，如果目标在前半数组中，右标更新为中间值-1，反之，左下标更新为中间值+1
  7. 二分查询到最后没找到目标值，则返回 -1 代表不存在

代码

const search = function(nums, target) {
  if(nums.length === 0){
    return -1;
  }

  let left = 0;
  let right = nums.length - 1;
  let mid;

  while(left <= right){
    mid = parseInt((left + right) / 2);
    if(nums[mid] === target){
      return mid;
    } else if(nums[mid] < nums[right]) {
      if(nums[mid] < target && target <= nums[right]) {
            left = mid + 1;
      } else {
        right = mid - 1;
      }
    } else {
      if(nums[left] <= target && target < nums[mid]){
            right = mid - 1;
      } else {
        left = mid + 1;
      }
    }
  }
  return -1;
};

复杂度分析

  • 时间复杂度：O(log(n))O(log(n))

    过程会最多遍历一遍数组

  • 空间复杂度：O(1)O(1)

    只产生一次临时变量存储

在排序数组中查找元素的第一个和最后一个位置、数组中的第K个最大元素和颜色分类

在排序数组中查找元素的第一个和最后一个位置

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

你的算法时间复杂度必须是 O(log n) 级别。

如果数组中不存在目标值，返回 [-1, -1]。

示例

输入: nums = [5,7,7,8,8,10], target = 8
输出: [3,4]

输入: nums = [5,7,7,8,8,10], target = 6
输出: [-1,-1]

方法一 二分查找

思路

由于数组已经时升序排列，可直接根据二分查找，往左定位第一个位置，往右定位最后一个位置 二分查找的实现上可以使用循环或者递归。

详解

  1. 根据二分查找，找到左边第一个不小于目标值的位置
  2. 从上一步中的位置开始到最后，二分查找，确定右边最后一个符合条件值的位置
  3. 得到结果
function getBinarySearchLowerBound (array, low, high, target) {
  // 找到第一个不小于目标值的位置
  while (low < high) {
    const mid = Math.floor((low + high) / 2);
    if (array[mid] < target) {
      low = mid + 1;
    } else {
      high = mid;
    }
  }

  // 如果相等，则匹配，否则不匹配
  return array[low] === target ? low : -1;
}

function getBinarySearchUpperBound (array, low, high, target) {
  // 找到第一个不大于目标值的位置
  while (low < high) {
    const mid = Math.ceil((low + high) / 2);
    if (array[mid] > target) {
      high = mid - 1;
    } else {
      low = mid;
    }
  }

  // 如果相等，则匹配，否则不匹配
  return array[high] === target ? high : -1;
}

const searchRange = function (nums, target) {
  const size = nums.length;
  const low = getBinarySearchLowerBound(nums, 0, size - 1, target);
  if (low === -1) {
    return [-1, -1];
  }
  // 从左边数字的位置开始
  const high = getBinarySearchUpperBound(nums, low >= 0 ? low : 0, size - 1, target);
  return [low, high];
};

复杂度分析

  • 时间复杂度：O(log(n))O(log(n))

    过程中最差情况会遍历二遍数组

  • 空间复杂度：O(1)O(1)

    产生三个临时变量存储

数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

示例1：

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5

示例2：

输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

说明：你可以假设 k 总是有效的，且 1 ≤ k ≤ 数组的长度。

方法一

思路

首先通过快速排序的方法将数组升序排序，此时数组的头部为最小的元素，尾部为数组最大的元素。题目要求找到数组中的第 K 个最大的元素，即返回 length - k 个元素即可。

详解

  1. 本方法采用快速排序法；
  2. 首先通过 arr[Math.floor((start + end) / 2)] 找到数组中间的元素作为主元；
  3. 然后使用双指针，分别从数组的头部和尾部遍历数组；
  4. 遍历过程中，把比主元小的数都放到主元的左边，比主元大的数都放到主元的右边，实现数组的升序排序；
  5. 返回第 length - k 个元素，即为数组中第 k 个最大的元素。

1

const findKthLargest = function (nums, k) {
  return findK(nums, 0, nums.length - 1, nums.length - k);
};

function findK (arr, start, end, k) {
  if (start === end) return arr[start];
  // 主元
  const pivot = arr[Math.floor((start + end) / 2)];
  let i = start; let j = end;
  while (i <= j) {
    while (arr[i] < pivot) i++;
    while (arr[j] > pivot) j--;
    if (i <= j) {
      swap(arr, i, j);
      i++;
      j--;
    }
  }
  // 二分查到k位置
  if (k >= (i - start)) {
    return findK(arr, i, end, k - i + start);
  } else {
    return findK(arr, start, i - 1, k);
  }
}
// 元素交换
function swap (arr, i, j) {
  const temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

复杂度分析

  • 时间复杂度： O(n log n)O(nlogn)

上述解法中，采用了快速排序的方法，快排的时间复杂度 O(n log n)O(nlogn)。

  • 空间复杂度： O(1)O(1)

上述解法中，申请了四个额外的临时存储空间，这将耗费 O(1)O(1) 的空间。

方法二

思路

首先通过最小堆排序的方法将数组升序排序，排序完的数组如下图所示：

image-20220807191400477

此时数组的头部为最小的元素，尾部为数组最大的元素。题目要求找到数组中的第 K 个最大的元素，即返回 length - k 个元素即可。

详解

  1. 本方法采用最小堆排序法；
  2. 首先建立最小堆，将每个叶子结点视为一个堆，再将每个叶子结点与其父节点一起构成一个包含更多结点的堆；
  3. 所以在构造堆的时候，首先需要找到最后一个结点的父节点，从这个节点开始构造最小堆，直到该节点前面的所有分支节点都处理完毕；
  4. 然后返回第 length - k 个，即为数组中第 k 个最大的元素。
const findKthLargest = function (nums, k) {
  const size = nums.length;
  // 建立堆
  for (let i = parseInt(size / 2) + 1; i >= 0; i--) {
    heapify(nums, i, size);
  }
  // 排序
  for (let j = size - 1; j >= size - k; j--) {
    // 得到本次的最大，将最大的与最后一个交换位子
    swap(nums, 0, j);
    heapify(nums, 0, j);
  }
  return nums[size - k];
};

function heapify (arr, x, length) {
  // 左右两个子节点
  const l = 2 * x + 1;
  const r = 2 * x + 2;
  let largest = x;
  if (l < length && arr[l] > arr[largest]) {
    largest = l;
  }
  if (r < length && arr[r] > arr[largest]) {
    largest = r;
  }
  if (largest !== x) {
    swap(arr, x, largest);
    // 递归交换以下的是否也建好堆.
    heapify(arr, largest, length);
  }
}

function swap (arr, i, j) {
  const temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

复杂度分析

  • 时间复杂度： O(n log n)O(nlogn)

上述解法中，采用了堆排序的方法，堆排序的时间复杂度 O(n log n)O(nlogn)。

  • 空间复杂度： O(1)O(1)

上述解法中，申请了四个额外的临时存储空间，这将耗费 O(1)O(1) 的空间。

方法三

思路

首先通过冒泡排序的方法将数组升序排序，此时数组的头部为最小的元素，尾部为数组最大的元素。题目要求找到数组中的第 K 个最大的元素，即返回 length - k 个元素即可。

详解

  1. 本方法采用经典冒泡排序法；
  2. 比较相邻的元素，如果第一个比第二个大，就交换他们两个；
  3. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对；
  4. 完成步骤 3 后，最后的元素会是最大的数，实现升序排序；
  5. 返回第 len-k 个元素，即为数组中第 k 个最大的元素。
const findKthLargest = function (nums, k) {
  const len = nums.length;
  for (let i = len - 1; i > 0; i--) {
    // 冒泡排序
    for (let j = 1; j <= i; j++) {
      // 异或交换，详见题外话解析
      if (nums[j - 1] > nums[j]) {
        nums[j - 1] ^= nums[j];
        nums[j] ^= nums[j - 1];
        nums[j - 1] ^= nums[j];
      }
    }
    if (i === (len - k)) {
      return nums[i];
    }
  }
  return nums[0];
};

复杂度分析

  • 时间复杂度： O(n^2)O(n2)

上述解法中，内外两层循环，时间复杂度 O(n^2)O(n2)。

  • 空间复杂度： O(1)O(1)

上述解法中，最优的情况是开始时元素已经按顺序排好，空间复杂度为 0 ，最差的情况是开始时元素逆序排序，此时空间复杂度 O(n)O(n)，平均空间复杂度 O(1)O(1)。

复杂度分析：

  • 时间复杂度： O(n^2)O(n2)，内外两层循环，时间复杂度 O(n^2)O(n2)
  • 空间复杂度： O(1)O(1)，最优的情况是开始时元素已经按顺序排好，空间复杂度为0，最差的情况是开始时元素逆序排序，此时空间复杂度 O(n)O(n)，平均空间复杂度 O(1)O(1)

题外话

对于给定两个整数a,b，下面的异或运算可以实现a,b的交换，而无需借助第3个临时变量：

a = a ^ b;
b = a ^ b;
a = a ^ b;

这个交换两个变量而无需借助第3个临时变量过程，其实现主要是基于异或运算的如下性质：

  1. 任意一个变量X与其自身进行异或运算，结果为0，即X ^ X=0
  2. 任意一个变量X与0进行异或运算，结果不变，即X ^ 0=X
  3. 异或运算具有可结合性，即a ^ b ^ c =（a ^ b）^ c= a ^（ b ^ c）
  4. 异或运算具有可交换性，即a ^ b = b ^ a

分析：

第一步： a = a ^ b;

完成后 a变量的结果为a ^ b

第二步： b = a ^ b;

此时赋值号右边的 a 保存的是 a ^ b 的值，那么将赋值号右边的 a 用 a ^ b 替换，

得到（a ^ b） ^ b = a ^ (b ^ b)=a ^ 0=a,

即经过第二步运算后 b 中的值为 a ，即 b=a ，将 a 换到了 b 里

第三步： a = a ^ b;

此时赋值号右边的 a 保存的仍然是 a ^ b 的值，不变，而赋值号右边的 b 已经是 a 了，

将赋值号右边的 a,b 分别进行替换，

即此时赋值号右边 a ^ b=（a ^ b）^ a=a ^ b^ a=a ^ a^ b=0^ b=b, 该值赋值给 a ,即 a=b

即经过第三步运算后 a 中的值为 b ，即 a=b, 将 b 换到了 a 里

这样经过如上的三步骤，完成了交换两个变量 a,b 而无需借助第 3 个临时变量过程。

颜色分类

给定一个包含红色、白色和蓝色，一共 n 个元素的数组，原地对它们进行排序，使得相同颜色的元素相邻，并按照红色、白色、蓝色顺序排列。

此题中，我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色。

注意: 不能使用代码库中的排序函数来解决这道题。

示例

输入: [2,0,2,1,1,0]
输出: [0,0,1,1,2,2]

方法一 直接计算

思路

直接遍历整个数组，分别计算出红蓝白球的个数，然后按照红色、白色、蓝色顺序依次存入数组。

详解

  1. 设定三个变量 red, white，blue 分别表示红球、白球和蓝球。
  2. 遍历数组，遇到 0 则使 red 自增1，遇到 1 则使 white 自增1，遇到 2 则使 blue 自增1。
  3. 根据红白蓝的个数，依次将 0，1，2 存入数组。
/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
const sortColors = function (nums) {
  let red = 0;
  let blue = 0;
  let white = 0;
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] === 0) {
      red++;
    } else if (nums[i] === 1) {
      blue++;
    } else if (nums[i] === 2) {
      white++;
    }
  }
  let index = 0;
  for (let i = 0; i < red; i++) {
    nums[index++] = 0;
  }
  for (let i = 0; i < blue; i++) {
    nums[index++] = 1;
  }
  for (let i = 0; i < white; i++) {
    nums[index++] = 2;
  }
};

复杂度分析

  • 时间复杂度： O(n)O(n)
  • 空间复杂度： O(n)O(n)

方法二 双指针遍历

思路

设定三个指针 begin, end, i，用 i 遍历数组，遇到 0，1 时分别将值与 begin, end 指向的值交换。这种方法相对于方法一的好处是只使用了一个常数空间。

详解

  1. 设定一头一尾两个指针 begin 和 end，然后用一个指针 i 从头开始遍历数组。
  2. 如果遇到 0，则将该数值与begin指向的值交换，并且使begin向后移一位。
  3. 如果遇到 2，则将该数值与end指向的值交换，并且使end向前移一位，并且此时不需自加 i。
  4. 如果遇到 1，则继续。
  5. 最终得到新数组。
/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
const sortColors = function (nums) {
  let begin = 0;
  let end = nums.length - 1;
  let i = 0;
  while (i <= end) {
    if (nums[i] === 0) {
      nums[i] = nums[begin];
      nums[begin] = 0;
      i++;
      begin++;
    } else if (nums[i] === 2) {
      nums[i] = nums[end];
      nums[end] = 2;
      end--;
    } else {
      i++;
    }
  }
};

复杂度分析

  • 时间复杂度：O(n)O(n)
  • 空间复杂度：O(1)O(1)

方法三 使用各种排序法

思路

本题的实质是将数字从小到大排序，可以使用各种排序法（冒泡排序法，选择排序法，快速排序法等），这里举一个冒泡排序法的例子。

1

/**
 * @param {number[]} nums
 * @return {void} Do not return anything, modify nums in-place instead.
 */
const sortColors = function (nums) {
  for (let i = 0; i < nums.length; i++) {
    for (let j = 0; j < nums.length - i; j++) {
      if (nums[j] > nums[j + 1]) {
        const tem = nums[j];
        nums[j] = nums[j + 1];
        nums[j + 1] = tem;
      }
    }
  }
};

复杂度分析

  • 时间复杂度：O(n^2)O(n2)

    遍历了两次含n个元素的空间

  • 空间复杂度：O(1)O(1)

    排序过程没有用到新的空间存储数据

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/606514.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【LeetCode刷题】153. 寻找旋转排序数组中的最小值

【LeetCode刷题】153. 寻找旋转排序数组中的最小值

1. 题目链接2. 题目描述3. 解题方法4. 代码 1. 题目链接 153. 寻找旋转排序数组中的最小值 2. 题目描述 3. 解题方法 根据题目分析&#xff0c;可以明确一点&#xff0c;无论该数组如何旋转&#xff0c;都会有这样的一个性质&#xff0c;就是nums[0] > nums[n-1]&#xf…
阅读更多...
CST软件的界面快捷键汇总与操作窗口【入门基础】

CST软件的界面快捷键汇总与操作窗口【入门基础】

CST界面操作快捷键 利用鼠标和键盘快捷键的GUI操作 View > Mouse Control 本章节介绍&#xff0c;使用鼠标和键盘快捷键&#xff0c;操作CST软件的2D/3D GUI (Graphical User Interface图形用户界面)的方法。为了快速方便地操作2D/3D Model&#xff0c;建议熟悉本章节的内…
阅读更多...
springcloud报错：Failed to start bean‘webServerStartStop‘

springcloud报错：Failed to start bean‘webServerStartStop‘

如果你正在使用nacos进行服务注册&#xff0c;然后报一下错误&#xff1a; 那就说明的nacos没有打开&#xff0c;所以找到你的下载nacos的文件夹 好了&#xff0c;错误完美解决~
阅读更多...
eNSP Pro 最新版安装实践

eNSP Pro 最新版安装实践

目录 写在前面什么是eNSP Pro版本配置需求 安装流程宿主机环境安装步骤 写在前面 最近听到说&#xff0c;华为的eNSP Pro不再限制账号使用了&#xff0c;马上尝试了一下。 官网下载链接&#xff1a; https://support.huawei.com/enterprise/zh/enterprise-professional-servic…
阅读更多...
鸿蒙内核源码分析(环境脚本篇) | 编译鸿蒙原来如此简单

鸿蒙内核源码分析(环境脚本篇) | 编译鸿蒙原来如此简单

很香的 Docker 如果只是为了编译鸿蒙,初级的接触鸿蒙,docker是很香的,从第一次接触docker就对它爱不释手, 脏活累活它干了,少了太多的麻烦. docker 编译鸿蒙看编译环境篇就行了, L1 和 L2 都编译通过了.如果要深入的了解鸿蒙,比如调试鸿蒙的代码或编译工具,就需要另辟蹊径了. …
阅读更多...
区块链的可扩展性三难问题

区块链的可扩展性三难问题

这个词是由以太坊的联合创始人Vitalik Buterin创造的&#xff0c;并提出了理想的区块链需要具备的三个特征&#xff1a;去中心化、可扩展性和安全性。 Vitalik还提出&#xff0c;区块链几乎不可能很好地实现所有这三个特征&#xff0c;所以会出现权衡。 因此&#xff0c;今天…
阅读更多...
linux 使用intel oneapi报错报错

linux 使用intel oneapi报错报错

使用intel oneapi 2024.1.0 时经常报这个错误 因为当前 intel2024.1.0没有在使用 需要改回2024.0.0并安装适配的torch的包来运行
阅读更多...
XN297 2.4GHz 单片高速无线收发芯片

XN297 2.4GHz 单片高速无线收发芯片

概述 XN297是一款工作在2.400~2.483GHz世界通用ISM频段的单片无线收发芯片。该芯片集成 射频收发器、频率发生器、晶体振荡器、调制解调器等功能模块&#xff0c;并且支持一对多组网和带 ACK的通信模式。发射输出功率、工作频道以及通信数据率均可配置。 主要特性 1、低功…
阅读更多...
三星硬盘好还是西数硬盘好？硬盘数据丢失怎么找回

三星硬盘好还是西数硬盘好？硬盘数据丢失怎么找回

在数字化时代&#xff0c;硬盘作为数据存储的核心组件&#xff0c;其品质与性能直接关系到用户的数据安全与使用体验。在众多硬盘品牌中&#xff0c;三星与西数无疑是两个备受关注的名字。那么&#xff0c;究竟是三星硬盘更胜一筹&#xff0c;还是西数硬盘更受用户青睐&#xf…
阅读更多...
【项目】使用Yolov8 + tesseract 实现“营业执照”信息解析（OCR） + 输入可为图片或者pdf + 完整代码 + 整体方案 + 全网首发

【项目】使用Yolov8 + tesseract 实现“营业执照”信息解析（OCR） + 输入可为图片或者pdf + 完整代码 + 整体方案 + 全网首发

本项目可用于毕业设计参考、实验等，营业执照分为横版和竖版，整体检测+识别效果如下所示： 说明：图片来源于网络，如有侵权，请联系作者删除。 目录
阅读更多...
DRF 目录总结+思维导图

DRF 目录总结+思维导图

【0】思维导图链接 链接: https://gitmind.cn/app/docs/mcd0bc41 密码: 4350 【一】DRF 基础知识 DRF 基础知识-CSDN博客 【二】CBV 源码解析 Django CBV源码分析-CSDN博客 【三】APIView源码解析 DRF APIView源码分析-CSDN博客 【四】request源码分析 DRF APIView源码分…
阅读更多...
# 从浅入深 学习 SpringCloud 微服务架构（十三）SCG 网关中使用 sentinel 限流

# 从浅入深 学习 SpringCloud 微服务架构（十三）SCG 网关中使用 sentinel 限流

从浅入深 学习 SpringCloud 微服务架构&#xff08;十三&#xff09;SCG 网关中使用 sentinel 限流 一、SCG 网关中使用 sentinel 限流&#xff1a;入门案例 1、基于 Sentinel 的限流&#xff1a; 1&#xff09; Sentinel 支持对 Spring Cloud Gateway, Zuul 等主流的 API G…
阅读更多...
【全开源】Java洗衣清洁服务同城清洗服务小程序源码

【全开源】Java洗衣清洁服务同城清洗服务小程序源码

特色功能&#xff1a; 在线预约与支付&#xff1a;用户可以通过洗衣小程序在线预约洗衣服务&#xff0c;并选择支付方式进行支付&#xff0c;如微信支付、支付宝等。这种在线预约和支付的方式极大地方便了用户&#xff0c;提高了服务的便捷性。智能推荐与选择&#xff1a;根据…
阅读更多...
探索C++的string：从基础到深入

探索C++的string：从基础到深入

文章目录 string类string类的接口string的常见构造string类对象的容量操作string类的遍历及访问操作string类对象的修改操作string类的非成员函数 总结 string类 C中的string类是一个非常重要的字符串处理工具&#xff0c;它提供了一种方便且灵活的方式来处理字符串。它位于标…
阅读更多...
Vue3专栏项目 -- 一、第一个页面（下）

Vue3专栏项目 -- 一、第一个页面（下）

一、Dropdown 组件&#xff08;下拉菜单组件&#xff09;编码 1、基本功能&#xff1a;展示出下拉按钮和下拉菜单栏的样式 我们可以通过bootstrap来实现这个下拉框&#xff0c;需要注意它这个只是有样式&#xff0c;是没有行为的 然后这个下拉按钮的文字展示是根据用户名称展…
阅读更多...
云推流-让ue/unity内容及3D大型模型内容轻松做到网页使用的解决方案

云推流-让ue/unity内容及3D大型模型内容轻松做到网页使用的解决方案

UE&#xff08;Unreal Engine&#xff09;和Unity作为当下最热门的游戏引擎之一&#xff0c;为开发者提供了强大的工具集和平台支持&#xff0c;使得创建高质量、交互式的3D场景变得越来越容易。 然而&#xff0c;当我们把这种较大的资源分享给其他人时&#xff0c;对方可能需要…
阅读更多...
qml拖动交换之Gridview

qml拖动交换之Gridview

qml拖动交换之Gridview 坐标变换代码 QML中mapToItem和mapFromItem的使用 坐标变换 代码 import QtQuick 2.6 import QtQuick.Window 2.2Window {visible: truewidth: 1024height: 480title: qsTr("Drag Icon")property ListModel dataModel: ListModel {ListEleme…
阅读更多...
摩菲Murphy显示器显示表 总线编程器维修PV780B

摩菲Murphy显示器显示表 总线编程器维修PV780B

Murphy仪器维修包括&#xff1a;摩菲数字显示器&#xff1b;摩菲监视仪表&#xff1b;摩菲CAN总线控制器等维修 维修故障包括&#xff1a;黑屏、指示灯无显示&#xff0c;触摸屏上电无反应&#xff0c; 上电蓝屏、白屏&#xff0c;通电几分钟后屏幕变为蓝屏&#xff0c;主板故…
阅读更多...
46. UE5 RPG 增加角色受击反馈

46. UE5 RPG 增加角色受击反馈

在前面的文章中&#xff0c;我们实现了对敌人的属性的初始化&#xff0c;现在敌人也拥有的自己的属性值&#xff0c;技能击中敌人后&#xff0c;也能够实现血量的减少。 现在还需要的就是在技能击中敌人后&#xff0c;需要敌人进行一些击中反馈&#xff0c;比如敌人被技能击中后…
阅读更多...
android基础-多线程

android基础-多线程

多线程&#xff1a; 创建子线程&#xff0c;子线程不允许直接更新UI&#xff0c;试想下如果多个线程去更新UI&#xff0c;则会造成资源错乱&#xff0c;如果枷锁就会使得代码冗余复杂。 android异步处理&#xff1a; 另一种异步多线程方法 doInBackground是在子线程中。
阅读更多...
最新文章

Copyright @ 2022~2023