Standard C++ Episode 9
2015-08-21 04:23
507 查看
程序设计=数据结构+算法 外加"设计方法学"
数值算法:微积分、方程组、有限元分析等—工程计算。
非数值算法:查找、排序、决策、调度—系统编程。
一、冒泡排序
1.算法
1)比较相邻的元素,如果第一个比第二个大,就交换它们俩;
2)对每一对相邻的元素做同样的工作,从开始的第一对到结尾的最后一对,使最后的元素为最大值;
3)针对的所有的元素重复以上步骤,除了最后一个;
4)持续每次对越来越少的元素重复以上步骤,直到没有元素需要交换为止。
2.评价
平均时间复杂度:O(N^2)
稳定
对数据的有序性非常敏感
二、插入排序
1.算法
1)从第一个元素开始,该元素可以认为已经有序;
2)取出下一个元素,在已经有序的序列中从后向前扫描;
3)若该元素大于新元素,则将该元素移到下一个位置;
4)若该元素小于等于新元素,则将新元素放在该元素之后;
5)重复步骤2),直到处理完所有元素。
2.评价
平均时间复杂度:O(N^2)
稳定
对数据的有序性非常敏感
因为没有交换,所以赋值的次数比冒泡少,速度比冒泡略快。
三、选择排序
1.算法
首先在未排序序列中找到最小元素,与该序列的首元素交换,再从剩余未排序元素中继续寻找最小元素,放到有序序列的末尾。以此类推,直到所有元素均排序完毕。
2.评价
平均时间复杂度:O(N^2)
稳定
对数据的有序性不敏感
因为交换的次数少,所有速度比冒泡略快。
四、快速排序
1.算法
1)从序列中选出一个元素作为基准;
2)重排序列,所有比基准小的元素位于基准左侧,比基准大的元素位于基准右侧,和基准相等的元素位于任意一侧,此过程称为分组;
3)以递归的方式对小于基准的分组和大于基准的分组分别进行排序。
2.评价
平均时间复杂度:O(NlogN)
不稳定
如果每次能够均匀分组速度将是最快的。
五、归并排序
1.算法
1)申请空间,其大小为两个有序序列之和;
2)设定两个指针,分别指向两个有序序列的起始位置;
3)比较两个指针的目标,选择小值放入合并空间,并将指针移到下一个位置;
4)重复步骤3)直到某一个指针到达序列尾;
5)将另一序列的剩余元素直接复制到合并空间。
2.评价
平均时间复杂度:O(2NlogN)
稳定
对数据的有序性不敏感
非就地排序,不适用于大数据量的排序。
六、线性查找
1.算法
从表头开始依次比较,直到找到与查找目标匹配的元素,或者找不到。
2.评价
平均时间复杂度:O(N)
对数据的有序性没有要求
七、二分查找
1.算法
首先必须保证查找样本必须有序,将表中值与查找目标进行比较,如果二者相等,则查找成功,否则根据查找目标比中值大或者小,在其右侧或者左侧继续前述过程。直到查找成果或者失败。
2.评价
平均时间复杂度:O(logN)
数值算法:微积分、方程组、有限元分析等—工程计算。
非数值算法:查找、排序、决策、调度—系统编程。
一、冒泡排序
1.算法
1)比较相邻的元素,如果第一个比第二个大,就交换它们俩;
2)对每一对相邻的元素做同样的工作,从开始的第一对到结尾的最后一对,使最后的元素为最大值;
3)针对的所有的元素重复以上步骤,除了最后一个;
4)持续每次对越来越少的元素重复以上步骤,直到没有元素需要交换为止。
2.评价
平均时间复杂度:O(N^2)
稳定
对数据的有序性非常敏感
二、插入排序
1.算法
1)从第一个元素开始,该元素可以认为已经有序;
2)取出下一个元素,在已经有序的序列中从后向前扫描;
3)若该元素大于新元素,则将该元素移到下一个位置;
4)若该元素小于等于新元素,则将新元素放在该元素之后;
5)重复步骤2),直到处理完所有元素。
2.评价
平均时间复杂度:O(N^2)
稳定
对数据的有序性非常敏感
因为没有交换,所以赋值的次数比冒泡少,速度比冒泡略快。
三、选择排序
1.算法
首先在未排序序列中找到最小元素,与该序列的首元素交换,再从剩余未排序元素中继续寻找最小元素,放到有序序列的末尾。以此类推,直到所有元素均排序完毕。
2.评价
平均时间复杂度:O(N^2)
稳定
对数据的有序性不敏感
因为交换的次数少,所有速度比冒泡略快。
四、快速排序
1.算法
1)从序列中选出一个元素作为基准;
2)重排序列,所有比基准小的元素位于基准左侧,比基准大的元素位于基准右侧,和基准相等的元素位于任意一侧,此过程称为分组;
3)以递归的方式对小于基准的分组和大于基准的分组分别进行排序。
2.评价
平均时间复杂度:O(NlogN)
不稳定
如果每次能够均匀分组速度将是最快的。
五、归并排序
1.算法
1)申请空间,其大小为两个有序序列之和;
2)设定两个指针,分别指向两个有序序列的起始位置;
3)比较两个指针的目标,选择小值放入合并空间,并将指针移到下一个位置;
4)重复步骤3)直到某一个指针到达序列尾;
5)将另一序列的剩余元素直接复制到合并空间。
2.评价
平均时间复杂度:O(2NlogN)
稳定
对数据的有序性不敏感
非就地排序,不适用于大数据量的排序。
#include <iostream> using namespace std; // 冒泡排序 void bubbleSort (int data[], size_t size) { for (size_t i = 0; i < size - 1; ++i) { bool ordered = true; for (size_t j = 0; j < size - 1 - i; ++j) if (data[j+1] < data[j]) { int temp = data[j+1]; data[j+1] = data[j]; data[j] = temp; ordered = false; } if (ordered) break; } } // 插入排序 void insertSort (int data[], size_t size) { for (size_t i = 1; i < size; ++i) { int temp = data[i]; size_t j; for (j = i; j > 0 && temp < data[j-1]; --j) data[j] = data[j-1]; if (j != i) data[j] = temp; } } // 选择排序 void selectSort (int data[], size_t size) { for (size_t i = 0; i < size - 1; ++i) { size_t min = i; for (size_t j = i + 1; j < size; ++j) if (data[j] < data[min]) min = j; if (min != i) { int temp = data[i]; data[i] = data[min]; data[min] = temp; } } } // 快速排序 void quickSort (int data[], size_t left, size_t right) { size_t p = (left + right) / 2; int pivot = data[p]; for (size_t i = left, j = right; i < j;) { while (! (i>= p || pivot < data[i])) ++i; if (i < p) { data[p] = data[i]; p = i; } while (! (j <= p || data[j] < pivot)) --j; if (j > p) { data[p] = data[j]; p = j; } } data[p] = pivot; if (p - left > 1) quickSort (data, left, p - 1); if (right - p > 1) quickSort (data, p + 1, right); } // 异地合并 void merge (int data1[], size_t size1, int data2[], size_t size2, int data3[]) { size_t i = 0, j = 0, k = 0; for (;;) if (i < size1 && j < size2) if (data1[i] <= data2[j]) data3[k++] = data1[i++]; else data3[k++] = data2[j++]; else if (i < size1) data3[k++] = data1[i++]; else if (j < size2) data3[k++] = data2[j++]; else break; } // 本地合并 void merge (int data[], size_t l, size_t m, size_t r) { int* res = new int[r-l+1]; merge (data+l, m-l+1, data+m+1, r-m, res); for (size_t i = 0; i < r-l+1; ++i) data[l+i] = res[i]; delete[] res; } // 归并排序 void mergeSort (int data[], size_t left, size_t right) { if (left < right) { int mid = (left + right) / 2; mergeSort (data, left, mid); mergeSort (data, mid+1, right); merge (data, left, mid, right); } } int main (void) { int data[] = {13,23,20,12,15,31,19,26,24,37}; size_t size = sizeof (data) / sizeof (data[0]); // bubbleSort (data, size); // insertSort (data, size); // selectSort (data, size); // quickSort (data, 0, size - 1); mergeSort (data, 0, size - 1); for (size_t i = 0; i < size; ++i) cout << data[i] << ' '; cout << endl; /* int data1[] = {10, 20, 30, 45, 66}; int data2[] = {15, 18, 27, 33}; int data3[9]; merge (data1, 5, data2, 4, data3); for (size_t i = 0; i < 9; ++i) cout << data3[i] << ' '; cout << endl; // 10 15 18 20 27 30 33 45 66 /* int data[] = {100,10,20,30,45,66,15,18,27,33,0}; merge (data, 1, 5, 9); for (size_t i = 0; i < 11; ++i) cout << data[i] << ' '; cout << endl; // 100 10 15 18 20 27 30 33 45 66 0 */ return 0; }
/* * 泛型的快速排序 * * C语言标准库中提供的快速排序就是通过函数指针、通过内存拷贝实现了泛型; * C语言向下泛型,因为物理层面他们计算机中的信息没有类型区别; */ #include <stdio.h> #include <string.h> #include <stdlib.h> static void quickSort (void* base, size_t left, size_t right, size_t size, int (*compar) ( const void*, const void*)) { size_t p = (left + right) / 2; void* pivot = malloc (size); memcpy (pivot, base + p * size, size); size_t i, j; for (i = left, j = right; i < j;) { while (! (i >= p || compar (pivot, base + i * size) < 0)) ++i; if (i < p) { memcpy (base + p * size, base + i * size, size); p = i; } while (! (j <= p || compar ( base + j * size, pivot) < 0)) --j; if (j > p) { memcpy (base + p * size, base + j * size, size); p = j; } } memcpy (base + p * size, pivot, size); free (pivot); if (p - left > 1) quickSort (base, left, p - 1, size, compar); if (right - p > 1) quickSort (base, p+1, right, size, compar); } void my_qsort (void* base, size_t numb, size_t size, int (*compar) (const void*, const void*)) { quickSort (base, 0, numb -1, size, compar); } int cmpInt (const void* a, const void* b) { return *(const int*)a - *(const int*)b; } int cmpStr (const void* a, const void* b) { return strcmp (*(const char* const*)a, *(const char* const*)b); } int main (void) { int na[] = {34, 22, 19, 27, 30}; size_t size = sizeof (na[0]); size_t numb = sizeof (na) / size; // qsort (na, numb, size, cmpInt); my_qsort (na, numb, size, cmpInt); size_t i; for (i = 0; i < numb; ++i) printf ("%d ", na[i]); printf ("\n"); const char* sa[] = {"beijing", "chongqing", "shanghai", "tianjin", "guangzhou"}; size = sizeof (sa[0]); numb = sizeof (sa) / size; // qsort (sa, numb, size, cmpStr); my_qsort (sa, numb, size, cmpStr); for (i = 0; i < numb; ++i) printf ("%s ", sa[i]); printf ("\n"); return 0; }
/* * 泛型的快速排序 * * C语言标准库中提供的快速排序通过函数指针、通过内存拷贝实现了泛型;而C++因为可以让对象支持统一的行为(比如都支持* /->操作), 进而通过C++的模板就也实现了泛型; * 他们的区别是: * C语言向下泛型,因为物理层面他们计算机中的信息没有类型区别; * C++语言向上泛型,因为C++通过对行为的抽象,通过让对象支持统一的行为,对于统一的行为通过模板实现泛型。 */ #include <iostream> #include <vector> #include <list> using namespace std; template<class iterator> void print(iterator begin, iterator end) { while (begin != end) { cout << *begin++ << ' '; } cout << endl; } template<typename type> void my_swap (type& a, type& b) { type c = a; a = b; b = c; } template<typename iterator> void my_sort (iterator begin, iterator end) { iterator p = begin; iterator last = end; --last; for (iterator i = begin, j = last; i != j;) { while (! (i == p || *p < *i)) ++i; if (i != p) { my_swap (*p, *i); p = i; } while (! (j == p || *j < *p)) --j; if (j != p) { my_swap (*p, *j); p = j; } } iterator it = begin; ++it; if (p != begin && p != it) my_sort (begin, p); it = p; ++it; if (it != end && it != last) my_sort (it, end); } template<typename iterator, typename comparator> void my_sort (iterator begin, iterator end, comparator cmp) { iterator p = begin; iterator last = end; --last; for (iterator i = begin, j = last; i != j;) { while (! (i == p || cmp (*p, *i))) ++i; if (i != p) { my_swap (*p, *i); p = i; } while (! (j == p || cmp (*j, *p))) --j; if (j != p) { my_swap (*p, *j); p = j; } } iterator it = begin; ++it; if (p != begin && p != it) my_sort (begin, p, cmp); it = p; ++it; if (it != end && it != last) my_sort (it, end, cmp); } //测试用例 class CmpInt { public: bool operator() (int a, int b) const { return a > b; } }; bool Compare(int a, int b) { return a > b; } int main (void) { int na[] = {13, 24, 22, 19, 44, 56, 88, 22}; vector<int> vi (na, na + 8); list<int> li (na, na + 8); my_sort (na, na + 8); print (na, na + 8); my_sort (vi.begin (), vi.end ()); print (vi.begin (), vi.end ()); my_sort (li.begin (), li.end (), CmpInt ()); print (li.begin (), li.end ()); my_sort (li.begin (), li.end (),Compare); print (li.begin (), li.end ()); return 0; }
六、线性查找
1.算法
从表头开始依次比较,直到找到与查找目标匹配的元素,或者找不到。
2.评价
平均时间复杂度:O(N)
对数据的有序性没有要求
七、二分查找
1.算法
首先必须保证查找样本必须有序,将表中值与查找目标进行比较,如果二者相等,则查找成功,否则根据查找目标比中值大或者小,在其右侧或者左侧继续前述过程。直到查找成果或者失败。
2.评价
平均时间复杂度:O(logN)
相关文章推荐
- Standard C++ Episode 8
- Standard C++ Episode 7
- Standard C++ Episode 6
- Standard C++ Episode 5
- 异常?C语言程序中我们如何管控(处理)运行期间的运行异常
- Standard C++ Episode 4
- 使用 cscope浏览 C++文件
- ZOJ 3674 Search in the Wiki 【C++STL大法尽情地模拟】
- C语言内存分配
- C++实现KMP模式匹配算法
- C++ 小技巧之一条语句多行书写
- Codeforces Round #285(Div.2) A,B,C 解题报告
- C++ 的忠告
- 04==C语言(分支结构)
- C++ 小技巧之 字符串字面值拼接
- C++嵌入Python程序(二):参数传入及返回
- C++对象模型——异常处理 (Exception Handling)(第七章)
- 传送门2号 - 算法 x C++
- 警惕C++隐式转换(More Effectiv C++_5(运算符))
- 迷宫游戏C语言实现