数据结构中快速排序属于什么排序

❶ 数据结构的排序算法中，哪些排序是稳定的，哪些排序是不稳定的

一、稳定排序算法

1、冒泡排序

2、鸡尾酒排序

3、插入排序

4、桶排序

5、计数排序

6、合并排序

7、基数排序

8、二叉排序树排序

二、不稳定排序算法

1、选择排序

2、希尔排序

3、组合排序

4、堆排序

5、平滑排序

6、快速排序

排序(Sorting) 是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列。

一个排序算法是稳定的，就是当有两个相等记录的关键字R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。

不稳定排序算法可能会在相等的键值中改变纪录的相对次序，但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地实现为稳定。

做这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个对象间之比较，就会被决定使用在原先数据次序中的条目，当作一个同分决赛。然而，要记住这种次序通常牵涉到额外的空间负担。

(1)数据结构中快速排序属于什么排序扩展阅读：

排序算法的分类：

1、通过时间复杂度分类

计算的复杂度（最差、平均、和最好性能），依据列表(list)的大小(n)。

一般而言，好的性能是 O(nlogn)，且坏的性能是 O(n^2)。对于一个排序理想的性能是 O(n)。

而仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要 O(nlogn)。

2、通过空间复杂度分类

存储器使用量（空间复杂度）（以及其他电脑资源的使用）

3、通过稳定性分类

稳定的排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。

❷ 数据结构中哪种排序方式效率最好

简单排序的算法（直接插入，冒泡，简单选择排序）简单且稳定，适合与待排记录较小的情况，当当待排序的关键码序列已经基本有序时，用直接插入排序最快。
就平均时间的性能而言，快速排序最佳，即排序速度最快，所以在随机情况下，快速排序是最佳选择。一般情况下，快速排序效率最好。
既要节省空间，又要有较快的排序速度，堆排序是最佳选择，其不足之处是建堆时需要消耗较多时间。
若希望排序是稳定的，且有较快的排序速度，则可选用2路归并排序，其缺点需要较大的辅助空间分配。

❸ 数据结构中常见的排序方式都有哪些比如冒泡排序，快速排序等。每种排序具体是怎么排的

1.直接插入：就是有一个已经排好的子序列，它是有序的。然后来一个插入一个仍是这个序列有序。比如a1本身就是有序的。a2来了，要和a1比较，a2大就插在a1之后，小就在a1之前，那么a1、a2就是新的有序子序列，然后a3来了，又要插入进来，逐个与a2、a1比较插在它的适当位置再次形成子序列，就按这样一步步进行，知道最后一个插入时，以前的都已经有序了。
2.希尔排序：由于有时候数据量大，用直接插入就不太合适。于是把你的一组待排序数据按如8、4、2、1的一组增量数来分组，即第一次，a1和a9和a17甚至还有更多间隔为八的数分为一组进行直接插入排序，第二次则是新的a1和a5、a9、a13……依次知道最后比较数据之间的间隔数为1，每次都进行插入排序
3.直接选择：n个数逐个比较，谁大的谁放最后（n的位置），比较范围减一；然后又从n-1个数中找最大的，又放最后（n-1的位置），依次这样进行就可以。
4.冒泡：比较的时候如果前者比后者大就要进行值的交换。那么最大的每次都会沉到底下。比较范围减一。
5、快速排序：要采用分划控制。比较复杂。

❹ 数据结构中有几种排序

在数据机构中有插入排序、选择排序、交换排序、归并排序和基数排序

❺ 数据结构里的快速排序怎样理解谁知道

快速排序法的基本精神是在数列中找出适当的轴心，然後将数列一分为二，分别对左边与右边数列进行排序，而影响快速排序法效率的正是轴心的选择。

❻ 数据结构中快速排序的窍门是什么啊，谢谢

