C++ 实现十大排序算法

        教你手撕排序，这里有一个概念就是稳定排序。假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。并不是其算法复杂度的稳定，注意一下。

        算法（Algorithm） 代表着用系统的方法描述解决问题的策略机制，可以通过一定规范的 输入，在有限时间内获得所需要的 输出。

算法的好坏

        一个算法的好坏是通过 时间复杂度 与 空间复杂度 来衡量的。就是代码需要的时间和内存，也就你时间成本和空间成本。其实这个一个动态的调整，到一定程度，往往就是用空间去换取时间，或者去时间去换取空间（dp其实就是在用空间去换取时间）。当然优秀的代码就是很优秀，排序也是这样，他们的目标都是把一堆数字进行排序。

常见时间复杂度的 “大O表示法” 描述有以下几种：

时间复杂度非正式术语
O(1)常数阶
O(n)线性阶
O(n2)平方阶
O(log n)对数阶
O(n log n)线性对数阶
O(n3)立方阶
O(2n)指数阶

一个算法在N规模下所消耗的时间消耗从大到小如下：

O(1) < O(log n) < O(n) < O(n log n) < O(n2) < O(n3) < O(2n)

指数级的增长是非常快的

常见的排序算法

根据时间复杂度的不同，常见的算法可以分为3大类。

1.O(n²) 的排序算法

  • 冒泡排序

  • 选择排序

  • 插入排序

2.O(n log n) 的排序算法

  • 希尔排序

  • 归并排序

  • 快速排序

  • 堆排序

3.线性的排序算法

  • 计数排序

  • 桶排序

  • 基数排序

各种排序的具体信息

冒泡排序（Bubble Sort）

冒泡排序（Bubble Sort） 是一种基础的 交换排序。

冒泡排序之所以叫冒泡排序，是因为它每一种元素都像小气泡一样根据自身大小一点一点往数组的一侧移动。

算法步骤如下：

  1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个；

  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数；

  3. 针对所有的元素重复以上的步骤，除了最后一个；

  4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

图示如下：

代码如下：

void bubbleSort(vector<int> &a)
{int len = a.size();for (int i = 0; i < len - 1; i++) //需要循环次数{for (int j = 0; j < len - 1 - i; j++) //每次需要比较个数{if (a[j] > a[j + 1]){swap(a[j], a[j + 1]); //不满足偏序，交换}}}
}

还有一种假的写法就是保证第一个最小，第二个次小，比较的是i和j，虽然也是对的，有点像选择排序，但也不是。其不是冒泡排序

选择排序（Selection Sort）

选择排序（Selection sort） 是一种简单直观的排序算法。

选择排序的主要优点与数据移动有关。

如果某个元素位于正确的最终位置上，则它不会被移动。

选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对 n 个元素的表进行排序总共进行至多 n - 1 次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

选择排序的算法步骤如下：

  1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置；

  2. 然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾；

  3. 以此类推，直到所有元素均排序完毕。

图示如下：

代码如下：

void selectionSort(vector<int> &a)
{int len = a.size();for (int i = 0, minIndex; i < len - 1; i++) //需要循环次数{minIndex = i;                     //最小下标for (int j = i + 1; j < len; j++) //访问未排序的元素{if (a[j] < a[minIndex])minIndex = j; //找到最小的}swap(a[i], a[minIndex]);}
}

插入排序（Insertion Sort）

插入排序（Insertion sort） 是一种简单直观的排序算法。

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

插入排序的算法步骤如下：

  1. 从第一个元素开始，该元素可以认为已经被排序；

  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；

  3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；

  4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

  5. 将新元素插入到该位置后；

  6. 重复步骤2~5。

图示如下：

代码如下：

void insertionSort(vector<int> &a)
{int len = a.size();for (int i = 0, j, temp; i < len - 1; i++) //需要循环次数{j = i;temp = a[i + 1];while (j >= 0 && a[j] > temp){a[j + 1] = a[j];j--;}a[j + 1] = temp;}
}

希尔排序（Shell Sort）

希尔排序，也称 递减增量排序算法，是 插入排序 的一种更高效的改进版本。希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

  1. 插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到 线性排序 的效率；

  2. 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。

步长的选择是希尔排序的重要部分。

