常见的排序算法解析实现

  1. 简单介绍一下排序算法

  2. 具体写一下实现排序的代码

  3. 算法复杂度：时间复杂度和空间复杂度

  4. 是否为稳定排序

选择排序

介绍

SelectSort: 每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。

实现


import java.util.*;public class SelectSort {public static void selectSort(int[] array) {if (array == null) {throw new IllegalArgumentException("The input array cannot be null");}if (array.length <= 1) {return;}int n = array.length;for (int i = 0; i < n - 1; i++) {int minValueIndex = i;for (int j = i + 1; j < n; j++) {if (array[minValueIndex] > array[j]) {minValueIndex = j;}}swapElementInArray(array, i, minValueIndex);}}public static void swapElementInArray(int[] array, int firstIndex, int secondIndex) {if (array == null || array.length == 0) {throw new IllegalArgumentException("The input array cannot be null or empty");}if (firstIndex < 0 || firstIndex >= array.length || secondIndex < 0 || secondIndex >= array.length) {throw new IndexOutOfBoundsException("Invalid index values");}if (firstIndex != secondIndex) {int tempElement = array[firstIndex];array[firstIndex] = array[secondIndex];array[secondIndex] = tempElement;}}public static void main(String[] args) {int[] unorderedArray = {2, 1, 1, 9, 8, 5};System.out.println(Arrays.toString(unorderedArray));selectSort(unorderedArray);System.out.println(Arrays.toString(unorderedArray));}
}

算法复杂度

  • 时间复杂度： O(n^2)
  • 空间复杂度： O(1) 原地排序

稳定性

非稳定排序，初始的两个相等的元素的相对位置发生了变化

冒泡排序

介绍

冒泡排序是一种简单的比较排序算法，它的基本思想是通过多次遍历待排序的元素，依次比较相邻的两个元素，如果它们的顺序不符合排序要求（例如，如果要升序排序，那么左边的元素比右边的元素大），就交换它们的位置。这样，每一轮遍历都会将当前未排序序列中的最大元素“冒泡”到最后的位置，因此得名“冒泡排序”。

具体步骤如下：

  1. 从数组的第一个元素开始，比较相邻的两个元素。
  2. 如果左边的元素大于右边的元素（如果是升序排序），则交换它们的位置。
  3. 继续比较下一对相邻元素，重复步骤 2，直到遍历到数组的倒数第二个元素。
  4. 重复上述步骤，每次遍历都会将未排序序列中的最大元素“冒泡”到最后的位置。
  5. 每一轮遍历都会减少未排序序列的长度，直到整个数组都有序为止。

冒泡排序的时间复杂度为 O(n^2)，其中 n 是待排序元素的数量。虽然它不是效率最高的排序算法，但它的实现非常简单，适用于小规模数据或已经基本有序的数据集。然而，在大规模数据集上使用冒泡排序会很慢，更高效的排序算法如快速排序和归并排序通常更适合处理大型数据集。

实现


import java.util.*;public class BubbleSort {public static void bubbleSort(int[] array) {if (array == null) {throw new IllegalArgumentException("The input array cannot be null");}if (array.length <= 1) {return;}int n = array.length;for (int i = n - 1; i > 0; i--) {boolean hasSwapped = false;for (int j = 0; j < i; j++) {if (array[j] > array[j + 1]) {swapElementInArray(array, j, j + 1);hasSwapped = true;}}if (!hasSwapped) {break;}}}public static void swapElementInArray(int[] array, int firstIndex, int secondIndex) {if (array == null || array.length == 0) {throw new IllegalArgumentException("The input array cannot be null or empty");}if (firstIndex < 0 || firstIndex >= array.length || secondIndex < 0 || secondIndex >= array.length) {throw new IndexOutOfBoundsException("Invalid index values");}if (firstIndex != secondIndex) {int tempElement = array[firstIndex];array[firstIndex] = array[secondIndex];array[secondIndex] = tempElement;}}public static void main(String[] args) {int[] unorderedArray = {2, 1, 1, 9, 8, 5};System.out.println(Arrays.toString(unorderedArray));bubbleSort(unorderedArray);System.out.println(Arrays.toString(unorderedArray));}
}

