排序演算法分為內部排序和外部排序，我們經常說的排序演算法就是內部排序

內部排序：資料記錄在記憶體中進行排序

外部排序：排序的資料很大，一次性不能容納全部的排序記錄，在排序的過程中需要訪問外存

穩定排序演算法：相同的元素位置沒有被改變

我們將要了解的排序演算法如下：

交換排序：氣泡排序（可以是穩定，可以是不穩定），快速排序（不穩定）

選擇排序：簡單選擇排序（不穩定），堆排序

插入排序：直接插入排序，希爾排序

歸併排序

現在我們先來了解一下我們交換排序中的氣泡排序演算法

氣泡排序

思想：

1. 比較相鄰的元素，如果前一個比後一個大，就把它們兩個調換位置。
2. 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。
3. 針對所有的元素重複以上的步驟，除了最後一個。
4. 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

程式碼如下：

 1 #include<stdio.h>
 2 int a[5];
 3 void swap(int a[],int i,int j)
 4 {
 5     int t=a[i];
 6     a[i]=a[j];
 7     a[j]=t;
 8 }
 9 void Bubblesort(int a[],int n)
10 {
11     int i,j;
12     for(i=0;i<n;i++)
13     {
14         for
 
(j=i;j<n;j++)
15         {
16             if(a[i]>a[j])
17             {
18                 swap(a,i,j);
19             }
20         }
21     }
22 }
23 int main()
24 {
25     int i;
26     for(i=0;i<5;i++)
27     {
28         scanf("%d",&a[i]);
29     }
30     Bubblesort(a,5);
31     for(i=0
 
;i<5;i++)
32     {
33         printf("%d\n",a[i]);
34     }
35     return 0;
36 }

氣泡排序是最容易瞭解和掌握的排序演算法，但是對於多元素的資料排序是沒有效率的，但是氣泡排序也是可以改進的，下面我們看看氣泡排序的改進演算法——雞尾酒排序

此演算法與氣泡排序演算法的不同在於從上到下又從下到上，而氣泡排序僅僅是從上到下

下面我們看看雞尾酒排序的演算法

 1 #include<stdio.h>
 2 int a[5];
 3 void swap(int a[],int i,int j)
 4 {
 5     int t=a[i];
 6     a[i]=a[j];
 7     a[j]=t;
 8 }
 9 void Bubblesort(int a[],int n)
10 {
11     int i;
12     int l=0,r=n-1;
13     while(l<r)
14     {
15         for(i=l;i<r;i++)
16         {
17             if(a[i]>a[i+1])//max,down將最大值放到底部
18             {
19                 swap(a,i,i+1);
20             }
21         }
22         r--;//因為是放到底部所以是r--
23         for(i=r;i>l;i--)
24         {
25             if(a[i-1]>a[i])//min up將最小值放到頂部
26             {
27                 swap(a,i-1,i);
28             }
29         }
30         l++;//放到底部，所以l++
31     }
32 }
33 int main()
34 {
35     int i;
36     for(i=0;i<5;i++)
37     {
38         scanf("%d",&a[i]);
39     }
40     Bubblesort(a,5);
41     for(i=0;i<5;i++)
42     {
43         printf("%d\n",a[i]);
44     }
45     return 0;
46 }

下面我們看看交換排序中的快速排序

快速排序：

思想：

快速排序主要運用的是遞迴的思想

快速排序採用分冶法將一個序列分為兩個子序列

1.從序列中挑取一個元素作為基準元素

2.把所有比基準小的元素放基準元素的前面，把比基準元素大的放基準元素的後面，相同的可以方任意一邊，這個操作叫做分割槽操作

3.對每個分割槽遞迴進行操作1，2，遞迴結束的條件是序列大小為0或者1。

程式碼如下：

 1 #include<stdio.h>
 2 #define p 10
 3 int a[p];
 4 void swap(int a[],int i,int j)
 5 {
 6     int t=a[i];
 7     a[i]=a[j];
 8     a[j]=t;
 9 }
