c语言快速排序算法,C语言大牛推荐七大排序算法学生来看

c语言快速排序算法,C语言大牛推荐七大排序算法学生来看详细介绍

本文目录一览： 用C语言编程实现快速排序算法

1冒泡排序 选择排序 合并排序 插入排序 （他们是原地排序）2堆排序3快速排序4线性时间排序,分为:计数排序 基数排序 桶排序排序是可以相互渗透的，比如在选择排序中用2分的思想各种排序的思想、算法、运行时间及其期望空的话，可以问问我~
给个快速排序你参考参考 /********************** 快速排序 ****************************基本思想：在待排序的n个记录中任取一个记录（通常取第一个记录）， 以该记录为基准，将当前的无序区划分为左右两个较小的无 序子区，使左边的记录均小于基准值，右边的记录均大于或 等于基准值，基准值位于两个无序区的中间位置（即该记录 最终的排序位置）。之后，分别对两个无序区进行上述的划 分过程，直到无序区所有记录都排序完毕。*************************************************************//*************************************************************函数名称：static void swap(int *a, int *b)参 数：int *a---整型指针 int *b---整型指针功 能：交换两个整数的位置返 回 值：无说 明：static关键字指明了该函数只能在本文件中使用**************************************************************/static void swap(int *a, int *b){ int temp = *a; *a = *b; *b = temp;}int quickSortNum = 0; // 快速排序算法所需的趟数/*************************************************************函数名称：static int partition(int a[], int low, int high)参 数：int a[]---待排序的数据 int low---无序区的下限值 int high---无序区的上限值功 能：完成一趟快速排序返 回 值：基准值的最终排序位置说 明：static关键字指明了该函数只能在本文件中使用**************************************************************/static int partition(int a[], int low, int high){ int privotKey = a[low]; //基准元素 while(low < high) { //从表的两端交替地向中间扫描 while(low < high && a[high] >= privotKey) // 找到第一个小于privotKey的值 high--; //从high所指位置向前搜索，至多到low+1位置 swap(&a[low], &a[high]); // 将比基准元素小的交换到低端 while(low < high && a[low] <= privotKey) // 找到第一个大于privotKey的值 low++; //从low所指位置向后搜索，至多到high-1位置 swap(&a[low], &a[high]); // 将比基准元素大的交换到高端 } quickSortNum++; // 快速排序趟数加1 return low; // 返回基准值所在的位置} /*************************************************************函数名称：void QuickSort(int a[], int low, int high)参 数：int a[]---待排序的数据 int low---无序区的下限值 int high---无序区的上限值功 能：完成快速排序算法，并将排序完成的数据存放在数组a中返 回 值：无说 明：使用递归方式完成**************************************************************/void QuickSort(int a[], int low, int high){ if(low < high) { int privotLoc = partition(a, low, high); // 将表一分为二 QuickSort(a, low, privotLoc-1); // 递归对低子表递归排序 QuickSort(a, privotLoc+1, high); // 递归对高子表递归排序 } }

C语言的快速排序的算法是什么啊？

就是一种算法， 算法的时间复杂度为 nlgn。 是一种排序速度很快的算法， 同时也是不稳定排序算法！
你说的可能是除了冒泡法的方法吧应该是这样的 Array.Sort（数组名）// 把数组升序 Array.Reverse（数组名） //把数组的顺序颠倒 还望采纳
快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 算法过程　　设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。 　　一趟快速排序的算法是： 　　1）设置两个变量I、J，排序开始的时候：I=0，J=N-1； 　　2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]； 　　3）从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key的值A[J]，并与key交换； 　　4）从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key的A[I]，与key交换； 　　5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后另循环结束。) 　　例如：待排序的数组A的值分别是：（初始关键数据：X=49） 注意关键X永远不变，永远是和X进行比较，无论在什么位子，最后的目的就是把X放在中间，小的放前面大的放后面。 　　A[0] A[1] A[2] A[3] A[4] A[5] A[6]： 　　49 38 65 97 76 13 27 　　进行第一次交换后：27 38 65 97 76 13 49 　　( 按照算法的第三步从后面开始找) 　　进行第二次交换后：27 38 49 97 76 13 65 　　( 按照算法的第四步从前面开始找>X的值，65>49,两者交换，此时：I=3 ) 　　进行第三次交换后：27 38 13 97 76 49 65 　　( 按照算法的第五步将又一次执行算法的第三步从后开始找 　　进行第四次交换后：27 38 13 49 76 97 65 　　( 按照算法的第四步从前面开始找大于X的值，97>49,两者交换，此时：I=4,J=6 ) 　　此时再执行第三步的时候就发现I=J，从而结束一趟快速排序，那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所有大于49的数全部在49的后面，所有小于49的数全部在49的前面。 　　快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示： 　　初始状态 {49 38 65 97 76 13 27} 　　进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65} 　　分别对前后两部分进行快速排序 {27 38 13} 经第三步和第四步交换后变成 {13 27 38} 完成排序。 　　{76 97 65} 经第三步和第四步交换后变成 {65 76 97} 完成排序。 　　

