*********************************** input . cpp *****************************************#include<iostream>#include<iterator>#include<vector>using namespace std ;istream & input ( istream & in , vector < int > & get ){istream_iterator < int > begin ( in );istream_iterator < int > end ;ostream_iterator < int > out ( cout , " " );get . clear ();get . assign ( begin , end );cout << "check the input " << endl ;for ( vector < int >:: iterator index = get . begin (); index != get . end (); index ++ )* out = * index ;cout << endl ;cout << "size of the vector" << endl ;cout << get . size ();cout << endl ;return in ;}***************************************************************************/***************************************output.cpp*****************************#include <vector>#include <iostream>#include <iterator>using namespace std;ostream& output(vector<int> &out){ostream_iterator<int> os(cout, " ");cout << "after sort" << endl;for(vector<int>::const_iterator iter = out.begin(); iter != out.end(); iter++)*os = *iter;cout << endl;return cout;}/*********************************排序算法文件 test.cpp***************#include <iostream>#include <vector>using namespace std;extern ostream& output(vector<int> &);extern istream& input(istream&, vector<int> &);/***********************************Selection************************int sort(vector<int> &a){int tmp, change;for(int i = 0; i < a.size() - 1; i++){int find = -1;int j = i + 1, tmp = a[i];while(j < a.size()){if(tmp > a[j]){tmp = a[j];find = j;}++j;}if(find != -1){change = a[i];a[i] = a[find];a[find] = change;}}}平均时间复杂度n^2**********************************************************************************//******************************冒泡排序********************************int sort(vector<int> &a){int tmp;for(int i = 0; i < a.size(); i++){for( int j = 0; j < a.size() - i - 1; j++){if(a[j] > a[j+1]){tmp = a[j];a[j] = a[j+1];a[j+1] = tmp;}}}return 0;}时间复杂度 n^2***************************************************************//*************************插入排序***********************************int sort(vector<int> &a){int tmp;if(a.size() < 2)return 1;for(int i = 1; i < a.size(); i++){tmp = a[i];for(int j = i - 1; j >= 0; j--){if(a[j] < tmp){a[j + 1] = tmp;break;}a[j + 1] = a[j];}}return 0;}平均时间复杂度n^2**********************************************************************************//*****************************合并排序******************************************int sort(vector<int> &a, int p, int q);int merge(vector<int> &a, int p, int q);int merge(vector<int> &a, int p, int q){if(p == q)return 0;int mid = (p + q)/2;int *tmp = new int [q - p + 1];int left = p, right = mid+1, index = 0;while(left != mid+1 && right != q+1){if(a[left] < a[right]){tmp[index++] = a[left++];}else{tmp[index++] = a[right++];}}if(right == q + 1){while(left != mid + 1)tmp[index++] = a[left++];}else{while(right != q + 1)tmp[index++] = a[right++];}index = 0;int size = q - p + 1;while(index != size)a[p++] = tmp[index++];delete [] tmp;return 0;}int sort(vector<int> &a, int p, int q){if(p < q){int mid = (p + q)/2;sort(a, p, mid);sort(a, mid + 1, q);merge(a, p, q);}}最坏时间复杂度 nlgn******************************************************************************//******************************堆排序*********************************void MaxHeapify(vector<int> &a, int i, int size){int largest, tmp, rchild, lchild, circle = 1;while(circle){lchild = 2*i+1, rchild = 2*i+2;if(lchild < size && a[lchild] > a[i])largest = lchild;elselargest = i;if(rchild < size && a[rchild] > a[i] && a[rchild] > a[lchild])largest = rchild;if(largest != i){tmp = a[largest];a[largest] = a[i];a[i] = tmp;i = largest;}else{circle = 0;}}}void BuildHeap(vector<int> &a,int size){for(int i = size - 1; i >= 0; i--){MaxHeapify(a, i, size);}}void sort(vector<int> &a, int size){int tmp;BuildHeap(a, size);for(int i = size; i > 1; i--){tmp = a[0];a[0] = a[i-1];a[i-1] = tmp;MaxHeapify(a, 0, i - 1);}}//最优时间复杂度O(n) 最劣时间复杂度O(nlgn)*************************************************************************************//*********************************快速排序*******************************************int Quicksort(vector<int> &a, int p, int q){int i = p - 1, j = i + 1, tmp;int x = a[q];for(; j < q; j++){if( a[j] < x){++i;tmp = a[i];a[i] = a[j];a[j] = tmp;}}++i;tmp = a[i];a[i] = a[q];a[q] = tmp;return i;}int sort(vector<int> &a, int p, int r){int q;if(p < r){q = Quicksort(a, p, r);sort(a, p, q - 1);sort(a, q + 1, r);}}//最优时间复杂度O(nlgn), 最劣时间复杂度 n^2*****************************************************************************//*************************计数排序******************************************int sort(vector<int> &a, int size, int k){int *count = new int[k];for(int i = 0; i != size; i++){++count[a[i]];}int j = 0, index = 0;while(j != k){while(count[j]--){a[index++] = j;}++j;}delete [] count;}//时间复杂度O(n+k), K太大时很不划算， 很耗内存*************************************************************************//***********************************基数排序********************************int RadixSort(int *key, vector<int> &data, int size, int k){int *count = new int[k];int *tmp = new int[size];for(int i = 0 ; i != k; i++){count[i] = 0;}for(int i = 0; i != size; i++){++count[key[i]];}for(int i = 1; i != k; i++ ){count[i] += count[i - 1];}for(int i = size - 1; i >= 0; i--){tmp[--count[key[i]]] = data[i];}for(int i = 0; i < size; i++){data[i] = tmp[i];}delete count;delete tmp;return 0;}int sort(vector<int> &a, int size, int k){int base = 1;int *key = new int[size] ;while(1){int circle = 0;int count = 0;for(vector<int>::const_iterator iter=a.begin(); iter !=a.end(); iter++, count++){int tmp = *iter/base;tmp %= 10;key[count] = tmp;if(tmp != 0 )circle = 1;}if(circle == 0)break;RadixSort(key, a, size, k);base *= 10;}delete [] key;}//基数排序利用了部分计数排序的思想，但其巧妙之处在于利用少量时间复杂度的代价换取了更少的内存消耗，达到了一个奇妙的平衡//时间复杂度d（n+k）********************************************************************//*************************************BucketSort********************************typedef struct nodes{int val;struct nodes *next;}node;int BucketSort(vector<int> &a, int size, int bucket_num){node **store = new node *[bucket_num];for(int i = 0; i != bucket_num; i++){store[i] = NULL;}for(int i = 0; i != size; i++){node *tmp = new node;tmp->val = a[i];tmp->next = NULL;int index = a[i]/10;node *p = store[index];if(p){node *q = NULL;while(tmp->val > p->val && p->next){q = p;p = p->next;}if(tmp->val <= p->val){if(store[index] == p){tmp->next = p;store[index] = tmp;}else{q->next = tmp;tmp->next = p;}}else{p->next = tmp;}}else{store[index] = tmp;}}int count = 0;for(int i = 0; i != bucket_num; i++){node *out = store[i];while(out){a[count++] = out->val;out = out->next;}}for(int i = 0; i != bucket_num; i++){delete store[i];}delete store;return 0;}// O(N)+O(M*(N/M)*log(N/M))=O(N+N*(logN-logM))=O(N+N*logN-N*logM)//当N=M时，即极限情况下每个桶只有一个数据时。桶排序的最好效率能够达到O(N)。*********************************************************************************/int main ( void ){vector < int > store ;input ( cin , store );cin . clear ();sort ( store , store . size (), 10 );output ( store );return 0 ;}
排序算法总结
最新推荐文章于 2023-04-05 09:51:20 发布
扫一扫
3804
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