10 int Divide(int a[],int l,int r)//劃分序列
11 {
12     int benchmark=a[r];//確定基準元素
13     int tail=l-1;//初始化
14     int i;
15     for(i=l;i<r;i++)//遍歷除了基準元素以外的全部元素
16     {
17         if(a[i]<=benchmark)//把小於基準元素的放左邊
18         {
19             swap(a,++tail,i);
20         }
21     }
22     swap(a,tail+1,r);//把基準元素放到所有比基準元素小的元素後邊
23     return tail+1;//返回索引
24 }
25 void Quicksort(int a[],int l,int r)
26 {
27     if(l>=r)//存在序列大小為0或者為1
28         return;
29     int index=Divide(a,l,r);//第一次初始化劃分序列，且確定基準元素
30     Quicksort(a,l,index-1);
31     Quicksort(a,index+1,r);
32 }
33 int main()
34 {
35     int i;
36     for(i=0;i<p;i++)
37     {
38         scanf("%d",&a[i]);
39     }
40     Quicksort(a,0,p-1);
41     for(i=0;i<p;i++)
42     {
43         printf("%d\n",a[i]);
44     }
45     return 0;
46 }

下面我們來看看選擇排序，先看看選擇排序中的簡單的選擇排序

簡單選擇排序：

思想:

簡單選擇排序就是遍歷元素，找到當且元素最大或者最小的拿出來，放到自己陣列頭部，後面找到的陣列放陣列第1位，2位，以此類推，然後遍歷範圍減1，一直迴圈下去，直到遍歷範圍為1

但是我們要注意簡單選擇排序和氣泡排序的區別：氣泡排序是相鄰的兩個元素交換，而選擇排序則不是

話不多說，下面我們直接看程式碼：

 1 #include<stdio.h>
 2 #define p 10
 3 int a[p];
 4 void swap(int a[],int i,int j)
 5 {
 6     int t=a[i];
 7     a[i]=a[j];
 8     a[j]=t;
 9 }
10 void selectsort(int a[],int n)
11 {
12     int i,j,min;
13     for(i=0;i<n;i++)
14     {
15         min=i;//假定最小元素的位置
16         for(j=i+1;j<n;j++)//遍歷最小元素後面的元素，找到第最小元素的位置
17         {
18             if(a[min]>a[j])
19             {
20                 min=j;
21             }
22         }
23         if(min!=i)//交換
24         {
25             swap(a,min,i);
26         }
27     }
28 }
29 int main()
30 {
31     int i;
32     for(i=0;i<p;i++)
33     {
34         scanf("%d",&a[i]);
35     }
36     selectsort(a,p);
37     for(i=0;i<p;i++)
38     {
39         printf("%d\n",a[i]);
40     }
41     return 0;
42 }

下面我們來看看選擇排序中的堆排序：

堆排序：

堆排序要藉助於堆這種資料結構，主要分兩步走，第一步是構造初始堆，第二個輸出堆頂元素之後堆怎麼調整

我們以大定堆為例：要求其中父節點的值總是大於子節點

 1 #include<stdio.h>
 2 #define p 10
 3 int a[p];
 4 void swap(int a[],int i,int j)
 5 {
 6     int t=a[i];
 7     a[i]=a[j];
 8     a[j]=t;
 9 }
10 int Adjustment(int a[],int i,int size)//堆的調整
11 {
12     int left_child=2*i+1;
13     int right_child=2*i+2;//確定左右孩子位置
14     int max=i;//若孩子大於父親，則交換
15     if(left_child<size&&a[left_child]>a[max])
16         max=left_child;
17     if(right_child<size&&a[right_child]>a[max])
18         max=right_child;
19     if(max!=i)
20     {
21         swap(a,max,i);
22         Adjustment(a,max,size);
23     }
24 }
25 int BuildHeap(int a,int n)
26 {
27     int size=n;
28     int i;
29     for(i=size/2-1;i>=0;i--)//建立最大堆
30     {
31         Adjustment(a,i,size);
32     }
33     return size;
34 }
35 void Heapsort(int a,int n)//堆排序演算法
36 {
37     int size=BuildHeap(a,n);
38     while(size>1)
39     {
40         swap(a,0,--size);//將堆頂元素與最末尾的元素進行交換，升序排列
41         Adjustment(a,0,size);
42     }
43 }
44 int main()
45 {
46     int i;
47     for(i=0;i<p;i++)
48     {
49         scanf("%d",&a[i]);
50     }
51     Heapsort(a,p);
52     for(i=0;i<p;i++)
53     {
54         printf("%d\n",a[i]);
55     }
56     return 0;
57 }