算法复杂度

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

  • 空间复杂度：O(1) 原地排序

稳定性

 if (array[j] > array[j + 1]) {swapElementInArray(array, j, j + 1);hasSwapped = true;}

稳定排序：array[j] > array[j + 1] 遇到相等的元素不交换

插入排序

介绍

将待排序的数据分为已排序和未排序两部分，初始时已排序部分只包含第一个元素，然后逐步将未排序部分的元素插入到已排序部分中的适当位置，直到所有元素都被排序为止。

实现

import java.util.*;public class InsertSort {public static void insertSort(int[] array) {if (array == null) {throw new IllegalArgumentException("The input array cannot be null");}if (array.length <= 1) {return;}int n = array.length;for (int i = 1; i < n; i++) {int baseElement = array[i];int j = i - 1;while (j >= 0 && array[j] > baseElement) {array[j + 1] = array[j];j--;}array[j + 1] = baseElement;}}public static void main(String[] args) {int[] unorderedArray = {2, 1, 1, 9, 8 ,5};System.out.println(Arrays.toString(unorderedArray));insertSort(unorderedArray);System.out.println(Arrays.toString(unorderedArray));}
}

算法复杂度

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

  • 空间复杂度：O(1) 原地排序

稳定性

while (j >= 0 && array[j] > baseElement) {array[j + 1] = array[j];j--;
}
array[j + 1] = baseElement;

从上面的代码可以看出这是稳定排序，遇到相等的元素了，插入到这一元素的右边。

快速排序

介绍

它基于分而治之的思想，通过将待排序的数组分割成两个子数组，分别排序后再合并，从而实现整个数组的排序。快速排序的特点是平均情况下性能非常好，通常比其他常见的排序算法（如冒泡排序和插入排序）更快。

以下是快速排序的基本思想和步骤：

  1. 选择一个元素作为枢轴（pivot），通常选择数组中的第一个元素或随机选择。枢轴的选择是快速排序的关键，它将数组分为两个子数组。
  2. 划分阶段：将数组中小于枢轴的元素移动到枢轴的左边，将大于枢轴的元素移动到枢轴的右边。这一过程称为分区（partitioning）。可以使用两个指针来遍历数组，一个从左边开始，一个从右边开始，直到它们相遇。在这个过程中，小于枢轴的元素被交换到左边，大于枢轴的元素被交换到右边。
  3. 递归排序：将左右两个子数组分别递归地应用快速排序算法。这将继续划分和排序子数组，直到每个子数组只包含一个元素或为空。
  4. 合并：已排序的子数组会被合并成一个完整的有序数组。

实现

package sorts7;import java.util.*;public class QuickSort {public static void quickSort(int[] array, int leftIndex, int rightIndex) {if (leftIndex >= rightIndex) {return;}int pivotIndex = partition(array, leftIndex, rightIndex);quickSort(array, leftIndex, pivotIndex - 1);quickSort(array, pivotIndex + 1, rightIndex);}public static int partition(int[] array, int leftIndex, int rightIndex) {int i = leftIndex;int j = rightIndex;while (i < j) {while (i < j && array[j] >= array[leftIndex]) {j--;}while (i < j && array[i] <= array[leftIndex]) {i++;}swapElementInArray(array, j, i);}swapElementInArray(array, i, leftIndex);return i;}public static void swapElementInArray(int[] array, int firstIndex, int secondIndex) {if (array == null || array.length == 0) {throw new IllegalArgumentException("The input array cannot be null or empty");}if (firstIndex < 0 || firstIndex >= array.length || secondIndex < 0 || secondIndex >= array.length) {throw new IndexOutOfBoundsException("Invalid index values");}if (firstIndex != secondIndex) {int tempElement = array[firstIndex];array[firstIndex] = array[secondIndex];array[secondIndex] = tempElement;}}public static void main(String[] args) {int[] unorderedArray = {2, 1, 1, 9, 8, 5};System.out.println(Arrays.toString(unorderedArray));quickSort(unorderedArray, 0, unorderedArray.length - 1);System.out.println(Arrays.toString(unorderedArray));}
}

