排序算法僞碼模板

插入排序

直接插入排序–穩定

最好情況O(n)
平均情況O(n²)
最壞情況O(n²)

void insertsort(Elemtype a[], int n){
	int i, j;
	for(int i = 2; i<=n; i++){
		if(a[i] < a[i-1]){
			a[0] = a[i];
			for(int j = i-1; a[0] < a[j]; --j){
				a[j+1] = a[j];
			}
			a[j+1] = a[0];
		}
	}
}

折半插入排序–穩定

O(n²)
比較次數：O(nlog₂n)

void insertsort(Elemtype a[], int n){
	int i, j;
	int low, high, mid;
	for(int i = 2; i<=n; i++){
		if(a[i] < a[i-1]){
			a[i] = a[0];
			low = 1;
			high = i-1;
			while(low <= high){
				mid = (low + high) / 2;
				if(a[0] < a[mid])  high = mid - 1;
				else low = mid + 1;
			}
			for(int j = i-1; j>=high+1; j--){
				a[j+1] = a[j];
			}
			a[high+1] = a[0];
		}
	}
}

希爾排序–不穩定

增量系列：d₁=n/2   d_i+1=d_i/2(向下取整)

void shellsort(Elemtype a[], int n){
	for(int dk = n/2; dk>=1; dk=dk/2){
		for(int i = dk+1; i<=n; i++){
			if(a[i] < a[i-dk]){
				a[0] = a[i];
				for(int j = i-dk; j>0&&a[j]>a[0]; j-=dk){
					a[j+dk] = a[j]; 
				}
				a[j+dk] = a[0];
			}
		}
	}
}

交換排序

冒泡排序–穩定

最好情況：O(n):比較次數n-1 移動0次
最壞情況：O(n²):需進行n-1趟 第i趟比較n-i次
平均情況：O(n²)

void bubblesort(Elemtype a[], int n){
	for(int i = 0; i<n-1; i++){
		int flag = false;
		for(int j = n-1; j>i; j--){
			if(a[j] < a[j-1]){
				swap(a[j], a[j-1]);
				flag = true;
			}
		}
		if(flag == false)
		
	}
}

快速排序–不穩定

最壞情況：O(n²)
最好情況：O(nlog₂n)
空間複雜度：

• 最好情況：O(log₂n)
• 最壞情況：O(n)
• 平均情況：O(log₂n)

int partition(Elemtype a[], int low, int high){
	Elemtype p = a[low];
	while(low < high){
		while(high>low && a[high]>=p) high--;
		a[low] = a[high];
		while(low<high && a[low]<=p) low++;
		a[high] = a[low];
	}
	a[low] = p;
	
	return low;
}

void quicksort(Elemtype a[], int low, int high){
	if(low < high){
		int mid = partition(a, low, high);
		quicksort(a, low, mid-1);
		quicksort(a, mid+1, high);
	}
}

選擇排序

直接選擇排序–不穩定

平均O(n²): 移動次數n(n-1)/2

void selectsort(Elemtype a[], int n){
	 int i, j;
	 for(i = 0; i<n-1; i++){
	 	int min = i;
	 	for(j = i+1; j<n; j++){
		 	if(a[j] < a[i]) min = j;
		 }
		 if(min != i)  swap(a[min], a[i]);
	 }
}

堆排序–不穩定

時間複雜度O(nlog₂n)：建堆時間O(n)，共需n-1次向下調整

void buildmaxHeap(Elemtype a[], int len){
	for(int i = len/2; i>0; i--)
		headAdjust(a, i, len);
}

void headAdjust(Elemtype a[], int k, int len){
	a[0] = a[k];
	for(int i = 2*k; i<=len; i*=2){
		if(i<len && a[i] < a[i+1])
			i++;
		if(a[0] >= a[i])  break;
		else {
			a[k] = a[i];
			k = i;
		} 
	}
	a[k] = a[0];
}

void heapsort(Elemtype a[], int len){
	buildmaxHeap(a, len);
	for(int i = len; i>0; i--){
		swap(a[i], a[1]);
		headAdjust(a, 1, i-1);
	}
}

歸併排序 --穩定

時間複雜度：O(nlog₂n):每趟O(n),供需log₂n趟(向下取整)
空間複雜度：O(n)

Elemtype *b = (Elemtype*)malloc((n+1)*sizeof(Elemtype));
void merge(Elemtype a[], int low, int mid, int high){
	int i, j, k;
	for(k = low; k<=high; k++){
		b[k] = a[k];
	}
	
	for(i = low, j = mid+1, k = i; i<=mid && j<=high; k++){
		if(b[i] < b[j])
			a[k] = b[i++];
		else
			a[k] = b[j++];
	}
	
	while(i <= mid)
		a[k++] = b[i++];
	while(j <= high)
		a[k++] = b[j++];
} 

void mergeSort(Elemtype a, int low, int high){
	if(low < high){
		int mid = (low+high) / 2;
		mergeSort(low, mid);
		mergeSort(mid+1, high);
		merge(a, low, mid, high);
	}
}

基數排序–穩定

時間複雜度O(d(n+r))：需進行d趟分配與收集，一趟分配需O(n),一趟收集需O®
high){
if(low < high){
int mid = (low+high) / 2;
mergeSort(low, mid);
mergeSort(mid+1, high);
merge(a, low, mid, high);
}
}

# 基數排序--穩定

**時間複雜度O(d(n+r))**：需進行d趟分配與收集，一趟分配需O(n),一趟收集需O(r)
**空間複雜度O(r)**：r個隊列