冒泡排序是最简单排序算法,时间复杂度为n的平方,代码如下:
function bubbleSort(array) {
for (var i = 0; i < array.length; i++) {
for (var j = array.length; j > 0; j--) {
if (array[j] < array[j - 1]) {
var temp = array[j - 1];
array[j - 1] = array[j];
array[j] = temp;
}

}
/* 输出结果 */
document.write("这是第 + (i + 1) + "次循环·，结果为:");
for (var k = 0; k < array.length; k++) {
document.write(array[k] + ",");
}
document.write("<br />");
/* 输出结果结束 */
}
}

直接插入排序
直接插入排序也属于简单排序算法,时间复杂度也为n的平方，但性能略好于冒泡排序，代码如下:
function insertSort(array) {
var temp;
for (var i = 1; i < array.length; i++) {
var temp = array[i];
for (var j = i; j > 0 && temp < array[j - 1]; j--) {
array[j] = array[j - 1];
}
array[j] = temp
/* 输出结果 */
document.write("第? + i + "遍排序的结果是:")
for (var n = 0; n < array.length; n++) {
document.write(array[n] + ",");
}

document.write("<br />")
/* 输出结果结束 */

}
}

选择排序
选择排序也属于简单排序算法，时间复杂度也为n的平方，性能同样略微好于冒泡排序，代码如下:
function selectSort(array) {
var min, temp; ;
for (var i = 0; i < array.length; i++) {
min = i;
for (var j = i + 1; j < array.length; j++) {
if (array[min] > array[j])
min = j;
}
if (min != i) {
temp = array[i];
array[i] = array[min];
array[min] = temp;
}
/* 输出结果 */
document.write("第 + i + "遍排序的结果是:")
for (var n = 0; n < array.length; n++) {
document.write(array[n] + ",");
}

document.write("<br />")
/* 输出结果结束 */

}
}

复杂排序

希尔排序
希尔排序是插入排序的升级，1959年希尔通过将简单排序中两两比较改为设置步长跳跃式比较而突破了n的平方的时间复杂度,希尔排序根据步长的不同时间复杂度由最好的nlogn到最坏的n的平方。代码如下:
function shallSort(array) {
var increment = array.length;
var i
var temp; //暂存
var count = 0;
do {
increment = Math.floor(increment / 3) + 1;
for (i = increment; i < array.length; i++) {
if (array[i] < array[i - increment]) {
temp = array[i];
for (var j = i - increment; j > 0 && temp < array[j]; j -= increment) {

array[j + increment] = array[j];

}
array[j + increment] = temp;
/* 输出结果 */
count++;
document.write("<br />第 + count + "遍排序的结果是:")
for (var n = 0; n < array.length; n++) {
document.write(array[n] + ",");
}
/* 输出结果结束 */
}
}
}
while (increment > 1)

}

堆排序
堆排序是选择排序的升级，通过不断构建大顶堆或者小顶堆来选择最大或者最小的值放入队列前端进行排序，堆排序任何情况下的时间复杂度都为nlogn，代码如下:
function heapSort(array) {
var temp;
var i;
for (i = Math.floor(array.length / 2); i >= 0; i--) {
heapAdjust(array, i, array.length - 1); //将数组array构建成一个大顶堆
}
for (i = array.length - 1; i >= 0; i--) {
/*把根节点交换出去*/
temp = array[i];
array[i] = array[0];
array[0] = temp;

/*余下的数组继续构建成大顶堆*/
heapAdjust(array, 0, i - 1);
/* 输出结果 */
document.write("<br />第 + (array.length - i).toString() + "遍排序的结果是:")
for (var n = 0; n < array.length; n++) {
document.write(array[n] + ",");
}
/* 输出结果结束 */
}
}
//要调整的子树
//start为数组开始下标
//max是数组结束下标
function heapAdjust(array, start, max) {
var temp, j;
temp = array[start];//temp是根节点的值
for (j = 2 * start; j < max; j *= 2) {
if (j < max && array[j] < array[j + 1]) { //取得较大孩子的下标
++j;

}
if (temp >= array[j])
break;
array[start] = array[j];
start = j;
}
array[start] = temp;

}

归并排序
归并排序是复杂排序中唯一一个稳定排序，通过将待排序数组进行分拆再合并来进行排序，归并排序时间复杂度为n的平方，代码如下:
//source源数组
//dest目标数组
//s起始下标
//t目标下标
function mSort(source, dest, s, t) {
var m; //取中间值
var dest2 = new Array();
if (s == t) {
dest[s] = source[s];

}
else {
m = Math.floor((s + t) / 2);
mSort(source, dest2, s, m);
mSort(source, dest2, m+1 , t);
merge(dest2, dest, s, m, t);
/* 输出结果 */
document.write("<br />第 + ++count + "遍排序的结果是:")
for (var n = 0; n < dest.length; n++) {
document.write(array[n] + ",");
}
/* 输出结果结束 */
}

}

//将两个数组按照从小到大的顺序融合
//source原数组
//dest排序后的数组
//s第一个下标
//m第二个数组下标
//总长度
function merge(source, dest, s, m, n) {
for (var j = m+1, k = s; j <= n && s <= m; k++) {
if (source[s] < source[j]) {
dest[k] = source[s++];
}
else {
dest[k] = source[j++];
}
}

//将剩余排不完的有序数组加入到dest的末端
if (s <= m) {
for (var l = 0; l <= m - s; l++) {
dest[k + l] = source[s+l];
}
}
if (j <= n) {
for (var l = 0; l <= n - j; l++) {
dest[k + l] = source[j+l];
}

}
}

快速排序
快速排序是目前已知的速度最快的排序，时间复杂度为nlogn,代码如下:
var count = 0;
function quickSort(array, low, high) {
var temp;

if (low < high) {

var keypoint = QuickSortHelp(array, low, high);
count++;
document.write("<br />第台? + count + "遍括?排?序ò的?结á果?是?:")
for (var l = 0; l < array.length; l++) {
document.write(array[l] + ",");
}
quickSort(array, low, keypoint - 1);
quickSort(array, keypoint + 1, high);

}
}
function QuickSortHelp(array, low, high) {
while (low < high) {

while (low < high && array[low] <= array[high]) {
high--;
}
temp = array[low];
array[low] = array[high];
array[high] = temp;
while (low < high && array[low] <= array[high]) {
low++
}
temp = array[low];
array[low] = array[high];
array[high] = temp;

}
return low;
}

❼ 数据结构里的冒泡排序和快速排序

冒泡排序：
public static void sort(Array array){
for( int i=0;i<array.length;i++){
for(int j=array.length-1;j>i;j--){
int temp=j;
j=i;
i=temp;

}

}

}

❽ 谁能举个例子解释一下，什么是快速排序，冒泡排序，直接插入排序，堆序法thx

快速排序：quicksort: 找数组中一个数，把比他大的放到左边，比他小的放到右边，然后用递归排他左右边的，直到排完，复杂度O（nlgn）。
4,2,1,6，5.开始选4-2，1，4，6，5，再在2，1里选2-1，2，在6，5里选6-5，6 这样就完了1，2，4，5，6.

冒泡排序： bubblesort：简单的方法，从第一个数开始，依次和后面比较，比后面大就往后移动，直到排完，举例： 5，1，2，3，4. 先看5-1，5，2，3，4-1，2，5，3，4-1，2，3，5，4-1，2，3，4，5.这例子特殊，一下排完，事实上复杂度为O（n*n）；
插入排序： insertion sort： 简单的方法，和打牌时排序一样，复杂度O（n*n）
1，3，2，4，7，5-1，2，3，4，7，5-1，2，3，4，5，7.

堆： heapsort： 和树比较像，有根大枝小或根小枝大的特点，很难讲明白，时间复杂度为O（n*lgn）

建议看《算法导论》，或《programming pearls》 很清楚。

❾ 快速排序特点

快速排序（Quicksort）是对冒泡排序的一种改进，由东尼·霍尔在1960年提出。 快速排序是指通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序。整个排序过程可以递归进行，以此达到整个数据变成有序序列。

分类
排序算法

数据结构
不定

最坏空间复杂度
根据实现的方式不同而不同
快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。

步骤为：

从数列中挑出一个元素，称为“基准”（pivot），

重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

在简单的伪代码中，此算法可以被表示为：

function quicksort(q)
{
var list less, pivotList, greater
if length(q) ≤ 1
return q
else
{
select a pivot value pivot from q
for each x in q except the pivot element
{
if x<pivot then add x to less
if x ≥ pivot then add x to greater
}
add pivot to pivotList
return concatenate(quicksort(less), pivotList, quicksort(greater))
}
}
原地（in-place）分区的版本

上面简单版本的缺点是，它需要的额外存储空间，也就跟归并排序一样不好。额外需要的存储器空间配置，在实际上的实现，也会极度影响速度和缓存的性能。有一个比较复杂使用原地（in-place）分区算法的版本，且在好的基准选择上，平均可以达到空间的使用复杂度。

function partition(a, left, right, pivotIndex)
{
pivotValue = a[pivotIndex]
swap(a[pivotIndex], a[right]) // 把pivot移到结尾
storeIndex = left
for i from left to right-1
{
if a[i]<= pivotValue
{
swap(a[storeIndex], a[i])
storeIndex = storeIndex + 1
}
}
swap(a[right], a[storeIndex]) // 把pivot移到它最後的地方
return storeIndex
}
这是原地分区算法，它分区了标示为"左边（left）"和"右边（right）"的序列部分，借由移动小于的所有元素到子序列的开头，留下所有大于或等于的元素接在他们后面。在这个过程它也为基准元素找寻最后摆放的位置，也就是它回传的值。它暂时地把基准元素移到子序列的结尾，而不会被前述方式影响到。由于算法只使用交换，因此最后的数列与原先的数列拥有一样的元素。要注意的是，一个元素在到达它的最后位置前，可能会被交换很多次。

一旦我们有了这个分区算法，要写快速排列本身就很容易：

procere quicksort(a, left, right)
if right>left
select a pivot value a[pivotIndex]
pivotNewIndex := partition(a, left, right, pivotIndex)
quicksort(a, left, pivotNewIndex-1)
quicksort(a, pivotNewIndex+1, right)
这个版本经常会被使用在命令式语言中，像是C语言。

快速排序
快速排序是二叉查找树（二叉搜索树）的一个空间最优化版本。不是循序地把数据项插入到一个明确的树中，而是由快速排序组织这些数据项到一个由递归调用所隐含的树中。这两个算法完全地产生相同的比较次数，但是顺序不同。对于排序算法的稳定性指标，原地分区版本的快速排序算法是不稳定的。其他变种是可以通过牺牲性能和空间来维护稳定性的。