算法复杂度

  • 时间复杂度：O(nlogn) 递归层数为 log n ，循环次数为 n， 时间复杂度为 O(nlogn)

  • 空间复杂度：O(n) 最坏的情况下，使用的是 O(n)的栈帧空间

稳定性

不稳定排序

归并排序

介绍

归并排序的核心思想是将待排序的数组分割成若干个小数组，然后逐个合并这些小数组，最终得到一个有序的数组。归并排序的特点是稳定且具有一定的性能优势，尤其在大型数据集上表现良好。

以下是归并排序的基本思想和步骤：

  1. 分割阶段：将待排序的数组分割成两个相等或近似相等的子数组，通常采用递归方式进行分割，直到每个子数组只包含一个元素或为空。
  2. 合并阶段：逐个合并已分割的子数组，同时保持它们的有序性。合并过程中，将两个有序子数组合并成一个更大的有序数组。这一过程将一直进行，直到所有子数组都被合并成一个完整的有序数组。
  3. 递归排序：递归地对子数组进行归并排序，直到整个数组都有序。

实现

package sorts7;import java.util.*;public class MergeSort {public static int[] mergeSort(int[] array) {if (array.length <= 1) {return array;}int midIndex = array.length >> 1;int[] leftArray = Arrays.copyOfRange(array, 0, midIndex);int[] rightArray = Arrays.copyOfRange(array, midIndex, array.length);return merge(mergeSort(leftArray), mergeSort(rightArray));}public static int[] merge(int[] leftArray, int[] rightArray) {if (leftArray == null || leftArray.length == 0) {return rightArray;}if (rightArray == null || rightArray.length == 0) {return leftArray;}int leftIndex = 0;int rightIndex = 0;int mergedIndex = 0;int[] mergedArray = new int[leftArray.length + rightArray.length];while (leftIndex < leftArray.length && rightIndex < rightArray.length) {if (leftArray[leftIndex] < rightArray[rightIndex]) {mergedArray[mergedIndex++] = leftArray[leftIndex++];} else {mergedArray[mergedIndex++] = rightArray[rightIndex++];}}while (leftIndex < leftArray.length) {mergedArray[mergedIndex++] = leftArray[leftIndex++];}while (rightIndex < rightArray.length) {mergedArray[mergedIndex++] = rightArray[rightIndex++];}return mergedArray;}public static void main(String[] args) {int[] unorderedArray = {2, 1, 1, 9, 8, 5};System.out.println(Arrays.toString(unorderedArray));int[] mergedArray = mergeSort(unorderedArray);System.out.println(Arrays.toString(mergedArray));}
}

算法复杂度

  • 时间复杂度：O(nlogn) 递归的深度为 log n ，合并的时间复杂度为 O(n)， 时间复杂度为 O(nlogn)

  • 空间复杂度：O(n) 最坏的情况下，使用的是 O(n)的栈帧空间

稳定性

稳定排序

堆排序

介绍

堆排序（Heap Sort）是一种基于二叉堆数据结构的排序算法，它的核心思想是将待排序的数组看作是一个二叉堆，通过构建最大堆（Max Heap）或最小堆（Min Heap）来实现排序。在堆排序中，首先将数组转换成一个二叉堆，然后不断从堆中移出最大（或最小）元素，放入已排序部分，直到整个数组有序。

实现

