1. 冒泡排序（Bubble Sort）
两个数比较大小，通过两两交换，像水中的泡泡一样，较大的数下沉，较小的数冒起来。
算法描述：
1.比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3.针对所有的元素重复以上的步骤，除了最后一个；
4.重复步骤1~3，直到排序完成。
动画演示图：
oc代码：
- (NSArray*)bubbleSort:(NSArray*)temArr{
NSMutableArray *arr = [NSMutableArray arrayWithArray: temArr];
NSInteger count = arr.count;
for (int i = 0; i < count; i++) { // 循环次数
for (int j = 0; j < count - 1 - i; j++) { //比较次数
if ([arr[j] intValue] > [arr[j+1] intValue]) {
NSNumber *temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr;
}
swift代码：
func bubbleSort(temArr: [Int] ) -> [Int] {
if temArr.count == 0 {
return []
}
var arr = temArray
let count = arr.count
for i in 0..<count { // 循环次数
for j in 0..<count - 1 - i { // 比较次数
if (arr[j] > arr[j + 1] ) {
let temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
return arr
}
2.快速排序
1.从数列中挑出一个元素作为基准。
2. 重新排列数列，把所有的比基准小的放在基准前面，反之放在后面（一样大可任意一边）完成后基准处在分区的中间位置。
3. 通过递归调用把小于基准元素和大雨基准元素的子序列进行排序
算法过程图：
oc代码：
//数据数组
NSArray *temArr = @[@30,@40, @60, @10, @20, @50];
NSMutableArray *arr = [NSMutableArray arrayWithArray:temArr];
[self quickSort:arr low:0 hight: arr.count - 1];
NSLog(@"%@",arr);
- (void)quickSort:(NSMutableArray*)temArr low: (NSInteger)low hight: (NSInteger)hight{
if (low >= hight) {
return;
}
NSInteger i = low;
NSInteger j = hight;
id key = temArr[i]; // 参考基数
while (i < j) {
while (i < j && [temArr[j] intValue] >= [key intValue]) { // 右边j位大于基数位置不变
j--;
}
if (i == j) { // i、j位置重合结束本次循环，当key是目前最小的数时，会出现i=j的情况，
break;
}
temArr[i] = temArr[j]; //右边j位小于基数位置和i位交换
while (i < j && [temArr[i] intValue] <= [key intValue]) {
i++;
}
if (i == j) { // 当key是目前最大的数时(m[j]的前面)，会出现i=j的情况
break;
}
temArr[j] = temArr[i];
}
temArr[i] = key; // i和j重合时本轮循环结束，将key放入i的位置（则左侧数都比key小，右侧数都比key大）
// key 的左右分别进行快速排序
[self quickSort:temArr low:low hight:i - 1]; // 左递归
[self quickSort:temArr low:i + 1 hight:hight]; // 右递归
}
swift代码：
var array = [30,40,60,10,20,50]
quickSort(arr: &array, low: 0, hight: array.count - 1 )
print(array)
func quickSort(arr: inout [Int], low: Int, hight: Int ) {
if low >= hight { // 递归结束条件
return
}
var i = low;
var j = hight;
let key = arr[i] // 基数
while i < j {
// 从右边开始比较，比key大的数位置不变
while i < j && arr[j] >= key {
j -= 1
}
// 只要出现一个比key小的数，将这个数放入左边i的位置
arr[i] = arr[j]
// 从左边开始比较，比key小的数位置不变
while i < j && arr[i] <= key {
i += 1
}
// 只要出现一个比key大的数，将这个数放入右边j的位置
arr[j] = arr[i]
}
arr[i] = key // i和j重合时本轮循环结束，将key放入i的位置（则左侧数都比key小，右侧数都比key大）
// key 的左右分别进行快速排序
quickSort(arr: &arr, low: low, hight: i - 1) // 左递归
quickSort(arr: &arr, low: i + 1, hight: hight) // 右递归
}
3.插入排序（Insertion Sort）
1.从第一个元素开始，该元素可以认为已经被排序；
2.取出下一个元素，在已经排序的元素序列中从后向前扫描；
3.如果该元素（已排序）大于新元素，将该元素移到下一位置；
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5.将新元素插入到该位置后；
6.重复步骤2~5。
动画演示图：
OC代码：
- (NSArray*)insertionSort:(NSArray*)temArr{
NSMutableArray *arr = [NSMutableArray arrayWithArray: temArr];
NSInteger count = arr.count;
for (int i = 0; i < count; i++) { // 循环次数
// 从已排序的部分中查找 arr[i] 合适的位置插入
for (int j = i; j > 0; j--) { // 内循环
if ([arr[j-1] intValue] > [arr[j] intValue]) {
NSNumber *temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
} else {
// 因前面是已排序的，故当不满足比较条件即可结束内循环(肯定比前面的值更大)
break;
}
}
}
return arr;
}
swift 代码：
func insertSort(temArr: [Int] ) -> [Int] {
if temArr.count == 0 {
return []
}
var arr = temArray
let count = arr.count
for i in 0..<count { // 交换次数
// 从已排序的部分中查找 arr[i] 合适的位置插入
var j = I
while (j > 0) {
if (arr[j-1] > arr[j] ) {
let temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
} else {
// 因前面是已排序的，故只要不满足比较条件即可结束内循环，如肯定比前面的值更大
break;
}
j-=1;
}
}
return arr
}
4.希尔排序（Shell Sort）
希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素
算法描述：
1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
2. 按增量序列个数k，对序列进行k 趟排序；
3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
动画演示图：
OC代码:
- (NSArray*)shellSort:(NSArray*)temArr{
NSMutableArray *arr = [NSMutableArray arrayWithArray: temArr];
NSInteger count = arr.count; NSInteger gap = count / 2; //间隔系数
while(gap > 0) { // if的作用
for (NSInteger i = gap; i < count; i++) { // 遍数--分组
NSNumber *temp = arr[i];
NSInteger preIndex = i - gap;
while (preIndex >= 0 && [arr[preIndex] intValue] > [temp intValue]) { // 判断位置交换
arr[preIndex + gap] = arr[preIndex];
preIndex -= gap;
}
arr[preIndex + gap] = temp;
}
gap /= 2;
}
return arr;
}
swift代码：
func shellSort(temArr: [Int] ) -> [Int] {
if temArr.count == 0 {
return []
}
var arr = temArray
let count = arr.count
var gap = count / 2 //间隔系数
while gap > 0 { // if的作用
for i in gap..<count { // 遍数--分组
let temp = arr[i]
var preIndex = i - gap
while preIndex >= 0 && arr[preIndex] > temp { // 判断位置交换
arr[preIndex + gap] = arr[preIndex]
preIndex -= gap
}
arr[preIndex + gap] = temp
}
gap /= 2
}
return arr
}
5. 选择排序（Select Sort）
选择排序是直观的排序，从头依次找出最大(或最小值)，和排序元素换位。未排序元素继续重复排序操作。直到排序完毕。 双重循环时间复杂度为 O(n^2)
动画演示图：
算法过程图：
OC代码：
//数据数组
NSArray *arr = @[@3,@44, @38, @5, @47, @15, @36, @26, @27, @2, @46, @4, @19, @50, @48];
// 方法调用
NSArray *sortArray = [self selectSort:arr];
NSLog(@"%@",sortArray);
// 选择排序代码
- (NSArray *)selectSort:(NSArray*)temArr{
NSMutableArray *arr = [NSMutableArray arrayWithArray: temArr];
NSInteger count = arr.count;
for (int i = 0; i < count; i++) { // 交换次数
// 先假设每次循环时，最小数的索引为i
int minIndex = i; // 每一个元素都和剩下的未排序的元素比较
for (int j = i + 1; j < count; j++) {
if ([arr[minIndex] intValue] > [arr[j] intValue]) { //寻找最小数
minIndex = j; //将最小数的索引保存
}
}
//经过一轮循环，就可以找出第一个最小值的索引，然后把最小值放到i的位置
NSNumber *temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
return arr;
}
swift 代码：
// 待排序数组
var temArray = [3,44,38,5,47,15,36,26,27,2,46,4,19,50,48]
// 调用方法
let sortArray = selectSort(temArr: temArray)
// 定义选择排序方法
func selectSort2(temArr: [Int] ) -> [Int] {
if temArr.count == 0 {
return []
}
var arr = temArray
let count = arr.count
for i in 0..<count {
// 交换次数
// 先假设每次循环时，最小数的索引为i
var minIndex = i // 每一个元素都和剩下的未排序的元素比较
for j in i+1..<count {
if arr[minIndex] > arr[j] { //寻找最小数
minIndex = j //将最小数的索引保存
}
}
//经过一轮循环，就可以找出第一个最小值的索引，然后把最小值放到i的位置
let temp = arr[i]
arr[i] = arr[minIndex]
arr[minIndex] = temp
}
return arr
}
6.堆排序
思路分析：
堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆
大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]
堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了
动图展示：
OC代码：
- (void)heapSort:(NSMutableArray*)arr{
//1.构建大顶堆
for (NSInteger i = arr.count/2 -1 ; i >= 0; i--) {
//从第一个非叶子结点从下至上，从右至左调整结构
[self adjustHeap:arr i:i length:arr.count];
}
//2.调整堆结构+交换堆顶元素与末尾元素
for (NSInteger j = arr.count - 1; j > 0; j--) {
//将堆顶元素与末尾元素进行交换
NSNumber *temp = arr[0];
arr[0] = arr[j];
arr[j] = temp;
//重新对堆进行调整
[self adjustHeap:arr i:0 length:j];
}
}
/** 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上） */
- (void)adjustHeap:(NSMutableArray*)arr i: (NSInteger)i length: (NSInteger)length{
NSNumber *temp = arr[i];
for (NSInteger k = i*2+1; k < length; k = k*2+1) {
//如果右孩子大于做孩子，则指向右孩子
if (k+1 < length && [arr[k] intValue]< [arr[k + 1] intValue]) {
k++;
}
//如果最大的孩子大于当前节点，则将大孩子赋给当前节点，修改当前节点为其大孩子节点，再向下走。
if ([arr[k] intValue] > [temp intValue]) {
arr[i] = arr[k];
i = k;
} else {
break;
}
}
//将temp放到最终位置
arr[i] = temp;
}
目录一.加解密算法数字签名对称加密DES(DataEncryptionStandard)3DES(TripleDES)AES(AdvancedEncryptionStandard)RSA加密法DSA(DigitalSignatureAlgorithm)ECC(EllipticCurvesCryptography)非对称加密签名与加密过程非对称加密的应用对称加密与非对称加密的结合二.数字证书图解一.加解密算法加密简单而言就是通过一种算法将明文信息转换成密文信息，信息的的接收方能够通过密钥对密文信息进行解密获得明文信息的过程。根据加解密的密钥是否相同，算法可以分为对称加密、非对称加密、对称加密和非
嗨~大家好，这里是可莉！今天给大家带来的是7个C语言的经典基础代码~那一起往下看下去把【程序一】打印100到200之间的素数#includeintmain(){ inti; for(i=100;i 【程序二】输出乘法口诀表#includeintmain(){inti;for(i=1;i 【程序三】判断1000年---2000年之间的闰年#includeintmain(){intyear;for(year=1000;year 【程序四】给定两个整形变量的值，将两个值的内容进行交换。这里提供两种方法来进行交换，第一种为创建临时变量来进行交换，第二种是不创建临时变量而直接进行交换。1.创建临时变量来
目录第1题连续问题分析：解法：第2题分组问题分析：解法：第3题间隔连续问题分析：解法：第4题打折日期交叉问题分析：解法：第5题同时在线问题分析：解法：第1题连续问题如下数据为蚂蚁森林中用户领取的减少碳排放量iddtlowcarbon10012021-12-1212310022021-12-124510012021-12-134310012021-12-134510012021-12-132310022021-12-144510012021-12-1423010022021-12-154510012021-12-1523.......找出连续3天及以上减少碳排放量在100以上的用户分析：遇到这类
深度学习12.CNN经典网络VGG16一、简介1.VGG来源2.VGG分类3.不同模型的参数数量4.3x3卷积核的好处5.关于学习率调度6.批归一化二、VGG16层分析1.层划分2.参数展开过程图解3.参数传递示例4.VGG16各层参数数量三、代码分析1.VGG16模型定义2.训练3.测试一、简介1.VGG来源VGG（VisualGeometryGroup）是一个视觉几何组在2014年提出的深度卷积神经网络架构。VGG在2014年ImageNet图像分类竞赛亚军，定位竞赛冠军；VGG网络采用连续的小卷积核（3x3）和池化层构建深度神经网络，网络深度可以达到16层或19层，其中VGG16和VGG
1．问题描述使用Python的turtle（海龟绘图）模块提供的函数绘制直线。2．问题分析一幅复杂的图形通常都可以由点、直线、三角形、矩形、平行四边形、圆、椭圆和圆弧等基本图形组成。其中的三角形、矩形、平行四边形又可以由直线组成，而直线又是由两个点确定的。我们使用Python的turtle模块所提供的函数来绘制直线。在使用之前我们先介绍一下turtle模块的相关知识点。turtle模块提供面向对象和面向过程两种形式的海龟绘图基本组件。面向对象的接口类如下：1）TurtleScreen类：定义图形窗口作为绘图海龟的运动场。它的构造器需要一个tkinter.Canvas或ScrolledCanva
我一直在尝试用Ruby实现Luhn算法。我一直在执行以下步骤:该公式根据其包含的校验位验证数字，该校验位通常附加到部分帐号以生成完整帐号。此帐号必须通过以下测试:从最右边的校验位开始向左移动，每第二个数字的值加倍。将乘积的数字(例如，10=1+0=1、14=1+4=5)与原始数字的未加倍数字相加。如果总模10等于0(如果总和以零结尾)，则根据Luhn公式该数字有效；否则无效。http://en.wikipedia.org/wiki/Luhn_algorithm这是我想出的:defvalidCreditCard(cardNumber)sum=0nums=cardNumber.to_s.s
下面是我写的一个计算斐波那契数列中的值的方法:deffib(n)ifn==0return0endifn==1return1endifn>=2returnfib(n-1)+(fib(n-2))endend它工作到n=14，但在那之后我收到一条消息说程序响应时间太长(我正在使用repl.it)。有人知道为什么会这样吗？ 最佳答案 Naivefibonacci进行了大量的重复计算-在fib(14)fib(4)中计算了很多次。您可以将内存添加到您的算法中以使其更快:deffib(n,memo={})ifn==0||n==1returnnen
为了防止在迁移到生产站点期间出现数据库事务错误，我们遵循了https://github.com/LendingHome/zero_downtime_migrations中列出的建议。(具体由https://robots.thoughtbot.com/how-to-create-postgres-indexes-concurrently-in概述)，但在特别大的表上创建索引期间，即使是索引创建的“并发”方法也会锁定表并导致该表上的任何ActiveRecord创建或更新导致各自的事务失败有PG::InFailedSqlTransaction异常。下面是我们运行Rails4.2(使用Acti
我正在开发一个类似微论坛的项目，其中一个特殊用户发布一条快速(接近推文大小)的主题消息，订阅者可以用他们自己的类似大小的消息来响应。直截了当，没有任何形式的“挖掘”或投票，只是每个主题消息的响应按时间顺序排列。但预计会有很高的流量。我们想根据它们引起的响应嗡嗡声来标记主题消息，使用0到10的等级。在谷歌上搜索了一段时间的趋势算法和开源社区应用示例，到目前为止已经收集到两个有趣的引用资料，但我还没有完全理解它们:Understandingalgorithmsformeasuringtrends，关于使用基线趋势算法比较维基百科页面浏览量的讨论，在SO上。TheBritneySpearsP
我收到错误:unsupportedcipheralgorithm(AES-256-GCM)(RuntimeError)但我似乎具备所有要求:ruby版本:$ruby--versionruby2.1.2p95OpenSSL会列出gcm:$opensslenc-help2>&1|grepgcm-aes-128-ecb-aes-128-gcm-aes-128-ofb-aes-192-ecb-aes-192-gcm-aes-192-ofb-aes-256-ecb-aes-256-gcm-aes-256-ofbRuby解释器:$irb2.1.2:001>require'openssl';puts