快速排序算法c语言

排序算法是《数据结构与算法》中最基本的算法之一。
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：

点击以下图片查看大图：

关于时间复杂度 平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。
线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；
O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序
线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。
关于稳定性
稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。
不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。
名词解释：
n：数据规模 k："桶"的个数 In-place：占用常数内存，不占用额外内存 Out-place：占用额外内存 稳定性：排序后 2 个相等键值的顺序和排序之前它们的顺序相同 包含以下内容：
1、冒泡排序 2、选择排序 3、插入排序 4、希尔排序 5、归并排序 6、快速排序 7、堆排序 8、计数排序 9、桶排序 10、基数排序 排序算法包含的相关内容具体如下：
冒泡排序算法
冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。
选择排序算法
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n?) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间。
插入排序算法
插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
希尔排序算法
希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。
归并排序算法
归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。
快速排序算法
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
堆排序算法
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。
计数排序算法
计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
桶排序算法
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。
基数排序算法
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

C语言，快速排序算法

0和N-1表示的是数组下标。快排每一趟排序的目的是使值比设定的key值小的数都排到数组前部分，大的都排到后部分；然后对这两部分用新的关键值key分别重复上一步的操作；递归，直到数组有序。其中关键值key=a[low]。用题目给定的数组模拟第一趟排序如下：下标 0 1 2 3 4 5 6 7 8 9值 9 16 47 82 4 66 12 3 25 51low=0 high=9part_element=a[low]=9进入for循环进入第一个whilepart_element<51，于是high--,high=8;part_element<25，high--,high=7;part_element>3,不满足，结束whilea[low]=a[0]=a[high]=a[7]=3,low++,low=1;进入第二个whilepart_element<16,不满足，结束whilea[high]=a[7]=a[low]=a[1]=16,high--,high=6for第一个循环结束，数组如下3 16 47 82 4 66 12 16 25 51low=1,high=6for第二个循环同上，结束时数组如下3 4 47 82 47 66 12 16 25 51low=2,high=3for第三个循环，第一个while中high--以后，low==high，直接break跳出for循环，此时3 4 47 82 47 66 12 16 25 51low=2,high=2结束for以后a[high]=a[2]=part_element=9,得到3 4 9 82 47 66 12 16 25 51split函数return high=2quicksort函数中middle=2;下面两句递归，仍然是调用split函数，对数组0-2,3-9两部分分别重复上述操作最后直到数组数据有序
你好！首先 0 ，n-1 。应该是 数组的坐标（因为n个数字。所以数组的坐标是0 到n-1）而a是你传入的数组。所以他会根据数组的坐标到数组中找到元素。比较并进行排序。递归这段理解如下：首先要了解快速排序的思想：1）随意找一个基准数 。将比基准小的都放到它左边。比它大的都放到它右边。所以当返回基准的坐标的时候。其实这个坐标左边都是小于它的，右边都是大于等于它的。（这里主要是看代码的实现。图中代码是大于等于在右边。也可以自己写小于等于在左边。这个不影响最后结果）2）那么第二次对于返回基准坐标的左右两边。我们同样利用返回的基准坐标找到两个“基准”（如下图）。就会使得返回的这两个基准左右两边有序第三次 用返回的两个基准找到四个基准（如图）然后不断递归..不断的在整体有序的情况下使局部变的有序。假设 为 532348789第一次以a【0】 5为基准 。则：
图中红色标识为基准元素 最后会使得数组全局有序。希望能对你有所帮助。

数据结构C语言--三种以上的排序算法

