标签：
程序设计=数据结构+算法 外加"设计方法学"
数值算法：微积分、方程组、有限元分析等—工程计算。
非数值算法：查找、排序、决策、调度—系统编程。
一、冒泡排序
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 #include <iostream> 2 using namespace std; 3 // 冒泡排序 4 void bubbleSort (int data[], size_t size) { 5 for (size_t i = 0; i < size - 1; ++i) { 6 bool ordered = true; 7 for (size_t j = 0; j < size - 1 - i; ++j) 8 if (data[j+1] < data[j]) { 9 int temp = data[j+1]; 10 data[j+1] = data[j]; 11 data[j] = temp; 12 ordered = false; 13 } 14 if (ordered) 15 break; 16 } 17 } 18 // 插入排序 19 void insertSort (int data[], size_t size) { 20 for (size_t i = 1; i < size; ++i) { 21 int temp = data[i]; 22 size_t j; 23 for (j = i; j > 0 && temp < data[j-1]; --j) 24 data[j] = data[j-1]; 25 if (j != i) 26 data[j] = temp; 27 } 28 } 29 // 选择排序 30 void selectSort (int data[], size_t size) { 31 for (size_t i = 0; i < size - 1; ++i) { 32 size_t min = i; 33 for (size_t j = i + 1; j < size; ++j) 34 if (data[j] < data[min]) 35 min = j; 36 if (min != i) { 37 int temp = data[i]; 38 data[i] = data[min]; 39 data[min] = temp; 40 } 41 } 42 } 43 // 快速排序 44 void quickSort (int data[], size_t left, 45 size_t right) { 46 size_t p = (left + right) / 2; 47 int pivot = data[p]; 48 for (size_t i = left, j = right; i < j;) { 49 while (! (i>= p || pivot < data[i])) 50 ++i; 51 if (i < p) { 52 data[p] = data[i]; 53 p = i; 54 } 55 while (! (j <= p || data[j] < pivot)) 56 --j; 57 if (j > p) { 58 data[p] = data[j]; 59 p = j; 60 } 61 } 62 data[p] = pivot; 63 if (p - left > 1) 64 quickSort (data, left, p - 1); 65 if (right - p > 1) 66 quickSort (data, p + 1, right); 67 } 68 // 异地合并 69 void merge (int data1[], size_t size1, int data2[], 70 size_t size2, int data3[]) { 71 size_t i = 0, j = 0, k = 0; 72 for (;;) 73 if (i < size1 && j < size2) 74 if (data1[i] <= data2[j]) 75 data3[k++] = data1[i++]; 76 else 77 data3[k++] = data2[j++]; 78 else if (i < size1) 79 data3[k++] = data1[i++]; 80 else if (j < size2) 81 data3[k++] = data2[j++]; 82 else 83 break; 84 } 85 // 本地合并 86 void merge (int data[], size_t l, size_t m, 87 size_t r) { 88 int* res = new int[r-l+1]; 89 merge (data+l, m-l+1, data+m+1, r-m, res); 90 for (size_t i = 0; i < r-l+1; ++i) 91 data[l+i] = res[i]; 92 delete[] res; 93 } 94 // 归并排序 95 void mergeSort (int data[], size_t left, 96 size_t right) { 97 if (left < right) { 98 int mid = (left + right) / 2; 99 mergeSort (data, left, mid); 100 mergeSort (data, mid+1, right); 101 merge (data, left, mid, right); 102 } 103 } 104 int main (void) { 105 int data[] = {13,23,20,12,15,31,19,26,24,37}; 106 size_t size = sizeof (data) / sizeof (data[0]); 107 // bubbleSort (data, size); 108 // insertSort (data, size); 109 // selectSort (data, size); 110 // quickSort (data, 0, size - 1); 111 mergeSort (data, 0, size - 1); 112 for (size_t i = 0; i < size; ++i) 113 cout << data[i] << ‘ ‘; 114 cout << endl; 115 /* 116 int data1[] = {10, 20, 30, 45, 66}; 117 int data2[] = {15, 18, 27, 33}; 118 int data3[9]; 119 merge (data1, 5, data2, 4, data3); 120 for (size_t i = 0; i < 9; ++i) 121 cout << data3[i] << ‘ ‘; 122 cout << endl; 123 // 10 15 18 20 27 30 33 45 66 124 /* 125 int data[] = {100,10,20,30,45,66,15,18,27,33,0}; 126 merge (data, 1, 5, 9); 127 for (size_t i = 0; i < 11; ++i) 128 cout << data[i] << ‘ ‘; 129 cout << endl; 130 // 100 10 15 18 20 27 30 33 45 66 0 131 */ 132 return 0; 133 }
1 /* 2 * 泛型的快速排序 3 * 4 * C语言标准库中提供的快速排序就是通过函数指针、通过内存拷贝实现了泛型； 5 * C语言向下泛型，因为物理层面他们计算机中的信息没有类型区别； 6 */ 7 #include <stdio.h> 8 #include <string.h> 9 #include <stdlib.h> 10 static void quickSort (void* base, size_t left, 11 size_t right, size_t size, int (*compar) ( 12 const void*, const void*)) { 13 size_t p = (left + right) / 2; 14 void* pivot = malloc (size); 15 memcpy (pivot, base + p * size, size); 16 size_t i, j; 17 for (i = left, j = right; i < j;) { 18 while (! (i >= p || compar (pivot, 19 base + i * size) < 0)) 20 ++i; 21 if (i < p) { 22 memcpy (base + p * size, 23 base + i * size, size); 24 p = i; 25 } 26 while (! (j <= p || compar ( 27 base + j * size, pivot) < 0)) 28 --j; 29 if (j > p) { 30 memcpy (base + p * size, 31 base + j * size, size); 32 p = j; 33 } 34 } 35 memcpy (base + p * size, pivot, size); 36 free (pivot); 37 if (p - left > 1) 38 quickSort (base, left, p - 1, size, compar); 39 if (right - p > 1) 40 quickSort (base, p+1, right, size, compar); 41 } 42 void my_qsort (void* base, size_t numb, size_t size, 43 int (*compar) (const void*, const void*)) { 44 quickSort (base, 0, numb -1, size, compar); 45 } 46 int cmpInt (const void* a, const void* b) { 47 return *(const int*)a - *(const int*)b; 48 } 49 int cmpStr (const void* a, const void* b) { 50 return strcmp (*(const char* const*)a, 51 *(const char* const*)b); 52 } 53 int main (void) { 54 int na[] = {34, 22, 19, 27, 30}; 55 size_t size = sizeof (na[0]); 56 size_t numb = sizeof (na) / size; 57 // qsort (na, numb, size, cmpInt); 58 my_qsort (na, numb, size, cmpInt); 59 size_t i; 60 for (i = 0; i < numb; ++i) 61 printf ("%d ", na[i]); 62 printf ("\n"); 63 const char* sa[] = {"beijing", "chongqing", 64 "shanghai", "tianjin", "guangzhou"}; 65 size = sizeof (sa[0]); 66 numb = sizeof (sa) / size; 67 // qsort (sa, numb, size, cmpStr); 68 my_qsort (sa, numb, size, cmpStr); 69 for (i = 0; i < numb; ++i) 70 printf ("%s ", sa[i]); 71 printf ("\n"); 72 return 0; 73 }
1 /* 2 * 泛型的快速排序 3 * 4 * C语言标准库中提供的快速排序通过函数指针、通过内存拷贝实现了泛型；而C++因为可以让对象支持统一的行为(比如都支持* /->操作), 进而通过C++的模板就也实现了泛型； 5 * 他们的区别是: 6 * C语言向下泛型，因为物理层面他们计算机中的信息没有类型区别； 7 * C++语言向上泛型，因为C++通过对行为的抽象，通过让对象支持统一的行为，对于统一的行为通过模板实现泛型。 8 */ 9 #include <iostream> 10 #include <vector> 11 #include <list> 12 using namespace std; 13 template<class iterator> 14 void print(iterator begin, iterator end) 15 { 16 while (begin != end) { 17 cout << *begin++ << ‘ ‘; 18 } 19 20 cout << endl; 21 } 22 template<typename type> 23 void my_swap (type& a, type& b) { 24 type c = a; 25 a = b; 26 b = c; 27 } 28 template<typename iterator> 29 void my_sort (iterator begin, iterator end) { 30 iterator p = begin; 31 iterator last = end; 32 --last; 33 for (iterator i = begin, j = last; i != j;) { 34 while (! (i == p || *p < *i)) 35 ++i; 36 if (i != p) { 37 my_swap (*p, *i); 38 p = i; 39 } 40 while (! (j == p || *j < *p)) 41 --j; 42 if (j != p) { 43 my_swap (*p, *j); 44 p = j; 45 } 46 } 47 iterator it = begin; 48 ++it; 49 if (p != begin && p != it) 50 my_sort (begin, p); 51 it = p; 52 ++it; 53 if (it != end && it != last) 54 my_sort (it, end); 55 } 56 template<typename iterator, typename comparator> 57 void my_sort (iterator begin, iterator end, 58 comparator cmp) { 59 iterator p = begin; 60 iterator last = end; 61 --last; 62 for (iterator i = begin, j = last; i != j;) { 63 while (! (i == p || cmp (*p, *i))) 64 ++i; 65 if (i != p) { 66 my_swap (*p, *i); 67 p = i; 68 } 69 while (! (j == p || cmp (*j, *p))) 70 --j; 71 if (j != p) { 72 my_swap (*p, *j); 73 p = j; 74 } 75 } 76 iterator it = begin; 77 ++it; 78 if (p != begin && p != it) 79 my_sort (begin, p, cmp); 80 it = p; 81 ++it; 82 if (it != end && it != last) 83 my_sort (it, end, cmp); 84 } 85 86 //测试用例 87 class CmpInt { 88 public: 89 bool operator() (int a, int b) const { 90 return a > b; 91 } 92 }; 93 94 95 bool Compare(int a, int b) 96 { 97 return a > b; 98 } 99 100 101 102 int main (void) { 103 int na[] = {13, 24, 22, 19, 44, 56, 88, 22}; 104 vector<int> vi (na, na + 8); 105 list<int> li (na, na + 8); 106 my_sort (na, na + 8); 107 print (na, na + 8); 108 my_sort (vi.begin (), vi.end ()); 109 print (vi.begin (), vi.end ()); 110 my_sort (li.begin (), li.end (), CmpInt ()); 111 print (li.begin (), li.end ()); 112 my_sort (li.begin (), li.end (),Compare); 113 print (li.begin (), li.end ()); 114 return 0; 115 }
六、线性查找
1.算法
从表头开始依次比较，直到找到与查找目标匹配的元素，或者找不到。
2.评价
平均时间复杂度：O(N)
对数据的有序性没有要求
七、二分查找
1.算法
首先必须保证查找样本必须有序，将表中值与查找目标进行比较，如果二者相等，则查找成功，否则根据查找目标比中值大或者小，在其右侧或者左侧继续前述过程。直到查找成果或者失败。
2.评价
平均时间复杂度：O(logN)
标签：
原文地址：http://www.cnblogs.com/libig/p/4746718.html