package sorts7;import java.util.*;public class HeapSort {public static void heapSort(int[] array) {if (array == null) {throw new IllegalArgumentException("The input array cannot be null");}if (array.length <= 1) {return;}int n = array.length;for (int i = n / 2 - 1; i >= 0; i--) {heapify(array, i, n);}for (int i = n - 1; i > 0; i--) {swapElementInArray(array, 0, i);heapify(array, 0, i);}}public static void heapify(int[] array, int i, int n) {int maxValueIndex = i;int leftIndex = 2 * i + 1;int rightIndex = 2 * i + 2;if (leftIndex < n && array[leftIndex] > array[maxValueIndex]) {maxValueIndex = leftIndex;}if (rightIndex < n && array[rightIndex] > array[maxValueIndex]) {maxValueIndex = rightIndex;}if (i != maxValueIndex) {swapElementInArray(array, i, maxValueIndex);heapify(array, maxValueIndex, n);}}public static void swapElementInArray(int[] array, int firstIndex, int secondIndex) {if (array == null || array.length == 0) {throw new IllegalArgumentException("The input array cannot be null or empty");}if (firstIndex < 0 || firstIndex >= array.length || secondIndex < 0 || secondIndex >= array.length) {throw new IndexOutOfBoundsException("Invalid index values");}if (firstIndex != secondIndex) {int tempElement = array[firstIndex];array[firstIndex] = array[secondIndex];array[secondIndex] = tempElement;}}public static void main(String[] args) {int[] unorderedArray = {2, 1, 1, 9, 8, 5};System.out.println(Arrays.toString(unorderedArray));heapSort(unorderedArray);System.out.println(Arrays.toString(unorderedArray));}
}

算法复杂度

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

稳定性

不稳定排序

计数排序

介绍

计数排序（Counting Sort）是一种非比较性的整数排序算法，适用于待排序元素都是非负整数的情况。计数排序的核心思想是通过统计每个元素出现的次数，然后根据这些统计信息将元素放置在正确的位置上，从而完成排序。

以下是计数排序的关键特点和步骤：

  1. 找到待排序数组中的最大值，以确定计数数组的大小。计数数组的大小为最大元素值加一。
  2. 创建一个计数数组，用于存储每个元素出现的次数。初始时，计数数组的所有元素都初始化为 0。
  3. 遍历待排序数组，统计每个元素出现的次数，并将统计结果存储在计数数组中。具体来说，对于数组中的每个元素 x，将计数数组中的 counts[x]加 1。
  4. 根据计数数组中的统计信息，重新构建有序数组。遍历计数数组，对于每个元素 x，将 x 重复 counts[x]次放入有序数组中。
  5. 完成排序后，有序数组即为排序结果。

实现

package sorts7;import java.util.*;public class CountSort {public static void countSort(int[] nums) {if (nums == null) {throw new IllegalArgumentException("The input nums cannot be null");}if (nums.length <= 1) {return;}int maxValue = 0;for (int num : nums) {maxValue = Math.max(num, maxValue);}int[] counts = new int[maxValue + 1];for (int num : nums) {counts[num]++;}int sortedIndex = 0;for (int value = 0; value < counts.length; value++) {for (int i = 0; i < counts[value]; i++) {nums[sortedIndex++] = value;}}}public static void main(String[] args) {int[] unorderedArray = {2, 1, 1, 9, 8, 5};System.out.println(Arrays.toString(unorderedArray));countSort(unorderedArray);System.out.println(Arrays.toString(unorderedArray));}
}

算法复杂度

  • 时间复杂度：计数排序的时间复杂度为 O(n + k)，其中 n 是待排序元素的数量，k 是计数数组的大小。当 k 不过于大且是常数时，计数排序的时间复杂度可以近似看作 O(n)

  • 空间复杂度：计数排序的空间复杂度取决于计数数组的大小，通常为 O(k)，其中 k 是计数数组的大小。计数数组的大小取决于待排序数据中的最大元素值。如果待排序数据的范围很大，那么计数数组的大小也会很大，从而导致空间复杂度增加。

稳定性

稳定排序

桶排序

介绍

桶排序（Bucket Sort）是一种分布式排序算法，它将元素分散到多个桶中，然后对每个桶中的元素进行排序，最后将桶中的元素按顺序合并起来，形成有序的输出。桶排序通常用于处理具有均匀分布的输入数据。

以下是桶排序的简要介绍：

