2. 程式人生 > >九大排序演算法-C語言實現及詳解

九大排序演算法-C語言實現及詳解

阿新 • • 發佈：2019-01-08

概述

排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。

我們這裡說說八大排序就是內部排序。


    當n較大，則應採用時間複雜度為O(nlog2n)的排序方法：快速排序、堆排序或歸併排序序。

   快速排序：是目前基於比較的內部排序中被認為是最好的方法，當待排序的關鍵字是隨機分佈時，快速排序的平均時間最短；

1.插入排序—直接插入排序(Straight Insertion Sort)

基本思想:

將一個記錄插入到已排序好的有序表中，從而得到一個新，記錄數增1的有序表。即：先將序列的第1個記錄看成是一個有序的子序列，然後從第2個記錄逐個進行插入，直至整個序列有序為止。

要點：設立哨兵，作為臨時儲存和判斷陣列邊界之用。

直接插入排序示例：


如果碰見一個和插入元素相等的，那麼插入元素把想插入的元素放在相等元素的後面。所以，相等元素的前後順序沒有改變，從原無序序列出去的順序就是排好序後的順序，所以插入排序是穩定的。

演算法的實現：

//直接插入排序：將第一個資料看做一個順序表，將後面的資料一次插入表中
void InsertSort(int a[], int n)  
{  
    for(int i= 1; i<n; i++){  
        if(a[i] < a[i-1]){               //若第i個元素大於i-1元素，直接插入。小於的話，移動有序表後插入  
            int j= i-1;   //表中最後一個數據
            int x = a[i];        //複製為哨兵，即儲存待排序元素  
            a[i] = a[i-1];           //先後移一個元素 (因為a[i]就是X，所以不怕丟失) 
            while(j>=0 && x < a[j]){  //查詢在有序表的插入位置  (遍歷表)
                a[j+1] = a[j];  
                j--;         //元素後移  
            }  
            a[j+1] = x;      //插入到正確位置  
        }  
    }  
      
} 
int main()
{
	int n;
	cin>>n;
	int *a=new int[n];
	for(int j=0;j<n;j++)
		cin>>a[j];
	InsertSort(a,n);
	for(int i=0;i<n;i++)
		cout<<a[i];
	delete []a;
}

效率：

時間複雜度：O（n^2）.

其他的插入排序有二分插入排序，2-路插入排序。

 2. 插入排序—折半插入排序(二分插入)

