排序算法吗
❶ 几种常见的排序算法
for(i = 0; i < n; i++) for(j = 0; j < n - 1 - i; j++){if(arr[j] arr[j + 1]){arr[j] = arr[j] ^ arr[j+1]; arr[j+1] = arr[j] ^ arr[j+1]; arr[j] = arr[j] ^ arr[j+1];}}} 交换两个数据，可以用用临时变量，也可用以下的两个方法a = a^b;b = a^b;a = a^b;或者 a = a + b;b = a - b;a = a - b;// 选择排序 void SelectSort(int arr[], int n){int i, j;int min; for(i = 0; i < n - 1; i++){int index = 0; min = arr[i]; for(j = i + 1; j < n; j++) //找出 i+1 - n 无序区的最小者与arr[i]交换{if(arr[j] < min){min = arr[j];index = j;}}if(index != 0) //表明无序区有比arr[i]小的元素{arr[i] = arr[i]^arr[index]; arr[index] = arr[i]^arr[index]; arr[i] = arr[i]^arr[index];}}}感觉比冒泡法好多啦 //快速排序算法
❷ 关于排序算法
没有必要这么写，一般都不这么写的。
以下的程序已经改写，运行通过，运行截图中上例是原来的程序，第二次运行是改进后的程序运行的结果：
#include <stdio.h>
#define N 80
void fun(char s[], int n)
{
int i, j;
char ch;
for (i=0; i<n-1; i++)
for (j=i+1; j<n; j++)
if (s[i] < s[j])
{
ch = s[j];
s[j]=s[i];
s[i] = ch;
}
}
main()
{
int i = 0, strlen = 0;
char str[N];
printf(" Input a string: ");
gets(str);
while (str[i] != ' ')
{
strlen++;
i++;
}
fun(str, strlen);
printf(" ********* display string ********* ");
puts(str);
}
在程序算法不变的前提下，程序可以简化为：
#include <stdio.h>
#include <string.h>/*使用库函数*/
#define N 80
void fun(char s[])
{
int i, j,n;
char ch;
n=strlen(s);
for (i=0; i<n-1; i++)
for (j=i+1; j<n; j++)
if (s[i] < s[j])
{
ch = s[j];
s[j]=s[i];
s[i] = ch;
}
}
main()
{
int i = 0;
char str[N];
printf(" Input a string: ");
gets(str);
fun(str);
printf(" ********* display string ********* ");
puts(str);
}
❸ 排序算法
找网络，搞懂这几种方法的原理。自己动脑写。不要总是要别人解决。
❹ 最好的排序算法是什么算法呀
什么是最好？最快算是最好吗？
目前就所有的内部排序法中，公认的使用广泛的，是快速排序法，平均时间为 kn*lnn ，其中n为待排序序列中记录的个数，k为某个常数。
❺ 几种常用的排序算法比较
排序，从小大，0坐标的在下面，即排序后小的在下面，大的在上面。
1，冒泡Bubble：从第0个开始，一直往上，与相邻的元素比较，如果下面的大，则交换。
Analysis：
Implementation：
void BubbleSort(int *pData, int iNum)
2，插入Insertion：与打扑克牌时整理牌很想象，假定第一张牌是有序的，从第二张牌开始，拿出这张牌来，往下比较，如果有比这张牌大的，则把它拨到上一个位置，直到找到比手上的这张更小的（或到顶了），
则把手上的这张牌插入到这张更小的牌的后面。
Analysis：
Implementation：
void InsertionSort(int *list, int length)
{
int i, j, temp;
for (i = 1; i < length; i++)
{
temp = list[i];
j = i - 1;
while ((j >= 0) && (list[j] > temp))
{
list[j+1] = list[j];
j--;
}
list[j+1] = temp;
}
}
3，选择Selection：从所有元素中找到最小的放在0号位置，从其它元素（除了0号元素）中再找到最小的，放到1号位置，......。
Analysis：
Implementation：
void SelectionSort(int data[], int count)
{
int i, j, min, temp;
for (i = 0; i < count - 1; i++)
{
/* find the minimum */
min = i;
for (j = i+1; j < count; j++)
{
if (data[j] < data[min])
{
min = j;
}
}
/* swap data[i] and data[min] */
temp = data[i];
data[i] = data[min];
data[min] = temp;
}
}
4，快速Quick：先拿出中间的元素来（值保存到temp里），设置两个索引（index or pointer），一个从0号位置开始往最大位置寻找比temp大的元素；一个从最大号位置开始往最小位置寻找比temp小的元素，找到了或到顶了，则将两个索引所指向的元素
互换，如此一直寻找交换下去，直到两个索引交叉了位置，这个时候，从0号位置到第二个索引的所有元素就都比temp小，从第一个索引到最大位置的所有元素就都比temp大，这样就把所有元素分为了两块，然后采用前面的办法分别排序这两个部分。总的来
说，就是随机找一个元素（通常是中间的元素），然后把小的放在它的左边，大的放右边，对左右两边的数据继续采用同样的办法。只是为了节省空间，上面采用了左右交换的方法来达到目的。
Analysis：
Implementation：
void QuickSort(int *pData, int left, int right)
{
int i, j;
int middle, iTemp;
i = left;
j = right;
middle = pData[(left + right) / 2]; //求中间值
do
{
while ((pData[i] < middle) && (i < right)) //从左扫描大于中值的数
i++;
while ((pData[j] > middle) && (j > left)) //从右扫描小于中值的数
j--;
if (i <= j) //找到了一对值
{
//交换
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
i++;
j--;
}
} while (i <= j); //如果两边扫描的下标交错，就停止（完成一次）
//当左边部分有值(left<j)，递归左半边
if(left < j)
QuickSort(pData, left, j);
//当右边部分有值(right>i)，递归右半边
if(right > i)
QuickSort(pData, i, right);
}
5，希尔Shell：是对Insertion Sort的一种改进，在Insertion Sort中，从第2个位置开始取出数据，每次都是与前一个（step/gap==1）进行比较。Shell Sort修改为，在开始时采用较大的步长step，
从第step位置开始取数据，每次都与它的前step个位置上的数据进行比较（如果有8个数据，初始step==4，那么pos(4)与pos(0)比较，pos(0)与pos(-4)，pos(5)与pos(1)，pos(1)与pos(-3)，
...... pos(7)与pos(3)，pos(3)与pos(-1)），然后逐渐地减小step，直到step==1。step==1时，排序过程与Insertion Sort一样，但因为有前面的排序，这次排序将减少比较和交换的次数。
Shell Sort的时间复杂度与步长step的选择有很大的关系。Shell排序比冒泡排序快5倍，比插入排序大致快2倍。Shell排序比起QuickSort，MergeSort，HeapSort慢很多。但是它相对比较简单，它适合
于数据量在5000以下并且速度并不是特别重要的场合。它对于数据量较小的数列重复排序是非常好的。
Analysis：
Implementation：
template<typename RandomIter, typename Compare>
void ShellSort(RandomIter begin, RandomIter end, Compare cmp)
{
typedef typename std::iterator_traits<RandomIter>::value_type value_type;
typedef typename std::iterator_traits<RandomIter>::difference_type diff_t;
diff_t size = std::distance(begin, end);
diff_t step = size / 2;
while (step >= 1)
{
for (diff_t i = step; i < size; ++i)
{
value_type key = *(begin+i);
diff_t ins = i; // current position
while (ins >= step && cmp(key, *(begin+ins-step)))
{
*(begin+ins) = *(begin+ins-step);
ins -= step;
}
*(begin+ins) = key;
}
if(step == 2)
step = 1;
else
step = static_cast<diff_t>(step / 2.2);
}
}
template<typename RandomIter>
void ShellSort(RandomIter begin, RandomIter end)
{
typedef typename std::iterator_traits<RandomIter>::value_type value_type;
ShellSort(begin, end, std::less<value_type>());
}
6，归并Merge：先将所有数据分割成单个的元素，这个时候单个元素都是有序的，然后前后相邻的两个两两有序地合并，合并后的这两个数据再与后面的两个合并后的数据再次合并，充分前面的过程直到所有的数据都合并到一块。
通常在合并的时候需要分配新的内存。
Analysis：
Implementation：
void Merge(int array[], int low, int mid, int high)
{
int k;
int *temp = (int *) malloc((high-low+1) * sizeof(int)); //申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
int begin1 = low;
int end1 = mid;
int begin2 = mid + 1;
int end2 = high;
for (k = 0; begin1 <= end1 && begin2 <= end2; ++k) //比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
{
if(array[begin1]<=array[begin2])
{
temp[k] = array[begin1++];
}
else
{
temp[k] = array[begin2++];
}
}
if(begin1 <= end1) //若第一个序列有剩余，直接拷贝出来粘到合并序列尾
{
memcpy(temp+k, array+begin1, (end1-begin1+1)*sizeof(int));
}
if(begin2 <= end2) //若第二个序列有剩余，直接拷贝出来粘到合并序列尾
{
memcpy(temp+k, array+begin2, (end2-begin2+1)*sizeof(int));
}
memcpy(array+low, temp, (high-low+1)*sizeof(int));//将排序好的序列拷贝回数组中
free(temp);
}
void MergeSort(int array[], unsigned int first, unsigned int last)
{
int mid = 0;
if (first < last)
{
mid = (first+last)/2;
MergeSort(array, first, mid);
MergeSort(array, mid+1,last);
Merge(array,first,mid,last);
}
}
❻ 排序算法有多少种
排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列。
排序就是把集合中的元素按照一定的次序排序在一起。一般来说有升序排列和降序排列2种排序，在算法中有8中基本排序：
(1)冒泡排序；
(2)选择排序；
(3)插入排序；
(4)希尔排序；
(5)归并排序；
(6)快速排序；
(7)基数排序；
(8)堆排序；
(9)计数排序；
(10)桶排序。
插入排序
插入排序算法是基于某序列已经有序排列的情况下，通过一次插入一个元素的方式按照原有排序方式增加元素。这种比较是从该有序序列的最末端开始执行，即要插入序列中的元素最先和有序序列中最大的元素比较，若其大于该最大元素，则可直接插入最大元素的后面即可，否则再向前一位比较查找直至找到应该插入的位置为止。插入排序的基本思想是，每次将1个待排序的记录按其关键字大小插入到前面已经排好序的子序列中，寻找最适当的位置，直至全部记录插入完毕。执行过程中，若遇到和插入元素相等的位置，则将要插人的元素放在该相等元素的后面，因此插入该元素后并未改变原序列的前后顺序。我们认为插入排序也是一种稳定的排序方法。插入排序分直接插入排序、折半插入排序和希尔排序3类。
冒泡排序
冒泡排序算法是把较小的元素往前调或者把较大的元素往后调。这种方法主要是通过对相邻两个元素进行大小的比较，根据比较结果和算法规则对该二元素的位置进行交换，这样逐个依次进行比较和交换，就能达到排序目的。冒泡排序的基本思想是，首先将第1个和第2个记录的关键字比较大小，如果是逆序的，就将这两个记录进行交换，再对第2个和第3个记录的关键字进行比较，依次类推，重复进行上述计算，直至完成第(n一1)个和第n个记录的关键字之间的比较，此后，再按照上述过程进行第2次、第3次排序，直至整个序列有序为止。排序过程中要特别注意的是，当相邻两个元素大小一致时，这一步操作就不需要交换位置，因此也说明冒泡排序是一种严格的稳定排序算法，它不改变序列中相同元素之间的相对位置关系。
选择排序
选择排序算法的基本思路是为每一个位置选择当前最小的元素。选择排序的基本思想是，基于直接选择排序和堆排序这两种基本的简单排序方法。首先从第1个位置开始对全部元素进行选择，选出全部元素中最小的给该位置，再对第2个位置进行选择，在剩余元素中选择最小的给该位置即可；以此类推，重复进行“最小元素”的选择，直至完成第(n-1)个位置的元素选择，则第n个位置就只剩唯一的最大元素，此时不需再进行选择。使用这种排序时，要注意其中一个不同于冒泡法的细节。举例说明：序列58539．我们知道第一遍选择第1个元素“5”会和元素“3”交换，那么原序列中的两个相同元素“5”之间的前后相对顺序就发生了改变。因此，我们说选择排序不是稳定的排序算法，它在计算过程中会破坏稳定性。
快速排序
快速排序的基本思想是:通过一趟排序算法把所需要排序的序列的元素分割成两大块，其中，一部分的元素都要小于或等于另外一部分的序列元素，然后仍根据该种方法对划分后的这两块序列的元素分别再次实行快速排序算法，排序实现的整个过程可以是递归的来进行调用，最终能够实现将所需排序的无序序列元素变为一个有序的序列。
归并排序
归并排序算法就是把序列递归划分成为一个个短序列，以其中只有1个元素的直接序列或者只有2个元素的序列作为短序列的递归出口，再将全部有序的短序列按照一定的规则进行排序为长序列。归并排序融合了分治策略，即将含有n个记录的初始序列中的每个记录均视为长度为1的子序列，再将这n个子序列两两合并得到n/2个长度为2(当凡为奇数时会出现长度为l的情况)的有序子序列；将上述步骤重复操作，直至得到1个长度为n的有序长序列。需要注意的是，在进行元素比较和交换时，若两个元素大小相等则不必刻意交换位置，因此该算法不会破坏序列的稳定性，即归并排序也是稳定的排序算法。
❼ 几种排序算法的比较
一、八大排序算法的总体比较
4.3、堆的插入：
每次插入都是将新数据放在数组最后。可以发现从这个新数据的父结点到根结点必然为一个有序的数列，然后将这个新数据插入到这个有序数据中
（1）用大根堆排序的基本思想
先将初始数组建成一个大根堆，此对为初始的无序区；
再将最大的元素和无序区的最后一个记录交换，由此得到新的无序区和有序区，且满足<=的值；
由于交换后新的根可能违反堆性质，故将当前无序区调整为堆。然后再次将其中最大的元素和该区间的最后一个记录交换，由此得到新的无序区和有序区，且仍满足关系的值<=的值，同样要将其调整为堆；
..........
直到无序区只有一个元素为止；
4.4：应用
寻找M个数中的前K个最小的数并保持有序；
时间复杂度：O(K)[创建K个元素最大堆的时间复杂度] +（M-K）*log(K)[对剩余M-K个数据进行比较并每次对最大堆进行从新最大堆化]
5.希尔排序
（1）基本思想
先将整个待排序元素序列分割成若干子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序（因为直接插入排序在元素基本有序的情况下，效率很高）；
（2）适用场景
比较在希尔排序中是最主要的操作，而不是交换。用已知最好的步长序列的希尔排序比直接插入排序要快，甚至在小数组中比快速排序和堆排序还快，但在涉及大量数据时希尔排序还是不如快排；
6.归并排序
（1）基本思想
首先将初始序列的n个记录看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到n/2个长度为2的有序子序列，在此基础上，再对长度为2的有序子序列进行两两归并，得到若干个长度为4的有序子序列，以此类推，直到得到一个长度为n的有序序列为止；
（2）适用场景
若n较大，并且要求排序稳定，则可以选择归并排序；
7.简单选择排序
（1）基本思想
第一趟：从第一个记录开始，将后面n-1个记录进行比较，找到其中最小的记录和第一个记录进行交换；
第二趟：从第二个记录开始，将后面n-2个记录进行比较，找到其中最小的记录和第2个记录进行交换；
...........
第i趟：从第i个记录开始，将后面n-i个记录进行比较，找到其中最小的记录和第i个记录进行交换；
以此类推，经过n-1趟比较，将n-1个记录排到位，剩下一个最大记录直接排在最后；
❽ 几种常用排序算法
/** * @author txin0814 E-mail:[email protected] * @version 1.0 * @date Apr 1, 2011 2:28:06 PM * @description 排序类的 基类 */ public abstract class BaseSorter { public abstract void sort(E[] array,int from,int len); public final void sort(E[] array){ sort(array,0,array.length); } protected final void swap(E[] array,int from,int to){ E temp = array[from]; array[from] = array[to]; array[to] = temp; } } /** * @author txin0814 E-mail:[email protected] * @version 1.0 * @date Apr 1, 2011 2:34:47 PM * @description 插入排序 该算法在数据规模小的时候十分高效， * 该算法每次插入第K+1到前K个有序数组中一个合适位置， * K从0开始到N-1,从而完成排序 */ public class InsertSorter extends BaseSorter{ //当SORT_TYPE为false时按降序排列 为TRUE时按升序排列 public static boolean SORT_TYPE = false; @Override public void sort(E[] array, int from, int len) { E tmp=null; for(int i=from+1;ifrom;j--){ if(SORT_TYPE){ if(tmp.compareTo(array[j-1])0){ array[j]=array[j-1]; }else break; } } array[j]=tmp; } /*for (E e : array) { System.out.println(e); }*/ } public static void main(String[] args) { Integer[] elem = {32, 43, 1, 3, 54, 4, 19}; InsertSorter insertsort = new InsertSorter(); //InsertSorter.SORT_TYPE = true; insertsort.sort(elem); for (Integer integer : elem) { System.out.println(integer); } } } /** * @author txin0814 E-mail:[email protected] * @version 1.0 * @date Apr 1, 2011 2:53:29 PM * @description 冒泡排序 算法思想是每次从数组末端开始比较相邻两元素，把第i小的冒泡到数组的第i个位置。) */ public class BubbleSorter extends BaseSorter { //当SORT_TYPE为false时按降序排列 为TRUE时按升序排列 public static boolean SORT_TYPE = false; public final void bubble_down(E[] array, int from, int len) { for (int i = from; i < from + len; i++) { for (int j = from + len - 1; j > i; j--) { if (array[j].compareTo(array[j - 1]) > 0) { swap(array, j - 1, j); } } } } public final void bubble_up(E[] array, int from, int len) { for (int i = from + len - 1; i >= from; i--) { for (int j = from; j < i; j++) { if (array[j].compareTo(array[j + 1]) > 0) { swap(array, j + 1, j ); } } } } @Override public void sort(E[] array, int from, int len) { if (SORT_TYPE) { bubble_up(array, from, len); } else { bubble_down(array, from, len); } } public static void main(String[] args) { Integer[] elem = {32, 43, 1, 3, 54, 4, 19}; BubbleSorter bsort = new BubbleSorter(); //BubbleSorter.DWON = true; //bsort.sort(elem); //BubbleSorter.SORT_TYPE = true; bsort.sort(elem, 0, elem.length); for (Integer integer : elem) { System.out.println(integer); } } } /** * @author txin0814 E-mail:[email protected] * @version 1.0 * @date Apr 1, 2011 3:17:42 PM * @description 选择排序 选择排序相对于冒泡来说，它不是每次发现逆序都交换， * 而是在找到全局第i小的时候记下该元素位置，最后跟第i个元素交换，从而保证数组最终的有序。
❾ 各种排序算法
有插入排序，堆排序，快速排序，基排序，计数排序，桶排序，我说不完的，，详情参看《算法导论》