初始化桶： 首先，确定要使用的桶的数量，通常是根据输入数据的范围和分布来确定的。每个桶可以是一个容器，可以是数组、链表或其他数据结构。

分配元素到桶中： 接下来，遍历输入数组，将每个元素根据某种规则分配到相应的桶中。分配规则通常是将元素映射到特定的桶索引。这个映射可以使用一种映射函数来完成。

对每个桶进行排序： 一旦元素分配到桶中，就对每个桶中的元素进行排序。通常，桶内排序可以使用快速排序、归并排序等常见的排序算法，也可以选择其他排序方法，具体取决于应用的需要。

合并桶中的元素： 排序后，将各个桶中的元素按照桶的顺序合并起来，形成有序的输出。合并可以通过简单地按顺序访问每个桶中的元素并放入输出数组来实现。

输出结果： 最终得到一个有序的输出数组，其中包含了输入数据的有序排列。

实现

import java.util.*;public class BucketSort {public static void bucketSort(float[] nums) {if (nums == null) {throw new IllegalArgumentException("The input nums cannot be null");}if (nums.length <= 1) {return;}int halfLength = nums.length / 2;List<List<Float>> buckets = new ArrayList<>();for (int i = 0; i < halfLength; i++) {buckets.add(new ArrayList<>());}for (float num : nums) {int bucketIndex = (int) (num * halfLength);buckets.get(bucketIndex).add(num);}for (List<Float> bucket : buckets) {Collections.sort(bucket);}int sortedIndex = 0;for (List<Float> bucket : buckets) {for (float num : bucket) {nums[sortedIndex++] = num;}}}public static void main(String[] args) {float[] unorderedArray = {0.2f, 0.1f, 0.1f, 0.3f, 0.5f, 0.7f, 0.6f};System.out.println(Arrays.toString(unorderedArray));bucketSort(unorderedArray);System.out.println(Arrays.toString(unorderedArray));}}

算法复杂度

  • 时间复杂度: O(n), 当桶的数量比较多的时候。
  • 空间复杂度: O(n + k), 需要借助 k 个桶和 List 中的 n 个元素的额外空间

稳定性

桶排序的稳定性取决于每个桶里面的排序算法的稳定性

for (List<Float> bucket : buckets) {Collections.sort(bucket);
}

github 仓库地址: https://github.com/XIAOZHUXUEJAVA/sorting-algorithms-in-java

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Java 编程实现常见的排序算法

Java 编程实现常见的排序算法

在Java编程中&#xff0c;实现常见的排序算法是一项基础而重要的任务。排序算法是计算机科学中的经典问题之一&#xff0c;涉及将一组元素按照某个顺序进行排列。Java提供了一种非常灵活的编程环境&#xff0c;可以用来实现各种排序算法。 冒泡排序&#xff08;Bubble Sort&am…
阅读更多...
【Maven】＜scope＞provided＜/scope＞

【Maven】＜scope＞provided＜/scope＞

在Maven中&#xff0c;“provided”是一个常用的依赖范围&#xff0c;它表示某个依赖项在编译和测试阶段是必需的&#xff0c;但在运行时则由外部环境提供&#xff0c;不需要包含在最终的项目包中。下面是对Maven scope “provided”的详细解释&#xff1a; 编译和测试阶段可用…
阅读更多...
帆软FineBi V6版本经验总结

帆软FineBi V6版本经验总结

帆软FineBi V6版本经验总结 BI分析出现背景 ​ 现在是一个大数据的时代&#xff0c;每时每刻都有海量的明细数据出现。这时大数据时代用户思维是&#xff1a;1、数据的爆炸式增长&#xff0c;人们比起明细数据&#xff0c;更在意样本的整体特征、相互关系。2、基于明细的“小…
阅读更多...
PyTorch中的 Dataset、DataLoader 和 enumerate()

PyTorch中的 Dataset、DataLoader 和 enumerate()

