演算法：三種簡單排序演算法，三種排序演算法

演算法：三種簡單排序演算法，三種排序演算法

    排序演算法比較常見的有：冒泡排序、簡單選擇排序、直接插入排序；希爾排序、堆排序、歸併排序和快速排序演算法等。今天先學習一下前面三種比較簡單的演算法。排序的相關概念：

①排序的穩定性：兩個或多個元素相等，排序過後仍然是原來的順序則為穩定排序。

②內部排序：排序過程都在記憶體中進行；外部排序：需要對外存進行訪問的排序過程。

③內排序演算法效能因素：1、時間效能，比較與移動；2、輔助空間；3、演算法複雜性

執行個體：冒泡排序、簡單選擇排序與直接插入排序

#include "stdio.h"#define MAXSIZE 6int data[MAXSIZE] = {0,5,4,3,2,1};/**功能：數組元素交換*輸入：資料、交換元素的下標*輸出：無*/void swap(int data[],int i,int j){int temp = data[i];data[i] = data[j];data[j] = temp;}/**功能：冒泡排序*輸入：數組*輸出：無*演算法：迴圈一次，下標所在位置即為最小值，不斷地比較和移動*/void bubble1(int data[]){for(int i = 0; i < MAXSIZE-1; i++)  for(int j = i+1; j < MAXSIZE ; j++)if(data[j] < data[i])  swap(data,i,j);} /**功能：改進冒泡排序*輸入：數組*輸出：無*演算法：改進後的演算法除了關注當前最小值外，還可以順便移動其他較小值在前面*/void bubble2(int data[]){int flag = 1;  // 標誌位for(int i = 0; i < MAXSIZE-1 && flag; i++){flag = 0;  // 每次迴圈標誌位都賦為0for(int j = MAXSIZE - 1; j > i; j--)if(data[j] < data[j-1])  // 相鄰兩個元素之前的比較，而不是上面的演算法只關注最小值。{swap(data,j-1,j);flag = 1;  // 當有發生移動時，才賦為1，否則排序已經完成，無需多餘的比較。}}}/**功能：簡單選擇排序*輸入：數組*輸出：無*演算法：比較記錄最小值的下標，最後才移動，而非每次都比較後就移動*/void simple(int data[]){int min = 0;for(int i = 0; i < MAXSIZE-1; i++){min = i;  // 假設第一個下標為最小值for(int j = i+1; j < MAXSIZE; j++){if(data[j] < data[min])  // 當出現比第一個下標小的資料，記錄其下標min = j;}if(min != i)  // 如果最小值不是第一個下標才交換swap(data,min,i);}}/**功能：直接插入排序*輸入：數組*輸出：無*演算法：將資料插入到已經排好序的有序表中，得到記錄增1的有序表。*/void insertSort(int data[]){for(int i = 2; i < MAXSIZE; i++)  // 第一次迴圈，排序為data[1],data[2]兩個元素，data[0]是哨兵作用{if(data[i] < data[i-1])  // 如果data[2]比data[1]小，哨兵data[0]設為data[2]{data[0] = data[i];int j = i;while(data[j-1] > data[0])  // 當data[1] > data[0]時，將其右移即data[2] = data[1]{data[j] = data[j-1];j--;}data[j] = data[0];  // data[1] = data[0]，實現了data[1]和data[2]的交換，// 此時data[1]和data[2]即為排好序的有序表,開始第二次迴圈}}}void print(int *data){for(int i = 0; i < MAXSIZE; i++)printf("%d ",data[i]);printf("\n");}int main(int argc, char* argv[]){print(data);//bubble1(data);//bubble2(data);//simple(data);insertSort(data);print(data);}

    小結：三種簡單排序演算法的時間複雜性都是O(n^2)，都是穩定的排序。

簡單選擇排序演算法

#include<stdio.h>
typedef struct
{
int key;
}datatype;
void Select_Sort(datatype R[ ],int n)
{
int i,k,j;
for(i=1;i<n;i++)
{k=i;
for(j=i+1;j<=n;j++)
if(R[j].key<R[k].key)k=j;
}

if(i!=k)
{R[0]=R[k];
R[k]=R[i];
R[i]= R[0];
}
}

void main()
{
datatype r[5]={5,8,3,2,9};
Select_Sort(r,5);
}
 
常用的排序演算法都有什？

排序演算法 所謂排序，就是使一串記錄，按照其中的某個或某些關鍵字的大小，遞增或遞減的排列起來的操作。
分類
在電腦科學所使用的排序演算法通常被分類為：
計算的複雜度（最差、平均、和最好表現），依據串列（list）的大小（n）。一般而言，好的表現是O。(n log n)，且壞的行為是Ω(n2)。對於一個排序理想的表現是O(n)。僅使用一個抽象關鍵比較運算的排序演算法總平均上總是至少需要Ω(n log n)。
記憶體使用量（以及其他電腦資源的使用）
穩定度：穩定排序演算法會依照相等的關鍵（換言之就是值）維持紀錄的相對次序。也就是一個排序演算法是穩定的，就是當有兩個有相等關鍵的紀錄R和S，且在原本的串列中R出現在S之前，在排序過的串列中R也將會是在S之前。
一般的方法：插入、交換、選擇、合并等等。交換排序包含冒泡排序（bubble sort）和快速排序（quicksort）。選擇排序包含shaker排序和堆排序（heapsort）。
當相等的元素是無法分辨的，比如像是整數，穩定度並不是一個問題。然而，假設以下的數對將要以他們的第一個數字來排序。
(4, 1) (3, 1) (3, 7) (5, 6)
在這個狀況下，有可能產生兩種不同的結果，一個是依照相等的索引值維持相對的次序，而另外一個則沒有：
(3, 1) (3, 7) (4, 1) (5, 6) (維持次序)
(3, 7) (3, 1) (4, 1) (5, 6) (次序被改變)
不穩定排序演算法可能會在相等的索引值中改變紀錄的相對次序，但是穩定排序演算法從來不會如此。不穩定排序演算法可以被特別地時作為穩定。作這件事情的一個方式是人工擴充索引值的比較，如此在其他方面相同索引值的兩個物件間之比較，就會被決定使用在原先資料次序中的條目，當作一個同分決賽。然而，要記住這種次序通常牽涉到額外的空間負擔。
排列演算法列表
在這個表格中，n是要被排序的紀錄數量以及k是不同索引值的數量。
穩定的
冒泡排序（bubble sort） — O(n2)
雞尾酒排序 (Cocktail sort, 雙向的冒泡排序) — O(n2)
插入排序 （insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 額外 記憶體
計數排序 (counting sort) — O(n+k); 需要 O(n+k) 額外 記憶體
歸併排序 （merge sort）— O(n log n); 需要 O(n) 額外記憶體
原地歸併排序 — O(n2)
二叉樹排序 （Binary tree sort） — O(n log n); 需要 O(n) 額外記憶體
鴿巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 額外記憶體
基數排序 （radix sort）— O(n·k); 需要 O(n) 額外記憶體
Gnome sort — O(n2)
Library sort — O(n log n) with high probability, 需要 (1+ε)n 額外記憶體
不穩定
選擇排序 （selection sort）— O(n2)
希爾排序 （shell sort）— O(n log n) 如果使用最佳的現在版本
Comb sort — O(n log n)
堆排序 （heapsort）— O(n log n)
......餘下全文>>