百度百科上有。
排序：http://baike.baidu.com/view/58783.htm?fr=ala0_1
快排：http://baike.baidu.com/view/115472.htm
... ...
快速排序：
void QSort(int a[], int l, int r) //单关键字交换法快排
{
int i = l, j = r, mid = (i + j) / 2; //二分[i,j]区间
while (i <= j) //让a[mid]左边都比a[mid]小，右边都比a[mid]大
{
while (a[i] < a[mid]) //找到一个元素a[i]比a[mid]小
i++;
while (a[j] > a[mid]) //找到一个元素a[j]比a[mid]大
j--;
if (i <= j) //交换a[i]和a[j]，并让指针向中间靠拢
Swap(a[i++], a[j--]);
}
if (i < r)
QSort(a, i, r); //对右区间[i,r]递归排序
if (l < j)
QSort(a, l, j); //对左区间[l,j]递归排序
}
归并排序：
void Merge(int a[], int l, int m, int r) //将a中区间[l, r]合并为有序
{
int x[101], y[101]; //循环变量
int i, j, k;
int l1 = m - l + 1, l2 = r - m; //l1表示区间[l, m]的长度，l2表示区间[m + 1, r]的长度
for (i = 1; i <= l1; i++) //将a中区间[l, m]复制到x中
{
x[i] = a[l + i - 1];
}
for (i = 1; i <= l2; i++) //将a中区间[m + 1, r]复制到y中
{
y[i] = a[m + i];
}
x[l1 + 1] = MaxInt; //设置一个很大的数作为结束标志
y[l2 + 1] = MaxInt;
i = 1;
j = 1;
for (k = l; k <= r; k++) //将两个区间合并成为一个有序区间
{
if (x[i] <= y[j])
{
a[k] = x[i++];
}
else
{
a[k] = y[j++];
}
}
}
void MergeSort(int a[], int l, int r) //对a数组的[l, r]区间排序
{
int m;
if (l < r)
{
m = (l + r) / 2; //二分区间[l, r]
MergeSort(a, l, m); //递归二分区间[l, m]
MergeSort(a, m + 1, r); //递归二分区间[m + 1, r]
Merge(a, l, m, r); //合并区间[l, m]和[m + 1, r]
}
}
二叉排序树排序：
struct BinaryTree //二叉树结构
{
int data, p, l, r; //data数值域，p父节点编号，l左儿子编号，r右儿子编号
};
int root = 0;
void Init(BinaryTree a[], int &n) //读入数据域，并初始化树
{
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> a[i].data;
a[i].p = a[i].l = a[i].r = -1;
}
}

void Insert(BinaryTree a[], int i) //在二叉查找树中插入编号为 i 的节点
{
int parent = -1, x = a[1].p; //parent 始终指向 x 的父节点编号
while (x != -1) //向下搜索，直到找到最下一层
{
parent = x;
if (a[i].data < a[x].data)
x = a[x].l;
else
x = a[x].r;
}
a[i].p = parent; //把第 i 号节点的父亲指向parent
if (parent != -1) //判断树是否为空
{
if (a[i].data < a[parent].data) //向父节点插入儿子
a[parent].l = i;
else
a[parent].r = i;
}
else //为空就以 i 节点为根节点
a[root].p = i;
}
void BuildTree(BinaryTree a[], int n) //建立二叉查找树
{
root = 1;
for (int i = 1; i <= n; i++) //依次插入 n 个节点到二叉查找树
{
Insert(a, i);
}
a[root].p = -1;
}
void Sort(BinaryTree a[], int i) //中序遍历输出
{
if (a[i].l > -1) //递归遍历左儿子
Sort(a, a[i].l);
cout << a[i].data << " "; //输出节点
if (a[i].r > -1) //递归遍历右儿子
Sort(a, a[i].r);
}
堆排序：
void Heap(int a[], int n, int p) //维护最大（最小）堆，维护以P为根的堆
{
int l = p * 2, r = l + 1, t = p; //左儿子编号为2P，右儿子为2P+1，初始化根节点P为最大
if ((l <= n) && (a[l] > a[p])) //找一个最大的数，维护最大堆（改为
<就是维护最小堆）
t = l;

if ((r <= n) && (a[r] > a[t])) //找一个最大的数，维护最大堆（改为
<就是维护最小堆）
t = r;

if (p != t) //如果根节点不是最大，和最大的交换，再递归维护堆

{

Swap(a[p], a[t]);

Heap(a, n, t);

}

}

void HeapSort(int a[], int n)