PyTorch&#xff1a;关于Dataset&#xff0c;DataLoader 和 enumerate() 本博文主要参考了 Pytorch中DataLoader的使用方法详解 和 pytorch&#xff1a;关于enumerate&#xff0c;Dataset和Dataloader 两篇文章进行总结和归纳。 DataLoader 隶属 PyTorch 中 torch.utils.data…
阅读更多...
数据结构之树 --- 二叉树

数据结构之树 --- 二叉树

目录 定义二叉树的结构体 二叉树的遍历 递归遍历 非递归遍历 链式二叉树的实现 二叉树的功能接口 先序遍历创建二叉树 后序遍历销毁二叉树 先序遍历查找树中值为x的节点 层序遍历 上篇我们对二叉树的顺序存储堆进行了讲述&#xff0c;本文我们来看链式二叉树。 定…
阅读更多...
SpringCloud(H版alibaba)框架开发教程之nacos做配置中心——附源码（2）

SpringCloud(H版alibaba)框架开发教程之nacos做配置中心——附源码（2）

上篇主要讲了使用eureka&#xff0c;zk&#xff0c;nacos当注册中心 这篇内容是nacos配置中心 代码改动部分mysql驱动更新到8.0&#xff0c;数据库版本升级到了8.0&#xff0c;nacos版本更新到了2.x nacos2.x链接 链接&#xff1a;https://pan.baidu.com/s/11nObzgTjWisAfOp…
阅读更多...
探秘交互设计：深入了解五大核心维度！

探秘交互设计：深入了解五大核心维度！

交互式设计是用户体验&#xff08;UX&#xff09;设计的重要组成部分。本文将解释什么是交互设计&#xff0c;并分享一些有用的交互设计模型&#xff0c;并简要描述交互设计师通常做什么。 如何解释交互设计 交互式设计可以用一个简单的术语来理解&#xff1a;它是用户和产品…
阅读更多...
探索深度学习在自然语言处理中的应用

探索深度学习在自然语言处理中的应用

摘要&#xff1a; 随着人工智能技术的不断发展&#xff0c;深度学习在自然语言处理领域的应用越来越广泛。本文将探讨深度学习在自然语言处理中的各种应用&#xff0c;包括文本分类、情感分析、机器翻译等&#xff0c;并分析其优缺点。 一、引言 自然语言处理&#xff08;NLP…
阅读更多...
借贷协议 Tonka Finance：铭文资产流动性的新破局者

借贷协议 Tonka Finance：铭文资产流动性的新破局者

“Tonka Finance 是铭文赛道中首个借贷协议&#xff0c;它正在为铭文资产赋予捕获流动性的能力&#xff0c;并为其构建全新的金融场景。” 在 2023 年的 1 月&#xff0c;比特币 Ordinals 协议被推出后&#xff0c;包括 BRC20&#xff0c;Ordinals 等在内的系列铭文资产在包括比…
阅读更多...
nginx源码分析-3

nginx源码分析-3

这一章内容讲述nginx中的事件是如何一步步添加到epoll实例中的。 在初始化http连接的函数ngx_http_init_connection中&#xff0c;nginx为http连接初始化了处理请求的回调函数&#xff0c;之后调用ngx_handle_read_event函数对可读数据进行处理。这里只为连接设置read而没有设…
阅读更多...
Ubuntu22.04 安装教程

Ubuntu22.04 安装教程

系统下载 Ubuntu官网下载 清华源镜像 安装流程 1. 选择安装语言 2. 选择是否在安装时更新 为了系统安装速度一般选择安装时不更新&#xff0c;安装后自行更新 3. 选择系统语言和键盘布局 4. 选择安装模式 5. 配置网络信息 6. 设置静态IP 7. 配置代理信息 8. 配置Ubuntu镜像…
阅读更多...
非常好用的ocr图片文字识别技术，识别图片中的文字

非常好用的ocr图片文字识别技术，识别图片中的文字

目录 一.配置环境 二.应用 2.1常见图片识别 2.2排版简单的印刷体截图图片识别 2.3竖排文字识别 2.4英文识别 2.5繁体中文识别 2.6单行文字的图片识别 三.参考 一.配置环境 pip3 install cnocr -i https://pypi.tuna.tsinghua.edu.cn/simple pip3 install onnxruntime…
阅读更多...
在电脑上免费分区的 5 个有效磁盘分区软件工具

