常見排序算法

一、冒泡排序

算法思想：首先將第一個記錄的關鍵字與第二個記錄的關鍵字進行比較，若爲逆序，則交換這兩個記錄的值，然後比較第二個記錄和第三個記錄的關鍵字，以此類推，直至第n-1個和第n個記錄的關鍵字比較過爲止；至此第一趟冒泡排序完成，對前n-1個記錄的關鍵字按照第一趟的冒泡排序排序，依次循環，直到最後縮到第一個爲止

#include<stdio.h>
void bubble_sort(int a[],int n)
{
	int i, j, t;
  for(j = 0; j < n ; j++)
 	{
	  for(i = 0; i < n - j - 1; i++)	//注意是n-j-1,因爲一趟遍歷n個數，要兩兩比較n-1次
	  {
	     if(a[i] > a[i+1])	//把值比較大的元素沉到底
	     {
	        t = a[i];
	        a[i] = a[i+1];
	        a[i+1] = t;
	     }
	  }
 	}
}

int main()
{
	int i, j;
	int arr[] = {2,4,8,5,9,7,1,10,3,6};
	for(i = 0; i < sizeof(arr)/sizeof(int); i++)
		printf("%d ",arr[i]);
	bubble_sort(arr, sizeof(arr)/sizeof(int));
	printf("\n");
	for(j = 0; j < sizeof(arr)/sizeof(int); j++)
		printf("%d ",arr[j]);
}

二、選擇排序

算法思想：每一趟從待排序的數據元素中選出最小（或最大）的一個元素，順序放在已排好序的數列的最後，直到全部待排序的數據元素排完。 選擇排序是不穩定的排序方法。

#include<stdio.h>
void select_sort(int arr[], int n)
{
	int i, j, k, t;
	for(i=0; i<n-1; i++)
	{
		k = i;
		for(j=i+1; j<n; j++)
		{
			if(arr[j] < arr[k])
				k = j;
		}
		if(k != i)
		{
			t = arr[i];
			arr[i] = arr[k];
			arr[k] = t;
		}
	}

}

int main()
{
	int i, j;
	int arr[] = {2,4,8,5,9,7,1,10,3,6};
	for(i = 0; i < sizeof(arr)/sizeof(int); i++)
		printf("%d ",arr[i]);
	select_sort(arr, sizeof(arr)/sizeof(int));
	printf("\n");
	for(j = 0; j < sizeof(arr)/sizeof(int); j++)
		printf("%d ",arr[j]);
}

 

 

三、直接插入排序

算法思想：每次從無序表中取出第一個元素，把它插入到有序表的合適位置，使有序表仍然有序。 第一趟比較前兩個數,然後把第二個數按大小插入到有序表中; 第二趟把第三個數據與前兩個數從前向後掃描，把第三個數按大小插入到有序表中；依次進行下去，進行了(n-1)趟掃描以後就完成了整個排序過程。

#include<stdio.h>
void insert_sort(int arr[], int n)
{
	int i, j, t;
	for (i = 1; i < n; i++)
	{
		t = arr[i];
		for(j=i-1; j>=0 && arr[j]>t; j--)
			arr[j+1] = arr[j];
		arr[j+1] = t;
	}
}

int main()
{
	int i, j;
	int arr[] = {2,4,8,5,9,7,1,10,3,6};
	for(i = 0; i < sizeof(arr)/sizeof(int); i++)
		printf("%d ",arr[i]);
	insert_sort(arr, sizeof(arr)/sizeof(int));
	printf("\n");
	for(j = 0; j < sizeof(arr)/sizeof(int); j++)
		printf("%d ",arr[j]);
}

四、希爾排序

算法思想：希爾排序(Shell Sort)是插入排序的一種。是針對直接插入排序算法的改進。先取一個小於n的整數d1作爲第一個增量，把文件的全部記錄分成（n除以d1）個組。所有距離爲d1的倍數的記錄放在同一個組中。先在各組內進行直接插入排序；然後，取第二個增量d2<d1重複上述的分組和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有記錄放在同一組中進行直接插入排序爲止。

#include<stdio.h>
void shell_sort(int arr[], int n)
{
	int d, i, j, t;
	for(d=n/2; d>=1; d=d/2)
	{
		for(i=d; i<n; i++)
		{
			t = arr[i];
			for(j=i-d; j>=0 && arr[j]>t; j=j-d)
				arr[j+d] = arr[j];
			arr[j+d] = t;
		} 
	}
}

int main()
{
	int i, j;
	int arr[] = {2,4,8,5,9,7,1,10,3,6};
	for(i = 0; i < sizeof(arr)/sizeof(int); i++)
		printf("%d ",arr[i]);
	shell_sort(arr, sizeof(arr)/sizeof(int));
	printf("\n");
	for(j = 0; j < sizeof(arr)/sizeof(int); j++)
		printf("%d ",arr[j]);
}

五、快速排序

算法思想：快速排序（Quicksort）是對冒泡排序的一種改進。通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

#include<stdio.h>
void quick_sort(int data[], int low, int high) 
{
	int mid; 
	if(low < high) 
	{
		mid = partition(data, low, high); 
		quick_sort(data, low, mid-1); /* 遞歸調用 */
		quick_sort(data, mid+1, high);
	} 
}

int partition(int data[], int low, int high) 
{
	int tmp;
	while(low < high) 
	{
		while((low < high) && (data[high] >= data[low]))	//high-->low
			--high;
		if(low < high)
		{
			tmp = data[low];
			data[low] = data[high];
			data[high] = tmp;
			low++;
		}
	
		while((low < high) && (data[low] <= data[high]))	//low-->high
			++low;
		if(low < high)
		{
			tmp = data[low];
			data[low] = data[high];
			data[high] = tmp;
			high--;
		}  
	}  
	return low;     		
} 


int main()
{
	int i, j;
	int arr[] = {2,4,8,5,9,7,1,10,3,6};
	for(i = 0; i < sizeof(arr)/sizeof(int); i++)
		printf("%d ",arr[i]);
	quick_sort(arr, 0, sizeof(arr)/sizeof(int)-1);
	printf("\n");
	for(j = 0; j < sizeof(arr)/sizeof(int); j++)
		printf("%d ",arr[j]);
}