C++排序算法总结及性能大致分析
利用指针排序实验报告(3篇)
第1篇一、实验目的1. 理解指针在排序算法中的应用。
2. 掌握几种常见的排序算法（如冒泡排序、选择排序、插入排序等）的指针实现方式。
3. 比较不同排序算法的效率，分析其优缺点。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019三、实验内容本次实验主要实现了以下排序算法：1. 冒泡排序2. 选择排序3. 插入排序以下是对每种排序算法的具体实现和性能分析。
1. 冒泡排序（1）算法原理冒泡排序是一种简单的排序算法。
它重复地遍历待排序的序列，比较每对相邻的元素，如果它们的顺序错误就把它们交换过来。
遍历序列的工作是重复地进行，直到没有再需要交换的元素为止。
（2）指针实现```cppvoid bubbleSort(int arr, int len) {for (int i = 0; i < len - 1; i++) {for (int j = 0; j < len - 1 - i; j++) {if ((arr + j) > (arr + j + 1)) {int temp = (arr + j);(arr + j) = (arr + j + 1);(arr + j + 1) = temp;}}}}```（3）性能分析冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
当待排序序列基本有序时，冒泡排序的性能较好。
2. 选择排序（1）算法原理选择排序是一种简单直观的排序算法。
它的工作原理是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
（2）指针实现```cppvoid selectionSort(int arr, int len) {for (int i = 0; i < len - 1; i++) {int minIndex = i;for (int j = i + 1; j < len; j++) {if ((arr + j) < (arr + minIndex)) {minIndex = j;}}int temp = (arr + i);(arr + i) = (arr + minIndex);(arr + minIndex) = temp;}}```（3）性能分析选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
快速排序算法c语言实验报告
快速排序算法c语言实验报告冒泡法和选择法排序C程序实验报告实验六：冒泡法排序物理学416班赵增月F12 2011412194日期：2013年10月31日一·实验目的 1.熟练掌握程序编写步骤；2.学习使用冒泡法和选择法排序；3.熟练掌握数组的定义和输入输出方法。
二·实验器材1.电子计算机；2.VC6.0三·实验内容与流程1.流程图（1）冒泡法(2)选择法 2.输入程序如下：（1）冒泡法#includestdio.h void main() { int a[10]; int i,j,t; printf(请输入10个数字：\n); for(i=0;i10;i++)scanf(%d,&a[i]); printf(\n); for(j=0;j9;j++)for(i=0;i9-j;i++) if(a[i]a[i+1]) { t=a[i]; a[i]=a[i+1]; a[i+1]=t; } printf(排序后如下：\n); for(i=0;i10;i++) printf(%d,a[i]); printf(\n); }（2）选择法#includestdio.h void main() { int a[10]; int i,j,t,k; printf(请输入10个数字：\n); for(i=0;i10;i++)scanf(%d,&a[i]);printf(\n); for(i=0;i9;i++) {k=i;for(j=i+1;j10;j++) if (a[k]a[j])k=j;t=a[i];a[i]=a[k];a[k]=t; }printf(排序后如下：\n); for(i=0;i10;i++)printf(%d,a[i]); printf(\n); }四．输出结果（1冒泡法）请输入10个数字：135****2468排序后如下：12345678910 （2）选择法输出结果请输入10个数字：135****6810排序后如下：12345678910五．实验反思与总结1.冒泡法和选择法是一种数组排序的方法，包含两层循环，写循环时，要注意循环变量的变化范围。
关于C语言排序算法的探讨
关于C语言排序算法的探讨【摘要】在学习c语言的过程中，数据的排序是经常遇到的问题，在这一过程中，就必须运用排序算法。
通过排序算法，对于一组排列无规律的数据根据大小顺序进行重新排序。
c语言排序算法是多种多样的，主要包括插入排序算法、选择排序算法、冒泡排序算法等等。
这些排序算法的基本思想、排序过程都存在着各自的主要特征，本文将进行关于c语言排序算法的探讨，希望能够有利于c语言学习者更好地掌握各种各样的排序算法。
【关键词】c语言排序算法【中图分类号】g42 【文献标识码】a 【文章编号】2095-3089（2013）04-0162-02一、引言在处理数据的过程中，对于数据进行排序是非常关键的。
通过数据的排序，能够将数据变得井然有序，从而有利于更加高效率地处理数据。
在人们日常的工作、学习和生活过程中，数据的排序也是经常用到的，主要包括：期末考试后班级所有学习者的成绩的排名、奥林匹克竞赛中分数据项的排名、评奖评优综合测评分数据项的排序等等。
显然，如果靠人工计算的话，这些排序是非常不容易实现的，而必须通过特定的排序算法在计算机中运用软件来实现。
接下来，本文将结合笔者多年来进行c语言教学的实际工作经验，深入探索c语言排序算法。
二、插入排序算法算法要求：用插入排序算法对10个整数进行降序排序。
算法分析：将序列划分成有序序列和无序序列，依次从无序序列中选择数据项值，并且将其插入到有序序列的合适位置。
在初始状态，有序序列中只存在第一个数，而剩下的n-1个数构成一个无序序列，那么，n个数据项就必须进行n-1次插入。
为了定位在有序序列中的插入位置，就必须从有序序列的最后一个数据项向前进行定位，在没有找到插入点之前，必须同时向向后移动动数据项，为插入数据项来腾出足够的空间。
算法主要特征：每一趟排序算法从无序序列中取出第一个数插入到有序序列的合适位置，数据项之间的最终位置在最后一趟插入后才能确定位置。
也可是先用循环查找插入位置（可从左边开始向右边进行或从右边开始向左边进行），再将插入位置之后的数据项（有序列中）逐个向后移动一个位置，最后完成插入。
C语言常用算法总结
C语言常用算法总结1、冒泡排序算法：冒泡排序是一种简单的排序算法，它重复地遍历要排序的序列，一次比较两个相邻的元素如果他们的顺序错误就把他们交换过来。
时间复杂度为O(n^2)。
2、快速排序算法：快速排序是一种基于分治的排序算法，通过递归的方式将数组划分为两个子数组，然后对子数组进行排序最后将排好序的子数组合并起来。
时间复杂度为O(nlogn)。
3、插入排序算法：插入排序是一种简单直观的排序算法，通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描找到相应位置并插入。
时间复杂度为O(n^2)。
4、选择排序算法：选择排序是一种简单的排序算法，每次循环选择未排序部分的最小元素，并放置在已排序部分的末尾。
时间复杂度为O(n^2)。
5、归并排序算法：归并排序是一种稳定的排序算法，基于分治思想，将数组递归地分为两个子数组，将子数组排序后再进行合并最终得到有序的数组。
时间复杂度为O(nlogn)。
6、堆排序算法：堆排序是一种基于完全二叉堆的排序算法，通过构建最大堆或最小堆，然后依次将堆顶元素与末尾元素交换再调整堆，得到有序的数组。
时间复杂度为O(nlogn)。
7、二分查找算法：二分查找是一种在有序数组中查找目标元素的算法，每次将待查找范围缩小一半，直到找到目标元素或范围为空。
时间复杂度为O(logn)。
8、KMP算法：KMP算法是一种字符串匹配算法，通过利用模式字符串的自重复性，避免不必要的比较提高匹配效率。
时间复杂度为O(m+n)，其中m为文本串长度，n为模式串长度。
9、动态规划算法：动态规划是一种通过将问题分解为子问题，并通过组合子问题的解来求解原问题的方法。
动态规划算法通常使用内存空间来存储中间结果，从而避免重复计算。
时间复杂度取决于问题规模。
10、贪心算法：贪心算法是一种通过选择局部最优解来构建全局最优解的算法并以此构建最终解。
时间复杂度取决于问题规模。
11、最短路径算法：最短路径算法用于求解图中两个节点之间的最短路径，常见的算法包括Dijkstra算法和Floyd-Warshall算法。
C语言八大排序算法
C语⾔⼋⼤排序算法C语⾔⼋⼤排序算法，附动图和详细代码解释！来源：C语⾔与程序设计、⽵⾬听闲等⼀前⾔如果说各种编程语⾔是程序员的招式，那么数据结构和算法就相当于程序员的内功。
想写出精炼、优秀的代码，不通过不断的锤炼，是很难做到的。
⼆⼋⼤排序算法排序算法作为数据结构的重要部分，系统地学习⼀下是很有必要的。
1、排序的概念排序是计算机内经常进⾏的⼀种操作，其⽬的是将⼀组“⽆序”的记录序列调整为“有序”的记录序列。
排序分为内部排序和外部排序。
若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。
反之，若参加排序的记录数量很⼤，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。
2、排序分类⼋⼤排序算法均属于内部排序。
如果按照策略来分类，⼤致可分为：交换排序、插⼊排序、选择排序、归并排序和基数排序。
如下图所⽰：3、算法分析1.插⼊排序*直接插⼊排序*希尔排序2.选择排序*简单选择排序*堆排序3.交换排序*冒泡排序*快速排序4.归并排序5.基数排序不稳定排序：简单选择排序，快速排序，希尔排序，堆排序稳定排序：冒泡排序，直接插⼊排序，归并排序，奇数排序1、插⼊排序将第⼀个和第⼆个元素排好序，然后将第3个元素插⼊到已经排好序的元素中，依次类推（插⼊排序最好的情况就是数组已经有序了）因为插⼊排序每次只能操作⼀个元素，效率低。
元素个数N，取奇数k=N/2，将下标差值为k的数分为⼀组（⼀组元素个数看总元素个数决定），在组内构成有序序列，再取k=k/2，将下标差值为k的数分为⼀组，构成有序序列，直到k=1，然后再进⾏直接插⼊排序。
3、简单选择排序选出最⼩的数和第⼀个数交换，再在剩余的数中⼜选择最⼩的和第⼆个数交换，依次类推4、堆排序以升序排序为例，利⽤⼩根堆的性质（堆顶元素最⼩）不断输出最⼩元素，直到堆中没有元素1.构建⼩根堆2.输出堆顶元素3.将堆低元素放⼀个到堆顶，再重新构造成⼩根堆，再输出堆顶元素，以此类推5、冒泡排序改进1：如果某次冒泡不存在数据交换，则说明已经排序好了，可以直接退出排序改进2：头尾进⾏冒泡，每次把最⼤的沉底，最⼩的浮上去，两边往中间靠16、快速排序选择⼀个基准元素，⽐基准元素⼩的放基准元素的前⾯，⽐基准元素⼤的放基准元素的后⾯，这种动作叫分区，每次分区都把⼀个数列分成了两部分，每次分区都使得⼀个数字有序，然后将基准元素前⾯部分和后⾯部分继续分区，⼀直分区直到分区的区间中只有⼀个元素的时候，⼀个元素的序列肯定是有序的嘛，所以最后⼀个升序的序列就完成啦。
c语言数字从大到小排列
c语言数字从大到小排列C语言数字从大到小排列C语言中，数字的排序是程序员需要掌握的计算机技能之一。
下面将介绍如何使用C语言编写程序来实现数字从大到小的排序。
I. 程序思路1. 输入需要排序的数字，将其存储在数组中；2. 从数组中选择一个数字作为基准点，将比基准点小的数字放在基准点左边，比基准点大的数字放在基准点右边；3. 对基准点左边和右边的数字重复第2步，直到所有数字都排列完成。
II. 编程实现1. 定义函数来实现数字排序：```void sort(int arr[], int left, int right){int i, j, pivot, temp;if (left < right) {pivot = left;i = left;j = right;while (i < j) {while (arr[i] >= arr[pivot] && i < right)i++;while (arr[j] < arr[pivot])j--;if (i < j) {temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}temp = arr[pivot];arr[pivot] = arr[j];arr[j] = temp;sort(arr, left, j - 1);sort(arr, j + 1, right);}}```2. 在主函数中输入需要排序的数字，并输出排序结果：```int main(){int arr[100], i, n;printf("请输入数字的个数：");scanf("%d", &n);for (i = 0; i < n; i++) {printf("请输入第 %d 个数字：", i + 1);scanf("%d", &arr[i]);}sort(arr, 0, n - 1);printf("数字按从大到小排列的结果：\n");for (i = 0; i < n; i++)printf("%d ", arr[i]);return 0;}```在上述代码中，sort函数使用快速排序算法实现数字从大到小的排列。
CC++实现快速排序算法的思路及原理解析
CC++实现快速排序算法的思路及原理解析⽬录快速排序2. 实现原理3. 动态演⽰4. 完整代码5. 结果展⽰6. 算法分析快速排序1. 算法思想快速排序的基本思想：通过⼀趟排序将待排记录分隔成独⽴的两部分，其中⼀部分记录的关键字均⽐另⼀部分的关键字⼩，则可分别对这两部分记录继续进⾏排序，以达到整个序列有序。
2. 实现原理2.1、设置两个变量 low、high，排序开始时：low=0，high=size-1。
2.2、整个数组找基准正确位置，所有元素⽐基准值⼩的摆放在基准前⾯，所有元素⽐基准值⼤的摆在基准的后⾯默认数组的第⼀个数为基准数据，赋值给key，即key=array[low]。
因为默认数组的第⼀个数为基准，所以从后⾯开始向前搜索（high–），找到第⼀个⼩于key的array[high]，就将 array[high] 赋给 array[low]，即 array[low] = array[high]。
（循环条件是 array[high] >= key；结束时 array[high] < key）此时从前⾯开始向后搜索（low++），找到第⼀个⼤于key的array[low]，就将 array[low] 赋给 array[high]，即 array[high] = array[low]。
（循环条件是 array[low] <= key；结束时 array[low] > key）循环 2-3 步骤，直到 low=high，该位置就是基准位置。
把基准数据赋给当前位置。
2.3、第⼀趟找到的基准位置，作为下⼀趟的分界点。
2.4、递归调⽤（recursive）分界点前和分界点后的⼦数组排序，重复2.2、2.3、2.4的步骤。
2.5、最终就会得到排序好的数组。
3. 动态演⽰4. 完整代码三个函数基准插⼊函数：int getStandard(int array[],int low,int high)（返回基准位置下标）递归排序函数：void quickSort(int array[],int low,int high)主函数：int main()#include <stdio.h>#include <stdlib.h>void display(int* array, int size) {for (int i = 0; i < size; i++) {printf("%d ", array[i]);}printf("\n");}int getStandard(int array[], int i, int j) {// 基准数据int key = array[i];while (i < j) {// 因为默认基准是从左边开始，所以从右边开始⽐较// 当队尾的元素⼤于等于基准数据时,就⼀直向前挪动 j 指针while (i < j && array[j] >= key) {j--;}// 当找到⽐ array[i] ⼩的时，就把后⾯的值 array[j] 赋给它if (i < j) {array[i] = array[j];}// 当队⾸元素⼩于等于基准数据时,就⼀直向后挪动 i 指针while (i < j && array[i] <= key) {i++;}// 当找到⽐ array[j] ⼤的时，就把前⾯的值 array[i] 赋给它if (i < j) {array[j] = array[i];}}// 跳出循环时 i 和 j 相等,此时的 i 或 j 就是 key 的正确索引位置// 把基准数据赋给正确位置array[i] = key;return i;}void QuickSort(int array[], int low, int high) {// 开始默认基准为 lowif (low < high) {// 分段位置下标int standard = getStandard(array, low, high);// 递归调⽤排序// 左边排序QuickSort(array, low, standard - 1);// 右边排序QuickSort(array, standard + 1, high);}}// 合并到⼀起快速排序// void QuickSort(int array[], int low, int high) {// if (low < high) {// int i = low;// int j = high;// int key = array[i];// while (i < j) {// while (i < j && array[j] >= key) {// j--;// }// if (i < j) {// array[i] = array[j];// }// while (i < j && array[i] <= key) {// i++;// }// if (i < j) {// array[j] = array[i];// }// }// array[i] = key;// QuickSort(array, low, i - 1);// QuickSort(array, i + 1, high);// }// }int main() {int array[] = {49, 38, 65, 97, 76, 13, 27, 49, 10};int size = sizeof(array) / sizeof(int);// 打印数据printf("%d \n", size);QuickSort(array, 0, size - 1);display(array, size);// int size = 20;// int array[20] = {0}; // 数组初始化// for (int i = 0; i < 10; i++) { // 数组个数// for (int j = 0; j < size; j++) { // 数组⼤⼩// array[j] = rand() % 1000; // 随机⽣成数⼤⼩ 0~999// }// printf("原来的数组：");// display(array, size);// QuickSort(array, 0, size - 1);// printf("排序后数组：");// display(array, size);// printf("\n");// }return 0;}5. 结果展⽰（递归调⽤，不好展⽰每次排序结果）6. 算法分析时间复杂度：最好： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)最坏： O ( n 2 ) O(n^2) O(n2)平均： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)空间复杂度： O ( n l o g 2 n ) O(n log_{2} n) O(nlog2n)稳定性：不稳定到此这篇关于C/C++实现快速排序算法的思路及原理解析的⽂章就介绍到这了,更多相关C++实现快速排序算法内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。
c语言链表排序算法
c语言链表排序算法在C语言中，链表的排序可以使用多种算法，如插入排序、归并排序、快速排序等。
以下是一个简单的插入排序算法的示例，用于对链表进行排序：C：#include<stdio.h>#include<stdlib.h>struct Node {int data;struct Node* next;};void insert(struct Node** head, int data) {struct Node* newNode= (struct Node*)malloc(sizeof(struct Node));newNode->data = data;newNode->next = NULL;if (*head == NULL) {*head = newNode;return;}struct Node* current = *head;while (current->next != NULL) {current = current->next;}current->next = newNode;}void sortList(struct Node** head) { struct Node* current = *head;while (current != NULL) {struct Node* next = current->next; while (next != NULL) {if (current->data > next->data) { int temp = current->data;current->data = next->data;next->data = temp;}next = next->next;}current = current->next;}}void printList(struct Node* head) { while (head != NULL) {printf("%d ", head->data);head = head->next;}}int main() {struct Node* head = NULL;insert(&head, 5);insert(&head, 2);insert(&head, 4);insert(&head, 1);insert(&head, 3);printf("Before sorting: ");printList(head);sortList(&head);printf("\nAfter sorting: ");printList(head);return0;}这个程序定义了一个链表节点结构体Node，其中包含一个整型数据data 和一个指向下一个节点的指针next。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
这里讲的排序默认为内排序。
参考书籍：数据结构(C语言版)秦玉平马靖善主编冯佳昕周连秋副主编清华大学出版社按照排序过程中依据的原则不同划分为：（1）插入排序包括直接插入排序，折半插入排序，2_路插入排序，shell排序（2）交换排序包括简单交换排序，冒泡排序，快速排序（3）选择排序包括简单选择排序，*树形选择排序，*堆排序（4）归并排序（5）计数排序包括*计数排序，基数排序*上面打星号的代码没有添加*下面代码修改自/%D0%E3%B2%C5%CC%AB%CA%D8/blog/item/5ad1f372177b21 158701b093.html主要修改了快速排序的错误，添加了折半插入排序和2_路插入排序，而且按照以上(1)~(5)重新改写了程序的结构。
代码如下：排序头文件：sort.h#ifndef __SORT_H__#define __SORT_H__/******************************************************************** ****//* 排序头文件 *//******************************************************************** ****//******************************************************************** ****//* 头文件包含 */#include "insertSort.h"#include "exchangeSort.h"#include "selectSort.h"#include "mergeSort.h"#include "countSort.h"/************************************************************************/#endif（1）插入排序：insertSort.h#ifndef __INSERTSORT_H__#define __INSERTSORT_H__/******************************************************************** ****//*常用头文件包含*/#include <vector>using namespace std;/******************************************************************** ****//******************************************************************** ****//*插入排序的思想插入排序属于插入方法的排序算法，它的想法是从第一个元素开始，创建有序序列，把未排序序列依次插入到有序序列中，以此类推*//******************************************************************** ****//*函数实现，按从小到大排序*/template <class T>void insertSort(vector<T>& v){/*直接插入排序*/for (unsigned int i = 1; i < v.size(); i++){T tmp = v[i];int j = i - 1;while (j >= 0 && v[j] > tmp){v[j+1] = v[j];j--;}v[j+1] = tmp;}}template <class T>void biInsertSort(vector<T>& v){/*折半插入排序*/for (unsigned int i = 1; i < v.size(); i++) {T tmp = v[i];int low = 0;int high = i - 1;while (low <= high){int mid = (low + high) / 2;if (tmp > v[mid]){low = mid + 1;}else{high = mid - 1;}}int j = i - 1;while (j >= 0 && v[j] > tmp){v[j+1] = v[j];j--;}v[j+1] = tmp;}}template <class T>void binInsertSort(vector<T>& v){/*2_路查找排序*/vector<T> vecTmp(v);int first,final,low,high,mid,k,j;unsigned int i,siz;siz = v.size();first = final = 0;for (i = 1; i < siz; i++){T tmp = v[i];if (tmp >= vecTmp[0]){low = 0;high = final;while (low <= high){mid = (low + high) / 2;if (v[i] > vecTmp[mid]){low = mid + 1;}else{high = mid - 1;}}for (j = final; j >= low; j--) {vecTmp[j+1] = vecTmp[j];}vecTmp[low] = tmp;final++;}else{if (first == 0){first = siz - 1;vecTmp[siz-1] = tmp;}else{low = first;high = siz - 1;while (low <= high){mid = (low + high) / 2;if (tmp > vecTmp[mid]){low = mid + 1;}else{high = mid - 1;}}for (j = first; j <= high; j++){vecTmp[j-1] = vecTmp[j];}vecTmp[high] = tmp;first--;}}}for (i = 0,j = first; j < siz; i++,j++){v[i] = vecTmp[j];}for (k = 0; k <= final; k++){v[i++] = vecTmp[k];}}/******************************************************************** ****//* 希尔排序 *//*希尔排序的思想希尔排序属于插入方法的排序算法，可以说是插入排序算法的改进版本，它的想法是把数据分组，在分组内进行插入排序，以此类推，分组的大小跟数据量有关系，D. E. Knuth建议数据量很大时按3*n+1分组，例如100的数据时，可以取1，4，13，40。
*/template <class T>void shellSort(vector<T>& v){for (unsigned int count = (unsigned int)v.size()/2; count > 0; count /= 2){for(unsigned int group = 0; group < count; group++){for (unsigned int i = group; i < v.size(); i += count){T tmp = v[i];int j = i - count;while (j >=0 && v[j] > tmp){v[j+count] = v[j];j -= count;}v[j+count] = tmp;}}}}/******************************************************************** ****//******************************************************************** ****/#endif（2）交换排序：exchangeSort.h#ifndef __EXCHANGESORT_H__#define __EXCHANGESORT_H__/******************************************************************** ****//*常用头文件包含*/#include <algorithm>/*要用template<class Type> void swap(Type& _Left,Type& _Right);*/#include <vector>#include <math.h>using namespace std;/******************************************************************** ****//******************************************************************** ****//*交换排序的思想交换排序属于比较法的排序算法，它的想法是扫描整个数据，从第0个元素开始，跟以后的元素逐个比较，按照排序规则(从小到大或者从大到小)交换顺序，比较完第a后再去比较第a+1个元素，以此类推*//*函数实现，按从小到大排序*/template <class T>void exchageSort(vector<T>& v){for (unsigned int i = 0; i < v.size()-1; i++){for (unsigned int j = i + 1; j < v.size(); j++){if (v[i]>v[j]){swap(v[i],v[j]);}}}}/******************************************************************** ****//*冒泡排序的思想冒泡排序属于比较法的排序算法，它的想法是比较相邻的两个数据，按照排序规则(从小到大或者从大到小)交换顺序，再去比较下一组相邻元素，以此类推*//******************************************************************** ****//*函数实现，按从小到大排序*/template <class T>void bubbleSort(vector<T>& v){bool flag = true;for (unsigned int i = 0; (i < v.size()-1) && (flag); i++){flag = false;for (unsigned int j = 0; j < v.size() - i - 1; j++){if (v[j]>v[j+1]){swap(v[j],v[j+1]);flag = true;}}}}/******************************************************************** ****//******************************************************************** ****//*快速排序的思想快速排序的想法是尽可能的减少每次排序的数据量以提高效率，那么对于任意从数据中取出的数据，可以按照大小把比它小的放在它的左边，比它大的放在它的右边，那么这个数的位置就确定了，再在它的左右两边分别按此排序，这就是快速排序。