數據結構的排序演算法
『壹』 數據結構的排序演算法中，哪些排序是穩定的，哪些排序是不穩定的
快速排序、希爾排序、堆排序、直接選擇排序不是穩定的排序演算法。
基數排序、冒泡排序、直接插入排序、折半插入排序、歸並排序是穩定的排序演算法。
『貳』 數據結構C語言--三種以上的排序演算法
快速排序：
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函數的意思都是交換兩個變數。
『叄』 數據結構中比較各種排序演算法 求詳解 ，，，，，，，，，，
排序演算法包括：插入排序、交換排序、選擇排序以及合並排序。
其中插入排序包括直接插入排序和Shell排序，交換排序包括冒泡排序和分化交換排序，選擇排序包括直接選擇排序和堆排序。
這些排序演算法中，直接插入排序、冒泡排序和直接選擇排序這三種排序的演算法平均時間復雜度是O(n的平方)；分化交換排序、堆排序和合並排序這三種排序的演算法平均時間復雜度是
『肆』 數據結構中有哪些基本演算法
數據結構中最基本的演算法有：查找、排序、快速排序，堆排序，歸並排序，，二分搜索演算法
等等。
1、用的最多也是最簡單的數據結構是線性表。
2、有前途的又難數據結構是圖 。
3、常用的80％演算法是排序和查找。
『伍』 數據結構的排序演算法中，哪些排序是穩定的，哪些排序是不穩定的
一、穩定排序演算法
1、冒泡排序
2、雞尾酒排序
3、插入排序
4、桶排序
5、計數排序
6、合並排序
7、基數排序
8、二叉排序樹排序
二、不穩定排序演算法
1、選擇排序
2、希爾排序
3、組合排序
4、堆排序
5、平滑排序
6、快速排序
排序(Sorting) 是計算機程序設計中的一種重要操作，它的功能是將一個數據元素（或記錄）的任意序列，重新排列成一個關鍵字有序的序列。
一個排序演算法是穩定的，就是當有兩個相等記錄的關鍵字R和S，且在原本的列表中R出現在S之前，在排序過的列表中R也將會是在S之前。
不穩定排序演算法可能會在相等的鍵值中改變紀錄的相對次序，但是穩定排序演算法從來不會如此。不穩定排序演算法可以被特別地實現為穩定。
做這件事情的一個方式是人工擴充鍵值的比較，如此在其他方面相同鍵值的兩個對象間之比較，就會被決定使用在原先數據次序中的條目，當作一個同分決賽。然而，要記住這種次序通常牽涉到額外的空間負擔。
(5)數據結構的排序演算法擴展閱讀：
排序演算法的分類：
1、通過時間復雜度分類
計算的復雜度（最差、平均、和最好性能），依據列表(list)的大小(n)。
一般而言，好的性能是 O(nlogn)，且壞的性能是 O(n^2)。對於一個排序理想的性能是 O(n)。
而僅使用一個抽象關鍵比較運算的排序演算法總平均上總是至少需要 O(nlogn)。
2、通過空間復雜度分類
存儲器使用量（空間復雜度）（以及其他電腦資源的使用）
3、通過穩定性分類
穩定的排序演算法會依照相等的關鍵（換言之就是值）維持紀錄的相對次序。
『陸』 數據結構的排序方法有哪些
冒泡排序，快速排序，堆排序。
『柒』 數據結構排序演算法有哪些常用的
最常用的是快速排序，基數排序，計數排序，歸並排序，堆排序，（偶爾還有插入排序）
都有各自的應用，快排就是單純的快，但是特殊數據下復雜度會退化
基數排序可以配合一些特定的演算法，譬如後綴數組的構建
計數排序簡單且常用，通常排序值域小但是數據量大的情況
歸並直接用來排序並不多，但是可以用來求解一些其他問題，本身的思想也非常重要，有很多拓展的演算法（不是排序演算法）
堆排序勝在穩定，不論數據如何最壞都是O(nlogn)，一般情況比快速排序慢些，但是極端情況下表現十分優秀，常用來配合快速排序，優化其穩定性
插入排序適合極少量數據的排序（幾個到十幾個），速度要比這些高級演算法快一些