將有序數列折半，看看插入到哪個序列中去 
//折半插入
void BInsertSort(int a[], int n)  
{  
    for(int i= 1; i<n; i++){  
		int low=0,high=i;
        if(a[i] < a[i-1]){               //若第i個元素大於i-1元素，直接插入。小於的話，移動有序表後插入  
            int x = a[i];        //複製為哨兵，即儲存待排序元素  
            a[i] = a[i-1];           //先後移一個元素 (因為a[i]就是X，所以不怕丟失) 
            while(low<=high){  //查詢在有序表的插入位置  (遍歷表)
                int m=(low+high)/2;
				if(x<a[m])  high=m-1;
				else low=m+1;
            }  
			for(int j=i-1;j>=high+1;j--)
				a[j+1]=a[j];
            a[j+1] = x;      //插入到正確位置  
        }  
    }  
      
} 
int main()
{
	int n;
	cin>>n;
	int *a=new int[n];
	for(int j=0;j<n;j++)
		cin>>a[j];
	BInsertSort(a,n);
	for(int i=0;i<n;i++)
		cout<<a[i];
	delete []a;
}

 3. 插入排序—希爾排序（Shell`s Sort）

希爾排序是1959 年由D.L.Shell 提出來的，相對直接排序有較大的改進。希爾排序又叫縮小增量排序

基本思想：

先將整個待排序的記錄序列分割成為若干子序列分別進行直接插入排序，待整個序列中的記錄“基本有序”時，再對全體記錄進行依次直接插入排序。

操作方法：

  1. 選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  2. 按增量序列個數k，對序列進行k 趟排序；
  3. 每趟排序，根據對應的增量ti，將待排序列分割成若干長度為m 的子序列，分別對各子表進行直接插入排序。僅增量因子為1 時，整個序列作為一個表來處理，表長度即為整個序列的長度。

希爾排序的示例：

演算法實現：

我們簡單處理增量序列：增量序列d = {n/2 ,n/4, n/8 .....1} n為要排序數的個數

即：先將要排序的一組記錄按某個增量d（n/2,n為要排序數的個數）分成若干組子序列，每組中記錄的下標相差d.對每組中全部元素進行直接插入排序，然後再用一個較小的增量（d/2）對它進行分組，在每組中再進行直接插入排序。繼續不斷縮小增量直至為1，最後使用直接插入排序完成排序。

//希爾排序：去增量為d1的分為一組，共分成d1組分別進行插入排序，然後每組對應元素放在一起，然後取d2...知道d=1
void ShellSort(int a[],int n)
{
	int dk;
	int tmp;
	for(dk=n/2;dk>0;dk/=2)
		for(int i=dk;i<n;i++)
		{
			tmp=a[i];
			for(int j=i;j>=dk;j-=dk)
				if(tmp<a[j-dk])
					a[j]=a[j-dk];
				else break;
			a[j]=tmp;
		}
}
int main()
{
	int n;
	cin>>n;
	int *a=new int[n];
	for(int j=0;j<n;j++)
		cin>>a[j];
	ShellSort(a,n);
	for(int i=0;i<n;i++)
		cout<<a[i];
	delete []a;
}
希爾排序時效分析很難，關鍵碼的比較次數與記錄移動次數依賴於增量因子序列d的選取，特定情況下可以準確估算出關鍵碼的比較次數和記錄的移動次數。目前還沒有人給出選取最好的增量因子序列的方法。增量因子序列可以有各種取法，有取奇數的，也有取質數的，但需要注意：增量因子中除1 外沒有公因子，且最後一個增量因子必須為1。希爾排序方法是一個不穩定的排序方法。

4. 選擇排序—簡單選擇排序（Simple Selection Sort）

基本思想：

在要排序的一組數中，選出最小（或者最大）的一個數與第1個位置的數交換；然後在剩下的數當中再找最小（或者最大）的與第2個位置的數交換，依次類推，直到第n-1個元素（倒數第二個數）和第n個元素（最後一個數）比較為止。

簡單選擇排序的示例：

 

操作方法：

第一趟，從n 個記錄中找出關鍵碼最小的記錄與第一個記錄交換；

第二趟，從第二個記錄開始的n-1 個記錄中再選出關鍵碼最小的記錄與第二個記錄交換；

以此類推.....

第i 趟，則從第i 個記錄開始的n-i+1 個記錄中選出關鍵碼最小的記錄與第i 個記錄交換，

直到整個序列按關鍵碼有序。


演算法實現：

//簡單選擇排序：遍歷一次找到最小與第一個元素呼喚位置，再從第二個元素開始遍歷找到最小與第二個元素呼喚位置...
void SelectSort(int a[],int n)
{
	for(int i=0;i<n-1;i++)
	{
		int k=i;//記錄最小的那個下標的
		for(int j=i+1;j<n;j++)
			if(a[j]<a[k])
				k=j;
		if(k!=i)
		{
			int t=a[i];
			a[i]=a[k];
			a[k]=t;
		}

	}
}
int main()
{
	int n;
	cin>>n;
	int *a=new int[n];
	for(int j=0;j<n;j++)
		cin>>a[j];
	SelectSort(a,n);
	for(int i=0;i<n;i++)
		cout<<a[i];
	delete []a;
}

 簡單選擇排序的改進——二元選擇排序（有bug）

簡單選擇排序，每趟迴圈只能確定一個元素排序後的定位。我們可以考慮改進為每趟迴圈確定兩個元素（當前趟最大和最小記錄）的位置,從而減少排序所需的迴圈次數。改進後對n個數據進行排序，最多隻需進行[n/2]趟迴圈即可。具體實現如下：

  1. void SelectSort(int r[],int n) {  
  2.     int i ,j , min ,max, tmp;  
  3.     for (i=1 ;i <= n/2;i++) {    
  4.         // 做不超過n/2趟選擇排序 
  5.         min = i; max = i ; //分別記錄最大和最小關鍵字記錄位置
  6.         for (j= i+1; j<= n-i; j++) {  
  7.             if (r[j] > r[max]) {   
  8.                 max = j ; continue ;   
  9.             }    
  10.             if (r[j]< r[min]) {   
  11.                 min = j ;   
  12.             }     
  13.       }    
  14.       //該交換操作還可分情況討論以提高效率
  15.       tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;  
  16.       tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;   
  17.     }   
  18. }  

5. 選擇排序—堆排序（Heap Sort）

堆排序是一種樹形選擇排序，是對直接選擇排序的有效改進。

基本思想：

堆的定義如下：具有n個元素的序列（k1,k2,...,kn),當且僅當滿足


時稱之為堆。由堆的定義可以看出，堆頂元素（即第一個元素）必為最小項（小頂堆）。
若以一維陣列儲存一個堆，則堆對應一棵完全二叉樹，且所有非葉結點的值均不大於(或不小於)其子女的值，根結點（堆頂元素）的值是最小(或最大)的。如：

（a）大頂堆序列：（96, 83,27,38,11,09)

  (b)  小頂堆序列：（12，36，24，85，47，30，53，91）


初始時把要排序的n個數的序列看作是一棵順序儲存的二叉樹（一維陣列儲存二叉樹），調整它們的儲存序，使之成為一個堆，將堆頂元素輸出，得到n 個元素中最小(或最大)的元素，這時堆的根節點的數最小（或者最大）。然後對前面(n-1)個元素重新調整使之成為堆，輸出堆頂元素，得到n 個元素中次小(或次大)的元素。依此類推，直到只有兩個節點的堆，並對它們作交換，最後得到有n個節點的有序序列。稱這個過程為堆排序。

因此，實現堆排序需解決兩個問題：
1. 如何將n 個待排序的數建成堆；
2. 輸出堆頂元素後，怎樣調整剩餘n-1 個元素，使其成為一個新堆。


首先討論第二個問題：輸出堆頂元素後，對剩餘n-1元素重新建成堆的調整過程。
調整小頂堆的方法：

1）設有m 個元素的堆，輸出堆頂元素後，剩下m-1 個元素。將堆底元素送入堆頂（（最後一個元素與堆頂進行交換），堆被破壞，其原因僅是根結點不滿足堆的性質。

2）將根結點與左、右子樹中較小元素的進行交換。

3）若與左子樹交換：如果左子樹堆被破壞，即左子樹的根結點不滿足堆的性質，則重複方法 （2）.

4）若與右子樹交換，如果右子樹堆被破壞，即右子樹的根結點不滿足堆的性質。則重複方法 （2）.

5）繼續對不滿足堆性質的子樹進行上述交換操作，直到葉子結點，堆被建成。

稱這個自根結點到葉子結點的調整過程為篩選。如圖：



再討論對n 個元素初始建堆的過程。
建堆方法：對初始序列建堆的過程，就是一個反覆進行篩選的過程。

1）n 個結點的完全二叉樹，則最後一個結點是第個結點的子樹。

2）篩選從第個結點為根的子樹開始，該子樹成為堆。

3）之後向前依次對各結點為根的子樹進行篩選，使之成為堆，直到根結點。

如圖建堆初始過程：無序序列：（49，38，65，97，76，13，27，49）
                              


                              

 演算法的實現：

從演算法描述來看，堆排序需要兩個過程，一是建立堆，二是堆頂與堆的最後一個元素交換位置。所以堆排序有兩個函式組成。一是建堆的滲透函式，二是反覆呼叫滲透函式實現排序的函式。

//堆排序:樹形選擇排序，將帶排序記錄看成完整的二叉樹，第一步：建立初堆，第二步：調整堆
//第二步：調整堆
void HeapAdjust(int a[],int s,int n)
{
	//調整為小根堆，從小到大
	int rc=a[s];
	for(int j=2*s;j<=n;j*=2)
	{
		if(j<n && a[j]>a[j+1])//判斷左右子數大小
			j++;
		if(rc<=a[j])
			break;
		a[s]=a[j];
		s=j;
	}
	a[s]=rc;
}
//第一步：建初堆
void CreatHeap(int a[],int n)
{
	//小根堆
	for(int i=n/2;i>0;i--)
		HeapAdjust(a,i,n);
}
//整合
void HeapSort(int a[],int n)
{
	CreatHeap(a,n);//第一步，建立初堆
	for(int i=n;i>1;i--)
	{
		int x=a[1];//堆頂與最後一個元素互換
		a[1]=a[i];
		a[i]=x;
		HeapAdjust(a,1,i-1);
	}

}
int main()
{
	int n;
	cin>>n;
	int *a=new int[n+1];
	for(int j=1;j<n;j++)//注意：這裡是從1開始的
		cin>>a[j];
	HeapSort(a,n);
	for(int i=1;i<n;i++)
		cout<<a[i];
	delete []a;
}

分析:

設樹深度為k，。從根到葉的篩選，元素比較次數至多2(k-1)次，交換記錄至多k 次。所以，在建好堆後，排序過程中的篩選次數不超過下式： 

                                

而建堆時的比較次數不超過4n 次，因此堆排序最壞情況下，時間複雜度也為：O(nlogn )。

6. 交換排序—氣泡排序（Bubble Sort）

基本思想：

在要排序的一組數中，對當前還未排好序的範圍內的全部數，自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的數比較後發現它們的排序與排序要求相反時，就將它們互換。

氣泡排序的示例：

 

演算法的實現：

//傳統氣泡排序
void maopao(int a[],int n)
{
	for(int i=0;i<n-1;i++)
		for(int j=0;j<n-i-1;j++)
			if(a[j]>a[j+1])
			{
				int t=a[j];
				a[j]=a[j+1];
				a[j+1]=t;
			}
}
int main()
{
	int n;
	cin>>n;
	int *a=new int[n];
	for(int j=0;j<n;j++)
		cin>>a[j];
	maopao(a,n);
	for(int i=0;i<n;i++)
		cout<<a[i];
	delete []a;
}

氣泡排序演算法的改進

對氣泡排序常見的改進方法是加入一標誌性變數exchange，用於標誌某一趟排序過程中是否有資料交換，如果進行某一趟排序時並沒有進行資料交換，則說明資料已經按要求排列好，可立即結束排序，避免不必要的比較過程。本文再提供以下兩種改進演算法：

1．設定一標誌性變數pos,用於記錄每趟排序中最後一次進行交換的位置。由於pos位置之後的記錄均已交換到位,故在進行下一趟排序時只要掃描到pos位置即可。

改進後演算法如下:

//氣泡排序改進1，新增標誌位，如果某一次排序中出現沒有交換位置，說明排序完成
void maopao(int a[],int n)
{
	int flag=0;
	for(int i=0;i<n-1;i++)
	{
		flag=0;
		for(int j=0;j<n-i-1;j++)
			if(a[j]>a[j+1])
			{
				int t=a[j];
				a[j]=a[j+1];
				a[j+1]=t;
				flag=1;
			}
		if(flag==0)
			break;
	}
}
int main()
{
	int n;
	cin>>n;
	int *a=new int[n];
	for(int j=0;j<n;j++)
		cin>>a[j];
	maopao(a,n);
	for(int i=0;i<n;i++)
		cout<<a[i];
	delete []a;
}

2．改進後的演算法實現為:

//氣泡排序改進2，新增標誌位，記錄最後一次交換位置的地方，證明最後一次交換位置之後的地方時排好序的，下一次只需要排最後一次之前的地方就好了
void maopao(int a[],int n)
{
	int flag=n-1;//剛開始，最後交換位置的地方設定為陣列的最後一位
	while(flag>0)//flag在逐漸減小，到最後肯定會變為0
	{
		int pos=0;//每一輪的最開始，標誌位置在陣列0
		for(int i=0;i<flag;i++)
			if(a[i]>a[i+1])
			{
				int t=a[i];
				a[i]=a[i+1];
				a[i+1]=t;
				pos=i;
			}
		flag=pos;	
	}
}
int main()
{
	int n;
	cin>>n;
	int *a=new int[n];
	for(int j=0;j<n;j++)
		cin>>a[j];
	maopao(a,n);
	for(int i=0;i<n;i++)
		cout<<a[i];
	delete []a;
}

3．傳統氣泡排序中每一趟排序操作只能找到一個最大值或最小值,我們考慮利用在每趟排序中進行正向和反向兩遍冒泡的方法一次可以得到兩個最終值(最大者和最小者) , 從而使排序趟數幾乎減少了一半。

改進後的演算法實現為:

//冒泡改進3，傳統冒泡每趟排序遍歷一次找到一個最大值或者最小值，如果每趟遍歷兩次就會找打一個最大值和一個最小值，減少了一半的排序趟數
void maopao ( int r[], int n){  
    int low = 0;   
    int high= n -1; //設定變數的初始值  
    int tmp,j;  
    while (low < high) {  
        for (j= low; j< high; ++j) //正向冒泡,找到最大者  
            if (r[j]> r[j+1]) {  
                tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;  
            }   
        --high;                 //修改high值, 前移一位  
        for ( j=high; j>low; --j) //反向冒泡,找到最小者  
            if (r[j]<r[j-1]) {  
                tmp = r[j]; r[j]=r[j-1];r[j-1]=tmp;  
            }  
        ++low;                  //修改low值,後移一位  
    }   
} 
int main()
{
	int n;
	cin>>n;
	int *a=new int[n];
	for(int j=0;j<n;j++)
		cin>>a[j];
	maopao(a,n);
	for(int i=0;i<n;i++)
		cout<<a[i];
	delete []a;
}

7. 交換排序—快速排序（Quick Sort）

基本思想：

1）選擇一個基準元素,通常選擇第一個元素或者最後一個元素,

2）通過一趟排序講待排序的記錄分割成獨立的兩部分，其中一部分記錄的元素值均比基準元素值小。另一部分記錄的 元素值比基準值大。

3）此時基準元素在其排好序後的正確位置

4）然後分別對這兩部分記錄用同樣的方法繼續進行排序，直到整個序列有序。

快速排序的示例：

（a）一趟排序的過程：

（b）排序的全過程


演算法的實現：

 遞迴實現：

//快速排序 
//第一個引數要排的陣列，第二個引數第一個數，第三個引數陣列成員個數
void kuaipai(int array[],int low,int hight)
{
	int i,j,t,m;
	if(low<hight)
	{
		i=low;
		j=hight;
		t=array[low];//第一個數為軸
		while(i<j)
		{
			while(i<j && array[j]>t)//從右邊找出小於軸的數
				j--;
			if(i<j)//將小於軸的數array[j]放到左邊array[i]的位置
			{
				m=array[i];
				array[i]=array[j];
				array[j]=m;
				i++;
			}
			while(i<j && array[i]<=t)//從左邊找出大於軸的數
				i++;
			if(i<j)//將大於軸的數array[i]放在右邊array[j]的位置
			{
				m=array[j];
				array[j]=array[i];
				array[i]=m;
				j--;
			}	
		}
		
		array[i]=t;//軸放在中間,現在就有兩個區域了分別是[0 i-1]和[i+1 hight],分別快排
		kuaipai(array,0,i-1);
		kuaipai(array,i+1,hight);
	}
}
void PX_kuaipai(int buf[],int size)
{
	kuaipai(buf,0,size-1);
}
void main()
{
	while(1)
	{
		int m,i;
		cin>>m;
		int *buf=new int[m];
		for(i=0;i<m;i++)
			cin>>buf[i];
		PX_kuaipai(buf,m);
		for(i=0;i<m;i++)
			cout<<buf[i];
		cout<<'\n';
		delete []buf;
	}
	
}

分析：

快速排序是通常被認為在同數量級（O(nlog2n)）的排序方法中平均效能最好的。但若初始序列按關鍵碼有序或基本有序時，快排序反而蛻化為氣泡排序。為改進之，通常以“三者取中法”來選取基準記錄，即將排序區間的兩個端點與中點三個記錄關鍵碼居中的調整為支點記錄。快速排序是一個不穩定的排序方法。

 
快速排序的改進

在本改進演算法中,只對長度大於k的子序列遞迴呼叫快速排序,讓原序列基本有序，然後再對整個基本有序序列用插入排序演算法排序。實踐證明，改進後的演算法時間複雜度有所降低，且當k取值為 8 左右時,改進演算法的效能最佳。演算法思想如下：

  1. void print(int a[], int n){  
  2.     for(int j= 0; j<n; j++){  
  3.         cout<<a[j] <<"  ";  
  4.     }  
  5.     cout<<endl;  
  6. }  
  7. void swap(int *a, int *b)  
  8. {  
  9.     int tmp = *a;  
  10.     *a = *b;  
  11.     *b = tmp;  
  12. }  
  13. int partition(int a[], int low, int high)  
  14. {  
  15.     int privotKey = a[low];                 //基準元素
  16.     while(low < high){                   //從表的兩端交替地向中間掃描
  17.         while(low < high  && a[high] >= privotKey) --high; //從high 所指位置向前搜尋，至多到low+1 位置。將比基準元素小的交換到低端
  18.         swap(&a[low], &a[high]);  
  19.         while(low < high  && a[low] <= privotKey ) ++low;  
  20.         swap(&a[low], &a[high]);  
  21.     }  
  22.     print(a,10);  
  23.     return low;  
  24. }  
  25. void qsort_improve(int r[ ],int low,int high, int k){  
  26.     if( high -low > k ) { //長度大於k時遞迴, k為指定的數
  27.         int pivot = partition(r, low, high); // 呼叫的Partition演算法保持不變
  28.         qsort_improve(r, low, pivot - 1,k);  
  29.         qsort_improve(r, pivot + 1, high,k);  
  30.     }   
  31. }   
  32. void quickSort(int r[], int n, int k){  
  33.     qsort_improve(r,0,n,k);//先呼叫改進演算法Qsort使之基本有序
  34.     //再用插入排序對基本有序序列排序
  35.     for(int i=1; i<=n;i ++){  
  36.         int tmp = r[i];   
  37.         int j=i-1;  
  38.         while(tmp < r[j]){  
  39.             r[j+1]=r[j]; j=j-1;   
  40.         }  
  41.         r[j+1] = tmp;  
  42.     }   
  43. }   
  44. int main(){  
  45.     int a[10] = {3,1,5,7,2,4,9,6,10,8};  
  46.     cout<<"初始值：";  
  47.     print(a,10);  
  48.     quickSort(a,9,4);  
  49.     cout<<"結果：";  
  50.     print(a,10);  
  51. }  

8. 歸併排序（Merge Sort）

基本思想：

歸併（Merge）排序法是將兩個（或兩個以上）有序表合併成一個新的有序表，即把待排序序列分為若干個子序列，每個子序列是有序的。然後再把有序子序列合併為整體有序序列。

歸併排序示例：

 

合併方法：

設r[i…n]由兩個有序子表r[i…m]和r[m+1…n]組成，兩個子表長度分別為n-i +1、n-m。

  1. j=m+1；k=i；i=i; //置兩個子表的起始下標及輔助陣列的起始下標
  2. 若i>m 或j>n，轉⑷ //其中一個子表已合併完，比較選取結束
  3. //選取r[i]和r[j]較小的存入輔助陣列rf
    如果r[i]<r[j]，rf[k]=r[i]； i++； k++； 轉⑵
    否則，rf[k]=r[j]； j++； k++； 轉⑵
  4. //將尚未處理完的子表中元素存入rf
    如果i<=m，將r[i…m]存入rf[k…n] //前一子表非空
    如果j<=n ,  將r[j…n] 存入rf[k…n] //後一子表非空
  5. 合併結束。
//歸併排序
void copyArray(int source[], int dest[],int len,int first)  
{  
    int i;  
    int j=first;  
    for(i=0;i<len;i++)  
    {  
        dest[j] = source[i];  
        j++;  
    }  
          
} 
//相鄰兩個有序子序列的

相關推薦

九大排序演算法-C語言實現及詳解

概述 排序有內部排序和外部排序，內部排序是資料記錄在記憶體中進行排序，而外部排序是因排序的資料很大，一次不能容納全部的排序記錄，在排序過程中需要訪問外存。 我們這裡說說八大排序就是內部排序。     當n較大，則應採用時間複雜度為O(nlog2n)的排序方法：快

氣泡排序演算法C語言實現

第一部分   排序方法介紹 常用的排序方法：氣泡排序，選擇排序，插入排序及希爾排序等。        氣泡排序是常用的一種排序方法，其基本方法就是逐次比較。即一次比較兩個數，若它們的順序錯誤，則交換；重複進行，知道沒有需要交換為止。 以升序排序為例：        1.

非常值得一看—九種濾波演算法C語言實現

關注“嵌入式軟體開發學習圈”免費獲取更多學習教程 今天帶著大家學習濾波演算法c語言（九種濾波演算法）實現，以及程式碼，大家可以學習瞭解下。。。。 1.限幅濾波演算法（程式判斷濾波演算法） 方法解析： 根據經驗判斷，確定兩次取樣允許的最

插入排序演算法C語言實現

實現如下： #include <stdio.h> #include <stdlib.h> #define SIZE 20 void insert_sort(int ar

快速排序演算法 C語言實現

快速排序演算法（QuickSort） 1.演算法思想 快速排序是一種劃分交換排序，採用了分治策略，通常稱為分治法。 （1）分治法的基本思想 將原問題分解成若干個規模更小但結構與原問題相似的子問題；遞迴地解這些子問題，然後將這些子問題的解組合成原問題的解。 （2）快速排序的基

順序表的基本操作及C語言實現（詳解版）

我們學習了順序表及初始化的過程，本節學習有關順序表的一些基本操作，以及如何使用 C 語言實現它們。 順序表插入元素 向已有順序表中插入資料元素，根據插入位置的不同，可分為以下 3 種情況： 插入到順序表的表頭； 在表的中間位置插入元素； 尾隨順序表中已有元素，作為順序表中的最後一個元素； 雖然資

靜態連結串列基本操作（C語言實現）詳解

上節，我們初步建立了一個靜態連結串列，本節學習有關靜態連結串列的一些基本操作，包括對錶中資料元素的新增、刪除、查詢和更改。 本節是建立在已能成功建立靜態連結串列的基礎上，因此我們繼續使用上節中已建立好的靜態連結串列學習本節內容，建立好的靜態連結串列如圖 1 所示： 圖 1 建立好的靜態連結串列 靜態

C語言實現九大排序演算法

- [C語言實現九大排序演算法](#c語言實現九大排序演算法) - [直接插入排序](#直接插入排序) - [折半插入排序](#折半插入排序) - [希爾排序](#希爾排序) - [氣泡排序](#氣泡排序) - [快速排序](#快速排序) - [直接選擇排序](

九大排序演算法之插入排序（原理及實現）

1、演算法思路：每趟將一個待排序的元素作為關鍵字，按照其關鍵字值得大小插入到已經排好的部分的適當位置上，知道插入完成。 2、演算法過程 舉個栗子（第一趟的排序過程） 原始序列：49、38、65、97、76、13、27、49 1)開始以第一個元素49為關鍵字，看成一個序列，其餘數看成另

九大排序演算法之選擇排序（原理及實現）

1、演算法思想：選擇排序，從頭至尾掃描序列，找出最小的一個元素，和第一個元素交換，接著從剩下的元素中繼續這種選擇和交換方式，最終得到一個有序序列。 2、演算法過程 舉個栗子（第一趟的排序過程） 原始序列：49、38、65、97、76、13、27、49 1）在進行選擇排

九大排序演算法的手寫實現及時空複雜度分析

一、氣泡排序  氣泡排序是一種簡單的排序方法，演算法如下：  1. 首先將所有待排序的數字放入工作列表中。  2. 從列表的第一個數字到倒數第二個數字，逐個檢查：若某一位上的數字大於他的下一位，則將它與它的下一位交換。  3. 重複2號步驟(倒數的數字加1。例

九大排序演算法的手寫實現及時空複雜度分析 筆試面試必備

一、氣泡排序 氣泡排序是一種簡單的排序方法，演算法如下： 1. 首先將所有待排序的數字放入工作列表中。 2. 從列表的第一個數字到倒數第二個數字，逐個檢查：若某一位上的數字大於他的下一位，則將它與它的下一位交換。 3. 重複2號步驟(倒數的數字加1。例如

單鏈表的C語言實現及插入刪除演算法

什麼是單鏈表？ 　　由於順序表在插入和刪除是需要做大量的元素移動工作，而且需要連續的物理空間，因此其缺點是十分明顯的，為了解決這一問題，不需要預先分配連續的記憶體地址空間、插入刪除元素不需要做大量移動工作的連結串列出現了。但解決問題的同時也擁有自己的缺點，即不能隨機存取。 　　在連結串列中，每個

10個重要的演算法C語言實現原始碼：拉格朗日，牛頓插值，高斯，龍貝格，牛頓迭代，牛頓-科特斯，雅克比，秦九昭，冪法，高斯塞德爾

（一）拉格朗日插值多項式 #include <stdio.h>  #include <conio.h>  #include <alloc.h> &n

有趣的演算法（七）：3分鐘看懂希爾排序（C語言實現）

在上一次的演算法討論中，我們一起學習了直接插入排序。它的原理就是把前i個長度的序列變成有序序列,然後迴圈迭代,直至整個序列都變為有序的。但是說來說去它還是一個時間複雜度為(n^2)的演算法,難道就不能再進一步把時間複雜度降低一階麼?確實,以上幾種演算法相對於之前的O(n^2)

資料結構排序演算法之歸併排序（c語言實現）

博主身為大二萌新，第一次學習資料結構，自學到排序的時候，對於書上各種各樣的排序演算法頓覺眼花繚亂，便花了很長的時間盡力把每一個演算法都看懂，但限於水平有限，可能還是理解較淺，於是便將它們逐個地整理實現出來，以便加深理解。 歸併排序就是通過將一個具有n個key記錄的線性表，看

排序演算法-合併排序（C語言實現）

都說“演算法是程式的靈魂”，而排序是計算機儲存控制方面不能沒有的操作。它在資料的存取，查詢搜尋，資料統計這些基礎資料操作方面有著重要的應用。所以排序演算法是必須是很有研究的。 這次，我學習的是-歸併排序演算法。據說該演算法是馮諾依曼發明的。這個排序演算法比起直

[演算法練習]堆排序的C語言實現

#include <stdio.h> void heap_sort(); void max_heap(); void build_heap(); int LEFT(),RIGHT();

資料結構排序演算法之快速排序（c語言實現）

快排的原理就是通過一趟排序將待排記錄分割成獨立的兩部分，其中的一部分記錄的關鍵字均比另一部分記錄的關鍵字小，則可分別對這兩部分記錄繼續進行排序，以達到整個序列有序。這其中，可以使用遞迴呼叫某一關鍵函式的辦法來實現這樣的功能。 分割的方法就是，選取一個樞軸，將所有關鍵字比它

堆排序（C語言實現）

names 博客 鏈接 c語言實現 建立 ron 要求 clas [1] 之前的博客介紹介紹了數組的兩種排序算法：插入排序和歸並排序(採用遞歸)，見鏈接http://blog.csdn.net/u013165521/article/detai