只要最终步长为1任何步长序列都可以工作。

算法最开始以一定的步长进行排序。

然后会继续以一定步长进行排序，最终算法以步长为1进行排序。

当步长为1时，算法变为普通插入排序，这就保证了数据一定会被排序。

希尔排序的算法步骤如下：

  1. 定义一个用来分割的步长；

  2. 按步长的长度K，对数组进行K趟排序；

  3. 不断重复上述步骤。

图示如下：

 代码如下：

void shell_Sort(vector<int> &a)
{int len = a.size();for (int gap = len / 2; gap > 0; gap /= 2){for (int i = 0; i < gap; i++){for (int j = i + gap, temp, preIndex; j < len; j = j + gap) //依旧需要temp作为哨兵{temp = a[j];        //保存哨兵preIndex = j - gap; //将要对比的编号while (preIndex >= 0 && a[preIndex]>temp){a[preIndex + gap] = a[preIndex]; //被替换preIndex -= gap;                 //向下走一步}a[preIndex + gap] = temp; //恢复被替换的值}}}
}

快速排序（Quick Sort）

快速排序（Quicksort），又称 划分交换排序（partition-exchange sort） 。

快速排序（Quicksort） 在平均状况下，排序 n 个项目要 O(n log n) 次比较。在最坏状况下则需要 O(n2) 次比较，但这种状况并不常见。事实上，快速排序 O(n log n) 通常明显比其他算法更快，因为它的 内部循环（inner loop） 可以在大部分的架构上很有效率地达成。

快速排序使用 分治法（Divide and conquer） 策略来把一个序列分为较小和较大的2个子序列，然后递归地排序两个子序列。

快速排序的算法步骤如下：

  1. 挑选基准值：从数列中挑出一个元素，称为 “基准”（pivot） ；

  2. 分割：重新排序序列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（与基准值相等的数可以到任何一边）。在这个分割结束之后，对基准值的排序就已经完成；

  3. 递归排序子序列：递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。

递归到最底部的判断条件是序列的大小是零或一，此时该数列显然已经有序。

选取基准值有数种具体方法，此选取方法对排序的时间性能有决定性影响。

图示如下：

代码如下：

int partition(vector<int> &a, int left, int right)
{int pivot = a[right];int i = left - 1;for (int j = left; j < right; j++){if (a[j] <= pivot){i++;swap(a[i], a[j]);}}swap(a[i + 1], a[right]);return i + 1;
}void quickSort(vector<int> &a, int left, int right)
{if (left < right){int mid = partition(a, left, right);quickSort(a, left, mid - 1);quickSort(a, mid + 1, right);}
}void qSort(vector<int> &a)
{quickSort(a, 0, a.size() - 1);
}

归并排序（Merge Sort）

归并排序（Merge sort） ，是创建在归并操作上的一种有效的排序算法，时间复杂度为 O(n log n) 。1945年由约翰·冯·诺伊曼首次提出。该算法是采用 分治法（Divide and Conquer） 的一个非常典型的应用，且各层分治递归可以同时进行。

其实说白了就是将两个已经排序的序列合并成一个序列的操作。

并归排序有两种实现方式

第一种是 自上而下的递归 ，算法步骤如下：

  1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

  2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；

  3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

  4. 重复步骤3直到某一指针到达序列尾；

  5. 将另一序列剩下的所有元素直接复制到合并序列尾。

具体代码：

void mergeSort(vector<int> &a, vector<int> &T, int left, int right)
{if (right - left == 1)return;int mid = left + right >> 1, tmid = left + right >> 1, tleft = left, i = left;mergeSort(a, T, left, mid), mergeSort(a, T, mid, right);while (tleft < mid || tmid < right){if (tmid >= right || (tleft < mid && a[tleft] <= a[tmid])){T[i++] = a[tleft++];}else{T[i++] = a[tmid++];}}for (int i = left; i < right; i++)a[i] = T[i];
}
void mSort(vector<int> &a)
{int len = a.size();vector<int> T(len);mergeSort(a, T, 0, len);
}

迭代比起递归还是安全很多，太深的递归容易导致堆栈溢出。所以建议可以试下迭代实现，acm里是够用了。

堆排序（Heap Sort）

堆排序（Heapsort） 是指利用 二叉堆 这种数据结构所设计的一种排序算法。堆是一个近似 完全二叉树 的结构，并同时满足 堆积的性质 ：即子节点的键值或索引总是小于（或者大于）它的父节点。

二叉堆是什么？

二叉堆分以下两个类型：

1.最大堆：最大堆任何一个父节点的值，都大于等于它左右孩子节点的值。

  • 图示如下：

  • 数组表示如下：

    [10, 8, 9, 7, 5, 4, 6, 3, 2]

2.最小堆：最小堆任何一个父节点的值，都小于等于它左右孩子节点的值。

  • 图示如下：

  • 数组表示如下：

    [1, 3, 2, 6, 5, 7, 8, 9, 10]

堆排序的算法步骤如下：

  1. 把无序数列构建成二叉堆；

  2. 循环删除堆顶元素，替换到二叉堆的末尾，调整堆产生新的堆顶。

代码如下：

void adjustHeap(vector<int> &a, int i,int len)
{int maxIndex = i;//如果有左子树，且左子树大于父节点，则将最大指针指向左子树if (i * 2 + 1 < len && a[i * 2 + 1] > a[maxIndex])maxIndex = i * 2 + 1;//如果有右子树，且右子树大于父节点和左节点，则将最大指针指向右子树if (i * 2 + 2 < len && a[i * 2 + 2] > a[maxIndex])maxIndex = i * 2 + 2;//如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。if (maxIndex != i){swap(a[maxIndex], a[i]);adjustHeap(a, maxIndex,len);}
}void Sort(vector<int> &a)
{int len = a.size();//1.构建一个最大堆for (int i = len / 2 - 1; i >= 0; i--) //从最后一个非叶子节点开始{adjustHeap(a, i,len);}//2.循环将堆首位（最大值）与末位交换，然后在重新调整最大堆for (int i = len - 1; i > 0; i--){swap(a[0], a[i]);adjustHeap(a, 0, i);}
}

我这里用了递归写法，非递归也很简单，就是比较哪个叶子节点大，再继续for下去。

计数排序（Counting Sort）

计数排序（Counting sort） 是一种稳定的线性时间排序算法。该算法于1954年由 Harold H. Seward 提出。计数排序使用一个额外的数组来存储输入的元素，计数排序要求输入的数据必须是有确定范围的整数。

当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 O(n + k) 。计数排序不是比较排序，排序的速度快于任何比较排序算法。

计数排序的算法步骤如下：

  1. 找出待排序的数组中最大和最小的元素；

  2. 统计数组中每个值为 i 的元素出现的次数，存入数组 C 的第 i 项；

  3. 对所有的计数累加（从数组 C 中的第一个元素开始，每一项和前一项相加）；

  4. 反向填充目标数组：将每个元素 i 放在新数组的第 C[i] 项，每放一个元素就将 C[i] 减去1。

代码如下：

void CountingSort(vector<int> &a)
{int len = a.size();if (len == 0)return;int Min = a[0], Max = a[0];for (int i = 1; i < len; i++){Max = max(Max, a[i]);Min = min(Min, a[i]);}int bias = 0 - Min;vector<int> bucket(Max - Min + 1, 0);for (int i = 0; i < len; i++){bucket[a[i] + bias]++;}int index = 0, i = 0;while (index < len){if (bucket[i]){a[index] = i - bias;bucket[i]--;index++;}elsei++;}
}

桶排序（Bucket Sort）

桶排序（Bucket Sort） 跟 计数排序（Counting sort） 一样是一种稳定的线性时间排序算法，不过这次需要的辅助不是计数，而是桶。

工作的原理是将数列分到有限数量的桶里。每个桶再个别排序。当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间 O(n)。

桶排序的算法步骤如下：

  1. 设置一个定量的数组当作空桶子；

  2. 寻访序列，并且把项目一个一个放到对应的桶子去；

  3. 对每个不是空的桶子进行排序；

  4. 从不是空的桶子里把项目再放回原来的序列中。

代码如下：

我觉得递归调用桶排序比较慢，这里直接用了sort函数，其实这个函数能决定这个算法的优劣，这些排序都是针对固定的序列的，可以自己尝试不同的算法去优化

size为1是，其实和计数排序是一样的，不过这里使用了辅助的空间，没有合并相同的，内存消耗要更大。

void bucketSort(vector<int> &a, int bucketSize)
{int len = a.size();if (len < 2)return;int Min = a[0], Max = a[0];for (int i = 1; i < len; i++){Max = max(Max, a[i]);Min = min(Min, a[i]);}int bucketCount = (Max - Min) / bucketSize + 1;//这个区间是max-min+1，但是我们要向上取整，就是+bucketSize-1，和上面的形式是一样的vector<int> bucketArr[bucketCount];for (int i = 0; i < len; i++){bucketArr[(a[i] - Min) / bucketSize].push_back(a[i]);}a.clear();for (int i = 0; i < bucketCount; i++){int tlen = bucketArr[i].size();sort(bucketArr[i].begin(),bucketArr[i].end());for (int j = 0; j < tlen; j++)a.push_back(bucketArr[i][j]);}
}

基数排序（Radix Sort）

基数排序（Radix sort） 是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

工作原理是将所有待比较数值（正整数）统一为同样的数字长度，数字较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。

基数排序的方式可以采用 LSD（Least significant digital） 或 MSD（Most significant digital） 。

LSD 的排序方式由键值的 最右边（最小位） 开始，而 MSD 则相反，由键值的 最左边（最大位） 开始。

MSD 方式适用于位数多的序列，LSD 方式适用于位数少的序列。

基数排序 、 桶排序 、 计数排序 原理都差不多，都借助了 “桶” 的概念，但是使用方式有明显的差异，其差异如下：

  • 基数排序：根据键值的每位数字来分配桶；

  • 桶排序：每个桶存储一定范围的数值；

  • 计数排序：每个桶只存储单一键值。

LSD 图示如下：

LSD 实现如下：

注意不要用负数，用负数完全相反，正负都有可以都转换为正数

void RadixSortSort(vector<int> &a)
{int len = a.size();if (len < 2)return;int Max = a[0];for (int i = 1; i < len; i++){Max = max(Max, a[i]);}int maxDigit = log10(Max) + 1;//直接使用log10函数获取位数，这样的话就不用循环了，这里被强制转换是向下取整int mod = 10, div = 1;vector<int> bucketList[10];for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10){for (int j = 0; j < len; j++){int num = (a[j] % mod) / div;bucketList[num].push_back(a[j]);}int index = 0;for (int j = 0; j < 10; j++){int tlen=bucketList[j].size();for (int k = 0; k < tlen; k++)a[index++] = bucketList[j][k];bucketList[j].clear();}}
}

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

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

相关文章

第十三讲 单片机驱动彩色液晶屏 bin档的烧录方法

第十三讲 单片机驱动彩色液晶屏 bin档的烧录方法

单片机驱动TFT彩色液晶屏系列讲座 目录 第一讲 单片机最小系统STM32F103C6T6通过RA8889驱动彩色液晶屏播放视频 第二讲 单片机最小系统STM32F103C6T6控制RA8889驱动彩色液晶屏硬件框架 第三讲 单片机驱动彩色液晶屏 控制RA8889软件:如何初始化 第四讲 单片机驱动彩色液晶屏 控…
阅读更多...
Java生成四位数随机验证码

Java生成四位数随机验证码

引言&#xff1a; 我们生活中登录的时候都要输入验证码&#xff0c;这些验证码是为了增加注册或者登录难度&#xff0c;减少被人用脚本疯狂登录注册导致的一系列危害&#xff0c;减少数据库的一些压力。 毕竟那些用脚本生成的账号都是垃圾账号 本次实践&#xff1a;生成这样的…
阅读更多...
CMake+QT+大漠插件的桌面应用开发

CMake+QT+大漠插件的桌面应用开发

文章目录 CMakeQT大漠插件的桌面应用开发简介环境项目结构配置编译环境代码 CMakeQT大漠插件的桌面应用开发 简介 在CMake大漠插件的应用开发——处理dm.dll&#xff0c;免注册调用大漠插件中已经说明了如何免注册调用大漠插件&#xff0c;以及做了几个简单的功能调用&#x…
阅读更多...
【STM32】STM32学习笔记-USART串口收发HEX和文本数据包(29)

【STM32】STM32学习笔记-USART串口收发HEX和文本数据包(29)

00. 目录 文章目录 00. 目录01. 串口简介02. 串口收发HEX数据包接线图03. 串口收发HEX数据包示例104. 串口收发HEX数据包示例205. 串口收发文本数据包接线图06. 串口收发文本数据包示例07. 程序示例下载08. 附录 01. 串口简介 串口通讯(Serial Communication)是一种设备间非常…
阅读更多...
科研绘图（五）玫瑰图

科研绘图（五）玫瑰图

柱状图的高级平替可视化 “玫瑰图”&#xff0c;通常也被称为“科克斯图”。它类似于饼图&#xff0c;但不同之处在于每个部分&#xff08;或“花瓣”&#xff09;的角度相同&#xff0c;半径根据它表示的值而变化。这种可视化工具对于周期性地显示信息非常有用&#xff0c;比…
阅读更多...
Spring Boot 中批量执行 SQL 脚本的实践

Spring Boot 中批量执行 SQL 脚本的实践

在Spring Boot应用中&#xff0c;有时候我们需要批量执行存储在数据库中的 SQL 脚本。本文将介绍一个实际的案例&#xff0c;演示如何通过 Spring Boot、MyBatis 和数据库来实现这一目标。 0、数据库层 CREATE TABLE batchUpdate (id INT AUTO_INCREMENT PRIMARY KEY,update_…
阅读更多...
TCP连接TIME_WAIT

TCP连接TIME_WAIT

TCP断开过程: TIME_WAIT的作用: TIME_WAIT状态存在的理由&#xff1a; 1&#xff09;可靠地实现TCP全双工连接的终止 在进行关闭连接四次挥手协议时&#xff0c;最后的ACK是由主动关闭端发出的&#xff0c;如果这个最终的ACK丢失&#xff0c;服务器将重发最终的FIN&#xf…
阅读更多...
CSS3中多列布局详解

CSS3中多列布局详解

多列布局 概念&#xff1a;在CSS3之前&#xff0c;想要设计类似报纸那样的多列布局&#xff0c;有两种方式可以实现&#xff1a;一种是"浮动布局"&#xff0c;另一种是“定位布局”。 这两种方式都有缺点&#xff1a;浮动布局比较灵活&#xff0c;但不容易控制&…
阅读更多...
用Python“自动连发消息”

用Python“自动连发消息”

自动连发消息&#xff0c;基本上C和Python的思路都是不停的模拟“击键”操作&#xff0c;还有一种VB的脚本写法&#xff0c;反成每种语言都能写&#xff0c;更厉害的可以用java做出个GUI界面&#xff0c;先上代码。 一 代码 import pyautogui # 鼠标 import p…
阅读更多...
C++力扣题目101--对称二叉树

C++力扣题目101--对称二叉树

101. 对称二叉树 力扣题目链接(opens new window) 给定一个二叉树&#xff0c;检查它是否是镜像对称的。 思路 首先想清楚&#xff0c;判断对称二叉树要比较的是哪两个节点&#xff0c;要比较的可不是左右节点&#xff01; 对于二叉树是否对称&#xff0c;要比较的是根节点…
阅读更多...
Linux命令之用户账户管理whoami,useradd,passwd,chage,usermod,userdel的使用

Linux命令之用户账户管理whoami,useradd,passwd,chage,usermod,userdel的使用

1、查看当前用户账户 2、切换用户为root用户 3、新建用户user1&#xff0c;给用户user1设置密码为password123 4、新建用户user2&#xff0c;UID为510&#xff0c;指定其所属的私有组为group1&#xff08;group1组的标识符为500&#xff09;&#xff0c;用户的主目录为/home/us…
阅读更多...
codesys【程序】

codesys【程序】

FB&#xff1a; 用于实现 PLC【叠】PLC FB功能块&#xff1a; 包含 输入&#xff0c;输出&#xff0c;局部变量&#xff0c;静态变量 用ST语言&#xff0c;方便复制。FUNCTION_BLOCK FB_CAN轴 VAR_INPUT 输入 END_VAR VAR_OUTPUT 输出 END_VAR VAR …
阅读更多...
【MATLAB源码-第110期】基于matlab的哈里斯鹰优化算发(HHO)无人机三维路径规划，输出做短路径图和适应度曲线。

【MATLAB源码-第110期】基于matlab的哈里斯鹰优化算发(HHO)无人机三维路径规划，输出做短路径图和适应度曲线。

操作环境&#xff1a; MATLAB 2022a 1、算法描述 哈里斯鹰优化算法&#xff08;Harris Hawk Optimization, HHO&#xff09;是一种受自然界捕食行为启发的优化算法。它基于哈里斯鹰的捕猎策略和行为模式&#xff0c;主要用于解决各种复杂的优化问题。这个算法的核心特征在于…
阅读更多...
vue3-列表渲染

vue3-列表渲染

v-for 我们可以使用 v-for 指令基于一个数组来渲染一个列表。 v-for 指令的值需要使用 (item in items) 形式的特殊语法&#xff0c;其中 items 是源数据的数组&#xff0c;而 item 是迭代项的别名&#xff0c; (item, index) in items index 表示当前项的位置索引(可选参数)…
阅读更多...
深度学习-标注文件处理（txt批量转换为json文件）

深度学习-标注文件处理（txt批量转换为json文件）

接上篇&#xff0c;根据脚本可将coco128的128张图片&#xff0c;按照比例划分成训练集、测试集、验证集&#xff0c;同时生成相应的标注的labels文件夹&#xff0c;最近再看实例分离比较火的mask rcnn模型&#xff0c;准备进行调试但由于实验室算力不足&#xff0c;网上自己租的…
阅读更多...
JVM知识总结（持续更新）

JVM知识总结（持续更新）

这里写目录标题 java内存区域程序计数器虚拟机栈本地方法栈堆方法区运行时常量池 对象的创建 java内存区域 Java 虚拟机在执行 Java 程序的过程中会把它管理的内存划分成若干个不同的数据区域&#xff1a; 程序计数器虚拟机栈本地方法栈堆方法区 程序计数器 记录下一条需要…
阅读更多...
【ArcGIS遇上Python】ArcGIS Python批量筛选多个shp中指定字段值的图斑（以土地利用数据为例）

【ArcGIS遇上Python】ArcGIS Python批量筛选多个shp中指定字段值的图斑（以土地利用数据为例）

文章目录 一、案例分析二、提取效果二、代码运行效果三、Python代码四、数据及代码下载一、案例分析 以土地利用数据为例，提取多个shp数据中的旱地。 二、提取效果 原始土地利用数据： 属性表： 提取的旱地：（以图层名称+地类名称命名）
阅读更多...
基于python舆情分析可视化系统+情感分析+爬虫+机器学习（源码）✅

基于python舆情分析可视化系统+情感分析+爬虫+机器学习（源码）✅

大数据毕业设计&#xff1a;Python招聘数据采集分析可视化系统✅ 毕业设计&#xff1a;2023-2024年计算机专业毕业设计选题汇总&#xff08;建议收藏&#xff09; 毕业设计&#xff1a;2023-2024年最新最全计算机专业毕设选题推荐汇总 &#x1f345;感兴趣的可以先收藏起来&…
阅读更多...
Python 自学(八) 之模块

Python 自学(八) 之模块

目录 1. import语句导入模块 P206 2. from ... import 语句导入模块 P207 3. 模块的搜索目录 sys.path P209 4. 以主程序的形式执行 __name__ P212 5. python中的包 P213 1. import语句导入模块 P206 同一目录下&…
阅读更多...
响应式Web开发项目教程（HTML5+CSS3+Bootstrap）第2版 第1章 HTML5+CSS3初体验 项目1-1 三栏布局页面

响应式Web开发项目教程（HTML5+CSS3+Bootstrap）第2版 第1章 HTML5+CSS3初体验 项目1-1 三栏布局页面

项目展示 三栏布局是一种常用的网页布局结构。 除了头部区域、底部区域外&#xff0c;中间的区域&#xff08;主体区域&#xff09;划分成了三个栏目&#xff0c;分别是左侧边栏、内容区域和右侧边栏&#xff0c;这三个栏目就构成了三栏布局。当浏览器的宽度发声变化时&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023