关键词：
13:50:24 2019-09-14
继续把未看完的看完
排序算法
定理:任意$N$个不同元素组成的序列平均具有$N(N-1)/4$个逆序对
定理:任何仅以交换相邻两元素来排序的算法，其平均时间复杂度为$Ω(N^2)$
这样子 冒泡排序 插入排序 的最坏情况都是 N^2
要使排序算法变高效 得使用间隔元素来交换 在一次排序中 交换多个逆序对的元素
希尔排序
定义增量序列$D_M>D_{M-1}>...>D_1=1$
$对每个D_k进行“D_k-间隔”排序（k=M,M-1,...1)$
$注意：“D_k-间隔"有序的序列，在执行”D_{k-1}间隔“排序后，仍然是“D_k-间隔"有序的$
如果增量元素不互质，则小增量可能根本不起作用
比如 $N=N/2$ 最坏情况 时候 $T= heta(N^{2})$
那么就会有其他的增量序列:
Hibbard增量序列 $D_k=2^k-1$ --相邻元素互质 最坏情况$T= heta(N^{3/2})$
猜想 Hibbard增量的 平均复杂度 $T_{avg}=O(N^{5/4})$
Sedgewick增量序列 $ {1,5,19,41,109,.....}$
$9*4^i-9*2^i或4^i-3*2^i+1$猜想$T_{avg}=O(N^{7/6}) T_{worst}=O(N^{4/3})$
冒泡排序 插入排序 希尔排序 选择排序 堆排序 归并排序(ps:其中堆排序写的是憨憨版本 之后会添上精明版本)
1 #define _CRT_SECURE_NO_WARNINGS 2 #include<stdio.h> 3 #include<malloc.h> 4 void Print(int A[], int N) 5 { 6 for (int i = 0; i < N; i++) 7 printf("%d ", A[i]); 8 printf(" "); 9 } 10 //排序算法 11 12 //冒泡排序 //最好 O(N) 最坏 O(N^2) 算法稳定 13 void Swap(int A[], int i, int j) 14 { 15 int temp = A[i]; 16 A[i] = A[j]; 17 A[j] = temp; 18 } 19 void Bubble_Sort(int A[], int N) 20 { 21 for (int i = 0; i < N; i++) 22 { 23 int IsSwap = 0; 24 for (int j = 0; j < N - i-1; j++) 25 { 26 if (A[j] > A[j + 1]) 27 { 28 IsSwap = 1; 29 Swap(A, j, j + 1); 30 } 31 } 32 if (!IsSwap) 33 break; 34 } 35 } 36 37 //插入排序 //最好O(N) 最坏 O(N^2) 算法稳定 38 void Insert(int A[], int j, int i) 39 { 40 int temp = A[i]; 41 for (; i > j; i--) 42 A[i] = A[i - 1]; 43 A[j] = temp; 44 } 45 void Insert_Sort(int A[], int N) 46 { 47 /*for (int i = 0; i < N-1; i++) 48 { 49 int m = i + 1; 50 int j = i; 51 while (j >= 0 && A[j] > A[m]) 52 j--; 53 Insert(A, j+1, m); 54 }*/ 55 /*for (int i = 1; i < N; i++) 56 { 57 int temp = A[i]; 58 int j; 59 for (j = i - 1; j >= 0 && A[j] > temp; j--) 60 A[j + 1] = A[j]; 61 A[j + 1] = temp; 62 }*/ 63 for (int p = 1; p < N; p++) 64 { 65 int temp = A[p]; 66 int i; 67 for (i = p; i > 0 && A[i - 1] > temp; i--) 68 A[i] = A[i - 1]; 69 A[i] = temp; 70 } 71 } 72 73 //希尔排序 //最坏情况 //改进插入排序 74 void Shell_Sort(int A[], int N) 75 { 76 /*for (int D = N / 2; D > 0; D /= 2) 77 { 78 for (int p = D; p < N; p++) 79 { 80 int temp = A[p]; 81 int i; 82 for (i = p; i >= D && A[i - D] > temp; i -= D) 83 A[i] = A[i - D]; 84 A[i] = temp; 85 } 86 }*/ 87 // 利用Sedgewick增量序列 88 int Si; 89 int Sedgewick[] = { 929,505,209,109,41,19,5,1,0 }; 90 for (Si = 0; Sedgewick[Si] >=N; Si++) //初始的增量Sedgewick[Si]不能超过待排序序列长度 91 ; 92 for (int D = Sedgewick[Si]; D>0;D=Sedgewick[++Si]) 93 { 94 for (int p = D; p < N; p++) 95 { 96 int temp = A[p]; 97 int i; 98 for (i = p; i >= D && A[i - D] > temp; i -= D) 99 A[i] = A[i - D]; 100 A[i] = temp; 101 } 102 } 103 } 104 105 //选择排序 106 void Selection_Sort(int A[], int N) 107 { 108 for (int i = 0; i < N; i++) 109 { 110 int MinPosition = i; 111 int Min = A[i]; 112 int j; 113 for (j = i + 1; j < N; j++) 114 { 115 if (A[j] < Min) 116 { 117 MinPosition = j; 118 Min = A[j]; 119 } 120 } 121 Swap(A, i, MinPosition); 122 } 123 } 124 125 //堆排序 //选择排序的一种改进 126 //改进了寻找最小元的算法 利用最小堆来实现 127 typedef struct HeapStruct* MinHeap; 128 struct HeapStruct 129 { 130 int* Elements; 131 int Size; 132 int Capacity; 133 }; 134 MinHeap Create(int MaxSize) 135 { 136 MinHeap H = (MinHeap)malloc(sizeof(struct HeapStruct)); 137 H->Elements = (int*)malloc(sizeof(int) * (MaxSize + 1)); 138 H->Capacity = MaxSize; 139 H->Size = 0; 140 H->Elements[0] = -10001; 141 return H; 142 } 143 MinHeap H = Create(20); 144 //建立最小堆 145 void PrecDown(MinHeap H, int i) //下滤 146 { 147 int Parent, Child; 148 int Tmp = H->Elements[i]; 149 for (Parent = i; Parent * 2 <= H->Size; Parent = Child) 150 { 151 Child = Parent * 2; 152 if ((Child != H->Size) && (H->Elements[Child] > H->Elements[Child + 1])) 153 Child++; 154 if (Tmp <= H->Elements[Child])break; 155 else 156 H->Elements[Parent] = H->Elements[Child]; 157 } 158 H->Elements[Parent] = Tmp; 159 } 160 void BuildMinHeap(MinHeap H) 161 { 162 int i; 163 for (i = H->Size / 2; i > 0; i--) 164 PrecDown(H, i); 165 } 166 int DeleteMin(MinHeap H) 167 { 168 int Parent, Child; 169 int MinItem, temp; 170 MinItem = H->Elements[1]; 171 temp = H->Elements[H->Size--]; 172 for (Parent = 1; Parent * 2 <= H->Size; Parent = Child) 173 { 174 Child = Parent * 2; 175 if (Child != H->Size && H->Elements[Child] > H->Elements[Child + 1]) 176 Child++; 177 if (H->Elements[Child] >= temp)break; 178 else 179 H->Elements[Parent] = H->Elements[Child]; 180 } 181 H->Elements[Parent] = temp; 182 return MinItem; 183 } 184 void Heap_Sort(int A[], int N) 185 { 186 //算法一 利用最小堆 187 /*int Tmp[10] = { 0 }; 188 for (int i = 0; i < 10; i++) 189 Tmp[i] = DeleteMin(H); 190 for (int i = 0; i < 10; i++) 191 A[i] = Tmp[i];*/ 192 /*for (int i = 0; i < 10; i++) 193 A[i] = DeleteMin(H);*/ 194 195 //算法二 利用最大堆后 再调整 196 } 197 198 //归并排序 199 void Merge(int A[],int lo,int mi,int hi) 200 { 201 //两个有序序列的合并 202 int* B = (int*)malloc(sizeof(int) * (mi - lo)); 203 for (int i = 0; i < mi - lo;)B[i++] = A[lo + i]; 204 int i, j, k; 205 i = lo; 206 j = 0; 207 k = mi; 208 /*while (j<mi-lo||k<hi) 209 { 210 if((j<mi-lo)&&(k>=hi||B[j]<=A[k]))A[i++]=B[j++]; 211 if ((k < hi) && (j >= mi-lo|| B[j] > A[k]))A[i++] = A[k++]; 212 }*/ 213 //化简版 214 while (j<mi-lo) 215 { 216 if (k >= hi || B[j] <= A[k])A[i++] = B[j++]; 217 if (k<hi && B[j]>A[k])A[i++] = A[k++]; 218 } 219 /*邓公版本*/ 220 /*int* A1= A + lo; 221 int* B = (int*)malloc(sizeof(int) * (mi - lo)); 222 for (int i = 0; i < mi - lo; B[i] = A1[i++]); 223 int* C = A + mi; 224 int i, j, k;*/ 225 /*for (i = j = k = 0; j < mi - lo || k < hi-mi;) 226 { 227 if (j < mi - lo&&((k >= hi - mi)||B[j] <=C[k]))A1[i++] = B[j++]; 228 if (k < hi - mi && (j >= mi - lo || B[j] > C[k]))A1[i++] = C[k++]; 229 }*/ 230 //简化 231 /*for (i = j = k = 0; j < mi - lo;) 232 { 233 if (k >= hi - mi || B[j] <= C[k])A1[i++] = B[j++]; 234 if (k < hi - mi && (j >= mi - lo || B[j] > C[k]))A1[i++] = C[k++]; 235 }*/ 236 } 237 void MergeSort(int A[],int lo,int hi) 238 { 239 if (lo == hi - 1) 240 return; 241 int mi = (lo + hi) >> 1; 242 MergeSort(A,lo, mi); 243 MergeSort(A, mi, hi); 244 Merge(A,lo, mi, hi); 245 } 246 int main() 247 { 248 int A[10]; 249 for (int i = 0; i < 10; i++) 250 scanf("%d", &A[i]); 251 //Bubble_Sort(A, 10); 252 //Insert_Sort(A, 10); 253 //Shell_Sort(A, 10); 254 //Selection_Sort(A, 10); 255 //堆排序 256 /*for (int i = 1; i <= 10; i++) 257 H->Elements[++H->Size] = A[i - 1]; 258 BuildMinHeap(H); //构建最小堆 259 Heap_Sort(A, 10);*/ 260 MergeSort(A,0,10); 261 Print(A, 10); 262 return 0; 263 }
mysql基础第二十三天,更新和删除数据(代码片段)
更新数据updatecustmerssetcust_city=replace(cust_city,'市','city')wherecust_id>1000;updatecustomersetcust_adderess='新福路12号',cust_city='厦门市'wherecust_id=1;u 查看详情
第二十三天
迭代器模式和观察值模式"""行为模式：是对不同的对象之间划分责任和算法的抽象方式。重点在于类和类之间相互作用。#迭代器模式#观察者模式"""1.迭代器模式#Iterable:iter方法:returnIterator#Iterator：nextiter方法#用于访问集合对象的... 查看详情
团队冲刺第二十三天(代码片段)
今天主要是做了一下获取地方的相关的天气方面的东西。主要的运行截图如下： 主要的代码如下：packagecom.weather;importandroid.Manifest;importandroid.app.ProgressDialog;importandroid.content.Context;importandroid.content.Intent 查看详情
华为实习日记——第二十三天
最近几天的天气比较凉爽，早晨走在路上吹着清凉清凉的风，感觉很舒服。 上午没任务，就把cinder-volume的创建卷的过程过了一遍，记了下笔记。 下午的时候很无聊，师父要开一天会，没人给我任务。就一边刷刷知... 查看详情
python之第二十三天的努力--函数总结(代码片段)
01函数总结#仅限关键字参数#deffunc(a,b,*args,c):#print(a,b)#print(c)##func(1,2,3,4,c=666)#*#a,b=(1,2)#a,b,*c=(1,2,3,4,5,6)#print(a,b,c)#12[3,4,5,6]#a,*b,c=[11,22,33,44,55,66,77]#print(a,b,c)#11[22,33,44,55,66]77# 查看详情
java基础第二十三天——解析xml文件和dtd约束(代码片段)
反射注意点：当我们利用反射获取src下的.properties文件时，我们利用IO流获取文件的路径时可以这样写：InputStreamstream=Demo1.class.getClassLoader().getResourceAsStream("person.properties");开发中，要把所有配置文件写入sr 查看详情
学java第二十三天，list类型和set类型(代码片段)
数组，是我们最常用的，但是有时候，我们要用数组，但是又不知道数组的类的长度的时候，我们java就有一个很好用的工具Collection，这都是java的爸爸的用心良苦，Collection中包含List和Set和Map，但是今天老师讲了List和Set。List是... 查看详情
爱创课堂每日一题第二十三天-expires和cache-control？
Expires要求客户端和服务端的时钟严格同步。HTTP1.1引入Cache-Control来克服Expires头的限制。如果max-age和Expires同时出现，则max-age有更高的优先级。 Cache-Control:no-cache,private,max-age=0 ETag:abcde &nb 查看详情
第二十三天泛型(代码片段)
1.概述泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。什么是泛型？为什么要使用泛型？泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传... 查看详情
学习笔记第二十三节课
管道符和作业控制管道符表示把一个文件的输出的内容，传递给后面的命令。比如wc-l的用法可以统计ls下有多少个目录文件。还有之前用的find命令。可以列出当前目录下所有文件，也可以用管道符。以后会经常用管道符。ctrl+z... 查看详情
每日算法&面试题，大厂特训二十八天——第二十三天（树）(代码片段)
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法... 查看详情
学习第十三天（2019-11-26）(代码片段)
第二十二章高级技巧一、高级函数1、安全的类型检测由于typeof会出现无法预知的行为，instanceof在多个全局作用域中并不能正确工作，所以调用Object原生的toString方法，会返回[ObjectNativeConstructorName]格式字符串。每个类内部都有一... 查看详情
批处理学习笔记第二十三课：用户变量和变量引用
用户变量 编写批处理程序时，用户根据需要自己定义的变量称之为用户变量。用户变量类似于C语言里面的变量，仅仅在定义该变量的程序中有效。 用户变量由set命令定义，这是批处理中非常非常重要... 查看详情
oldboy第十三天学习
1、现在给我的感觉是，python终于入门了开始越学越简单了。变得更好理解了。一、memcachedMemcached是一个高性能的分布式内存对象缓存系统，用于动态Web应用以减轻数据库负载。它通过在内存中缓存数据和对象来减少读取数据库... 查看详情
第二十三篇densenet——论文翻译
文章目录摘要1引言2相关工作3DenseNets4实验4.1数据集4.2训练4.3CIFAR和SVHN的分类结果4.4.ImageNet上的分类结果5讨论 查看详情
10.27开课一个月零二十三天（设计模式）
<?php//面向对象的三大特性//封装：//目的：为了让类更安全//做法：将成员变量变为私有，做一个方法来间接操作成员变量，在方法里面加限制条件//继承：//子类可以继承父类的一切//特点：单继承，一个子类只能有一个父类//... 查看详情
hadoop学习之路（二十三）mapreduce中的shuffle详解
概述1、MapReduce中，mapper阶段处理的数据如何传递给reducer阶段，是MapReduce框架中最关键的一个流程，这个流程就叫Shuffle2、Shuffle:数据混洗——（核心机制：数据分区，排序，局部聚合，缓存，拉取，再合并排序）3、具体来... 查看详情
第二十三课
第二十三课第一单元语法部分Vておく<提前>：预先…… 口语形式：～とく 说明： A、表示为后面要做的事情事先做好某种准备。 B、表示采取某种行为，并使其结果的状态持续下去。&nb... 查看详情