网站网页设计培训班,余姚网站建设在哪里,中国最新军事新闻最新消息2023,怎么自己建立一个网站后台排序算法总结
冒泡排序
冒泡排序#xff08;Bubble Sort#xff09;也是一种简单直观的排序算法。假设长度为n的数组arr#xff0c;要按照从小到大排序。则冒泡排序的具体过程可以描述为#xff1a;首先从数组的第一个元素开始到数组最后一个元素为止#xff0c;对数组中…排序算法总结
冒泡排序
冒泡排序Bubble Sort也是一种简单直观的排序算法。假设长度为n的数组arr要按照从小到大排序。则冒泡排序的具体过程可以描述为首先从数组的第一个元素开始到数组最后一个元素为止对数组中相邻的两个元素进行比较如果位于数组左端的元素大于数组右端的元素则交换这两个元素在数组中的位置。这样操作后数组最左端的元素即为该数组中所有元素的最小值。接着对该数组除最右端的n-1个元素进行同样的操作再接着对剩下的n-2个元素做同样的操作直到整个数组有序排列。
冒泡排序的原理如下
比较相邻的元素。如果第一个比第二个大就交换他们两个对每一对相邻元素做同样的工作从开始第一对到结尾的最后一对。在这一点最后的元素应该会是最大的数针对所有的元素重复以上的步骤除了最后一个持续每次对越来越少的元素重复上面的步骤直到没有任何一对数字需要比较。
代码实现如下
/*冒泡排序*/
class Bubbling_Sort
{/*时间复杂度O(n*n),空间复杂度O(1)有相对稳定性*/
public:void bub_sort(vectorint arr){for (int i 0; i arr.size(); i){for (int j arr.size() - 1; j i; j--){if (arr[j-1] arr[j]){arr[j] arr[j] ^ arr[j - 1];arr[j-1] arr[j] ^ arr[j - 1];arr[j] arr[j] ^ arr[j - 1];}}}}
};选择排序
选择排序是一种简单直观的排序算法无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。具体来说假设长度为n的数组arr要按照从小到大排序那么先从n个数字中找到最小值min1如果最小值min1的位置不在数组的最左端(也就是min1不等于arr[0])则将最小值min1和arr[0]交换接着在剩下的n-1个数字中找到最小值min2如果最小值min2不等于arr[1]则交换这两个数字依次类推直到数组arr有序排列。算法的时间复杂度为O(n^2)。
选择排序算法的原理如下
首先在未排序序列中找到最小大元素存放到排序序列的起始位置。 再从剩余未排序元素中继续寻找最小大元素然后放到已排序序列的末尾。 重复第二步直到所有元素均排序完毕
。 代码如下
class Choose_Sort
{/*时间复杂度O(n*n),空间复杂度O(1),没有相对稳定性*/
public:void c_sort(vectorint arr){for (int i 0; i arr.size(); i){for (int j i1; j arr.size(); j){if (arr[i] arr[j]){arr[i] arr[i] ^ arr[j];arr[j] arr[i] ^ arr[j];arr[i] arr[i] ^ arr[j];}}}}
};插入排序
插入排序Insertion-Sort的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列对于未排序数据在已排序序列中从后向前扫描找到相应位置并插入。该算法的时间复杂度为O(n^2)。
插入排序算法的原理如下
从第一个元素开始该元素可以认为已经被排序取出下一个元素在已经排序的元素序列中从后向前扫描如果该元素已排序大于新元素将该元素移到下一位置重复步骤3直到找到已排序的元素小于或者等于新元素的位置将新元素插入到该位置后重复步骤2~5。
代码如下
class Insert_Sort
{
/*插入排序时间复杂度是O(n*n),空间复杂度是O(1)有相对稳定性*/
public:void In_sort(vectorint arr){for (int i 0; i arr.size(); i){for (int j i; j0; j--){if (arr[j-1] arr[j])break;sort(arr, j - 1, j);}}}void sort(vectorint arr, int i, int j){arr[i] arr[i] ^ arr[j];arr[j] arr[i] ^ arr[j];arr[i] arr[i] ^ arr[j];}
};归并排序
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法Divide and Conquer的一个非常典型的应用。将已有序的子序列合并得到完全有序的序列即先使每个子序列有序再使子序列段间有序。代价是需要额外的内存空间。若将两个有序表合并成一个有序表称为2-路归并。 该算法时间复杂度为O(nlogn)。
归并排序算法的原理如下
把长度为n的输入序列分成两个长度为n/2的子序列对这两个子序列分别采用归并排序 将两个排序好的子序列合并成一个最终的排序序列。
代码如下
class Merge_sort{
/*归并排序的时间复杂度为O(nlogn),空间复杂度为O(n)有相对稳定性*/
public:void Me_sort(vectorint arr,int Left,int Right){if(Left Right)return;int mid Left ((Right-Left) 1);Me_sort(arr,mid1,Right);Me_sort(arr,Left,mid);Merge(arr,mid,Left,Right);}void Merge(vectorint arr,int mid,int Left,int Right){int *buf new int[Right - Left 1];int bufsize 0;int iLeft;int jmid1;while(imid jRight){if(bufsize Right - Left 1)break;buf[bufsize] arr[i] arr[j] ? arr[i]:arr[j];}while(imid){if(bufsize Right - Left 1)break;buf[bufsize] arr[i];}while(jRight){if(bufsize Right - Left 1)break;buf[bufsize] arr[j];}for(int k0;kbufsize;k){if(Left k Right)break;arr[Leftk] buf[k];}delete[] buf;}
};快速排序
快速排序通常明显比其他 Ο(nlogn) 算法更快因为它的内部循环inner loop可以在大部分的架构上很有效率地被实现出来。快速排序的基本思想是通过一趟排序将待排记录分割成独立的两部分其中一部分记录的关键字均比另一部分记录的关键字小则可分别对这两部分记录继续进行排序已达到整个序列有序。一趟快速排序的具体过程可描述为从待排序列中任意选取一个记录(通常选取第一个记录)作为基准值然后将记录中关键字比它小的记录都安置在它的位置之前将记录中关键字比它大的记录都安置在它的位置之后。这样以该基准值为分界线将待排序列分成的两个子序列。它是处理大数据最快的排序算法之一了。该算法时间复杂度为O(n log n)。
快速排序算法的原理如下
从数列中挑出一个元素称为 “基准”pivot;重新排序数列所有元素比基准值小的摆放在基准前面所有元素比基准值大的摆在基准的后面相同的数可以到任一边。在这个分区退出之后该基准就处于数列的中间位置。这个称为分区partition操作递归地recursive把小于基准值元素的子数列和大于基准值元素的子数列排序。
代码如下
class Quick_Sort
{/*时间复杂度为O(nlogn),空间复杂度为O(logn)没有相对稳定性*/int* p new int[2];
public:void quick_sort(vectorint arr, int Left, int Right){if (Left Right)return;swap(arr, Left (rand() * (Right - Left) / RAND_MAX), Right);int* p partition(arr, Left, Right);quick_sort(arr, Left, p[0]-1); // 区quick_sort(arr, p[1]1, Right);// 区}void swap(vectorint arr ,int i, int j){int temp arr[i];arr[i] arr[j];arr[j] temp;}int* partition(vectorint arr, int Left, int Right){int L Left-1;int R Right;int P Left;while (P R){if (arr[P] arr[Right])swap(arr, P, --R);else if (arr[P] arr[Right]){swap(arr, L, P);}elseP;}swap(arr, R, Right);p[0] L1;p[1] R;return p;}~Quick_Sort() {delete[] p;}
};堆排序
堆排序Heapsort是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构并同时满足堆积的性质即子结点的键值或索引总是小于或者大于它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法每个结点的值都大于等于其左右孩子结点的值称为大顶堆或者每个结点的值都小于等于其左右孩子结点的值称为小顶堆。该算法时间复杂度为O(nlogn)。
代码实现如下
class Heap_Sort
{/*堆排序的时间复杂度为O(nlogn),空间复杂度为O(1)没有相对稳定性*/
public:void heap(vectorint arr){if (arr.empty() || arr.size() 2)return ;for (int i 0; i arr.size(); i){heap_insert(arr, i);}int heapsize arr.size();swap(arr, 0, --heapsize);while (heapsize0){heapify(arr, 0, heapsize);swap(arr, 0, --heapsize);}}void heap_insert(vectorint arr, int temp){while (temp 0 arr[(temp - 1) / 2] arr[temp]){swap(arr, (temp - 1) / 2, temp);temp (temp - 1) / 2;}}void swap(vectorint arr, int i, int j){int temp arr[i];arr[i] arr[j];arr[j] temp;}void heapify(vectorint arr, int index, int heapSize){int left (index * 2) 1;while (left heapSize){/*这里很细节要注意当left1大于heapsize时是否要取left*/int leagues left 1 heapSize arr[left1] arr[left] ? left1 : left;leagues arr[index] arr[leagues] ? leagues : index;if (index leagues)break;swap(arr, index, leagues);index leagues;left (index * 2) 1;}}
};总结
复杂度
为O(n^2)的有冒泡排序、选择排序、插入排序、希尔排序 为O(nlogn)的有快速排序、归并排序、堆排序
稳定性
具有相对稳定性的是冒泡排序、插入排序、归并排序 没有相对稳定性的是选择排序、快速排序、堆排序