在电脑上免费分区的 5 个有效磁盘分区软件工具

磁盘分区可能是一个脆弱而复杂的过程&#xff0c;磁盘崩溃或用户设备受到病毒攻击的风险很高。因此&#xff0c;它们很难由用户单独或手动管理。本文详细介绍了可以帮助简化磁盘分区过程的不同软件工具、它们的功能和优点。那么让我们开始吧。 什么是磁盘分区工具&#xff1f; …
阅读更多...
在STM32中集成TSL2561光强传感器的开发和调试

在STM32中集成TSL2561光强传感器的开发和调试

在STM32中集成TSL2561光强传感器的开发和调试是一个常见的应用场景。TSL2561是一款数字光传感器&#xff0c;能够测量可见光和红外光的光强&#xff0c;并通过I2C接口将数据传输给微控制器。下面将为您介绍在STM32中集成TSL2561传感器的开发步骤&#xff0c;并附上相应的代码示…
阅读更多...
Web常用的编码和解码技术

Web常用的编码和解码技术

文章目录 一、URI的编码与解码1.1 URI介绍1.2 什么是encodeURI1.3 什么是encodeURIComponent1.4 应用场景1.5 URI解码1.6 扩展&#xff1a;内置对象URL 二、字符串的Base64编码与解码2.1 ASCII字符编解码2.2 非ASCII字符编解码 一、URI的编码与解码 1.1 URI介绍 URI指的是统一…
阅读更多...
【音视频 ffmpeg 学习】 RTMP推流 mp4文件

【音视频 ffmpeg 学习】 RTMP推流 mp4文件

1.RTMP(实时消息传输协议)是Adobe 公司开发的一个基于TCP的应用层协议。 2.RTMP协议中基本的数据单元称为消息&#xff08;Message&#xff09;。 3.当RTMP协议在互联网中传输数据的时候&#xff0c;消息会被拆分成更小的单元&#xff0c;称为消息块&#xff08;Chunk&#xff…
阅读更多...
Linux系统下隧道代理HTTP

Linux系统下隧道代理HTTP

在Linux系统下配置隧道代理HTTP是一个涉及网络技术的话题&#xff0c;主要目的是在客户端和服务器之间建立一个安全的通信通道。下面将详细解释如何进行配置。 一、了解基本概念 在开始之前&#xff0c;需要了解几个关键概念&#xff1a;代理服务器、隧道代理和HTTP协议。代理…
阅读更多...
VsCode的介绍和入门详细讲解

VsCode的介绍和入门详细讲解

VS Code&#xff08;Visual Studio Code&#xff09;是由 Microsoft 开发的一款轻量级开源编辑器&#xff0c;支持多种语言和框架的编写、调试和测试。它拥有丰富的扩展生态系统&#xff0c;可以满足不同开发者的需求。 下面是 VS Code 的入门详细讲解&#xff1a; 下载和安装…
阅读更多...
使用Python绘制各种图表

使用Python绘制各种图表

1、折线图&#xff08;Line Chart&#xff09; import matplotlib.pyplot as plt # 数据 x [1, 2, 3, 4, 5] y [2, 4, 1, 3, 7] # 绘制折线图 plt.plot(x, y) plt.title(折线图示例) plt.xlabel(X轴) plt.ylabel(Y轴) plt.show() 2、柱状图&#xff08;Bar…
阅读更多...
算法专题四：前缀和

算法专题四：前缀和

前缀和 一.一维前缀和(模板)&#xff1a;1.思路一&#xff1a;暴力解法2.思路二&#xff1a;前缀和思路 二. 二维前缀和(模板)&#xff1a;1.思路一&#xff1a;构造前缀和数组 三.寻找数组的中心下标&#xff1a;1.思路一&#xff1a;前缀和 四.除自身以外数组的乘积&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023