{

int i;

for (i = n / 2; i >= 1; i--) //n / 2开始必然是根节点，依次调用Heap，建立一个最大堆

Heap(a, n, i);

for (i = n; i >= 2; i--) //每次将堆顶和当前堆最后一个节点(i)交换，然后将[1, i - 1]重新堆化

{

Swap(a[i], a[1]);

Heap(a, i - 1, 1);

}

}

插入排序：

void InsertionSort(int a[], int l, int r) //对区间[l, r]执行插入排序

{

int i, j, t;

for (i = l + 1; i <= r; i++)

{

j = i - 1;

t = a[i];

while ((j >= l) && (a[j] > t)) //后移操作，并找到正确的位置

{

a[j + 1] = a[j];

j--;

}

a[j + 1] = t;

}

}

以上所有的Swap函数的意思都是交换两个变量。
</就是维护最小堆）
</就是维护最小堆）

快速排序算法

void QSort(SeqList L,int low,int high）改成void QSort(SeqList &L,int low,int high），加个&。
假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。
1、设置两个变量I、J，排序开始的时候I：=1，J：=N；
2、以第一个数组元素作为关键数据，赋值给X，即X：=A[1]；
3、从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换；
4、从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换；
5、重复第3、4步，直到I=J。
原理
设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它左边，所有比它大的数都放到它右边，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
快速排序（Quicksort）是对冒泡排序的一种改进。
然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。
快速排序算法通过多次比较和交换来实现排序，其排序流程如下：
(1)首先设定一个分界值，通过该分界值将数组分成左右两部分。
(2)将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。

C语言大牛推荐七大排序算法学生来看

C语言7种排序算法附代码
1.冒泡排序
比较相邻的元素。如果第一个比第二个大，就交换它们两个对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数:针对所有的元素重复以上的步骤，除了最后一个;重复步骤1~3，直到排序完成。
2.选择排序
在未排席序列中找到最小(大)元素，存放到排序序列的起始位置从剩余未排序元素中继续寻找最小(大)元素，然后放到已排序序列的末,以此类推，直到所有元素均排序完毕
3.插入排序
从第一个元素开始，该元素可以认为已经被排序;
取出下一个元素，在已经排序的元素序列中从后向前扫描:如果该元素(已排序)大于新元素，将该元素移到下一位置;
4.快速排序
快速排序的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
5.希尔排序
选择一个增量序列t1,t2,"”,tk，其中ti>tj,tk=1;按增量席列个数k，对序列进行k 趟排序;
6.桶排序
设置一个定量的数组当作空桶子
寻访序列，并且把项目一个一个放到对应的桶子去。
对每个不是空的桶子进行排序。
7.基数排序
取得数组中的最大数，并取得位数:
arr为原始数组，从最低位开始取每个位组成radix数组;对radix进行计数排序(利用计数排序适用于小范围数的特点)从不是空的桶子里把项目再放回原来的序列中

快速排序算法c语言

quick明显有问题，1.存在死循环2.使用递归是想实现什么？
如果想实现快速排序的话可以参考一下程序段，尽量精简交换操作增加排序速度:
void quick(int *arr, int len){ int i, j,k,z; for (i = 0; i < len - 1; i++) { for (j = 0,k=0; j < len - i - 1; j++) { if (arr[k] < arr[j + 1]) k = j + 1; } if (k != len - i - 1) { z = arr[len - i - 1]; arr[len - i - 1] = arr[k]; arr[k] = z; } }}

菜鸟提问 c语言关于快速排序

R[j]^=R[i];
R[i]^=R[j];
R[j]^=R[i];
你的代码里面R[i]^，R[j]^从何而来？不理解，不好改。
快速排序作为c语言中速度最快的一种排序，肯定能处理数字相同的情况，而且快速排序肯定是用递归算法。你的问题是算法，这里有个带注释的快速排序，win-tc和Dev-c++下运行通过。
#include

#include

#define MAX 255

int R[MAX];

int Partition(int i,int j)

{/* 调用Partition(low，high)时，对R[low..high]做划分，*/

/* 并返回基准记录的位置 */

int pivot=R[i]; /* 用区间的第1个记录作为基准 */

while(i
<j)
{ /* 从区间两端交替向中间扫描，直至i=j为止 */

while(i

=pivot) /* pivot相当于在位置i上 */

j--; /* 从右向左扫描，查找第1个关键字小于pivot.key的记录R[j] */

if(i
<j) * 表示找到的r[j]的关键字<pivot.key
R[i++]=R[j]; /* 相当于交换R[i]和R[j]，交换后i指针加1 */

while(i
<j&&r[i]<=pivot) * pivot相当于在位置j上*
i++; /* 从左向右扫描，查找第1个关键字大于pivot.key的记录R[i] */

if(i

pivot.key */

R[j--]=R[i]; /* 相当于交换R[i]和R[j]，交换后j指针减1 */

}

R[i]=pivot; /* 基准记录已被最后定位*/

return i;

}

void Quick_Sort(int low,int high) /* 对R[low..high]快速排序 */

{ int pivotpos; /* 划分后的基准记录的位置 */

if(low
<high)
{/* 仅当区间长度大于1时才须排序 */

pivotpos=Partition(low,high); /* 对R[low..high]做划分 */

Quick_Sort(low,pivotpos-1); /* 对左区间递归排序 */

Quick_Sort(pivotpos+1,high); /* 对右区间递归排序 */

}

}

main()

{int i,n;

clrscr();

puts("Please input total element number of the sequence:");

scanf("%d",&n);

if(n<=0||n>MAX)

{ printf("n must more than 0 and less than %d.\n",MAX);

exit(0);

}

puts("Please input the elements one by one:");

for(i=1;i<=n;i++)

scanf("%d",&R[i]);

puts("The sequence you input is:");

for(i=1;i<=n;i++)

printf("%4d",R[i]);

Quick_Sort(1,n);

puts("\nThe sequence after quick_sort is:");

for(i=1;i<=n;i++)

printf("%4d",R[i]);

puts("\n Press any key to quit...");

getch();

}

#include

#include

void swap(int &a,int &b){ //交换两个数

int temp=a;

a=b;

b=temp;

}

void quicksort(int R[],int s,int t)

{

int i=s,j=t;

int temp;

if(s
<t)
{

temp=R[s];

while(i
<j) while(i!="j)
{

while(j>i && R[j]>=temp) //改成等号

j--;

while(i
<j && r[i]<="temp)
i++;

swap(R[i],R[j]); //交换,你是想交换吧，虽然可以通过异或交换，但难以理解.

}

R[s]=R[i]; //增加的，交换中间数和第一个数

R[i]=temp;

quicksort(R,s,i-1);

quicksort(R,i+1,t);

}

}

int main()

{

int i;

int a[]={5,3,2,1,9,8,7,4,5};

int n = sizeof(a)/sizeof(int);

quicksort(a,0,n-1);

for(i=0;i
<n;i++)
printf("%d ",*(a+i));

// system("pause");

return 1;

}

R[j]^=R[i];

R[i]^=R[j];

R[j]^=R[i];

就是交换R[i]和R[j]

其实，最想说明的是那段交换的代码

R[j]^=R[i];

R[i]^=R[j];

R[j]^=R[i];

一定要排除 i==j 的情况。即自己与自己交换的情况。

如：

a=9;

a^=a;/*a=0*/

a^=a;/*a=0*/

a^=a;/*a=0*/

a就不再是10了。

#include

#include

void quicksort(int R[],int s,int t)

{

int i,j;

int temp;

if(s
<t)
{

temp=R[s];/*选第一个数作为参照*/

/*while(i!=j)不要用这种方法判定循环结束，万一i==j-1，i++，j--后 i〉j了，！=这个条件就救不了你了*/

for(i=s+1,j=t;i<=j;i++,j--)/*不包括参照数，进行左右阵营站队*/

{

while(j>i && R[j]>=temp)/*R[j]>=temp不要 = 也行，加了更好，毕竟相等的无论站左站右，哪边都无所谓*/

j--;

while(i
<j && r[i]<="temp)
i++;

if(i!=j){/*i千万不能等于j*/

R[j]^=R[i];

R[i]^=R[j];

R[j]^=R[i];

}

}

i--;

if(R[s]
<r[i])i--; *调整i的值，使i指向最后一个小于等于参照数的位置*
/*将参照数 与 最后一个小于等于参照数的数进行交换，这样就真正把左右两个阵营分开了*/

R[s]=R[i];

R[i]=temp;

quicksort(R,s,i-1);

quicksort(R,i+1,t);

}

}

int main(void)

{

int i;

int a[]={5,3,2,1,9,8,7,4,5};

quicksort(a,0,sizeof(a)/sizeof(int)-1);

for(i=0;i
<sizeof(a) sizeof(int);i++)
printf("%d ",*(a+i));

return 0;

}

</t)

</n;i++)

</t)

</j&&r[i]

</j)