排序算法_9种_代码_基本思路_c++

排序算法

冒泡排序

void BubbleSort(int* start,int* stop){
	for(int i=0;i<=stop-start;i++){
		for(int j=0;j<stop-start-i-1;j++){
			if(start[j]>=start[j + 1]){
				int temp=start[j];
				start[j]=start[j + 1];
				start[j+1]=temp;
			}
		}
	}
	return;
}

时间复杂度：O(n²)

空间复杂度：O(1)

稳定

选择排序

void SelectSort(int* start,int* stop){
    int i,j,index,n=stop-start;
    for(i=0;i<=n;i++){
        index = i;
        for(j=i+1;j<n;j++) if(start[j]<start[index]) index = j;
        swap(start[i],start[index]);
    }
    return;
}

时间复杂度：O(n²)

空间复杂度：O(1)

不稳定

插入排序

void InsertSort(int* start,int* stop){
	for(int i=0;i<=stop-start;i++){
		int end=i;
		int x=start[end + 1];
		while(end>=0){
			if (start[end]>x){
				start[end+1]=start[end];
				start--;
			}
			else{
				break;
			}
		}
		start[end+1]=x;
	}
	return;
}

时间复杂度：O(n²)

空间复杂度：O(1)

稳定

希尔排序

void ShellSort(int* start,int* stop){
	int gap=stop-start;
	while(gap>1){
		gap=gap/3+1;
		for(int i=0;i<stop-start-gap;i++){
			int end=i;
			int x=start[end + gap];
			while(end>=0){
				if(start[end]>x){
					start[end+gap]=start[end];
					end-=gap;
				}
				else break;
			}
			start[end + gap]=x;
		}
	}
	return;
}

时间复杂度：O(n^1.3)

空间复杂度：O(1)

不稳定

堆排序

void HeapSort(int* start,int* stop){
	priority_queue< int,vector<int>,greater<int> > pq;
	for(int i=0;i<=stop-start;i++){
		pq.push(start[i]);
	}
	int cnt=0;
	while(!pq.empty()){
		start[cnt++]=pq.top();
		pq.pop();
	}
}

时间复杂度：O(n logn)

空间复杂度：O(n)

不稳定

快速排序

void QuickSort(int* start,int* stop){
	int mid,low=0,hight=stop-start;
	if (low<hight){
		int i=low,j=hight,pivot=start[low];
		while(i<j){
			while(i<j&&start[j]>pivot){
				j--;
			}
			if(i<j){
				swap(start[i++],start[j]);
			}
			while(i<j&&start[i]<=pivot){
				i++;
			}
			if(i<j){
				swap(start[i],start[j--]);
			}
		}
		mid=i;
		QuickSort(start,mid+start-1);
		QuickSort(mid+start+1,stop);
	}
}

时间复杂度：O(n logn)

空间复杂度：O(n logn)

不稳定

归并排序

void MergeSort(int* start,int* stop){
	int left=0,right=stop-start;
	if(left<right){
		int mid=left+(right - left)/2;
		MergeSort(left+start,mid+start);
		MergeSort(mid+1+start,right+start);
		int L1=left,R1=mid,L2=mid+1,R2=right;
		int i=L1,j=L2;
		int temp[1000001],index=0;
		while(i<=R1&&j<=R2){
			if(start[i]<=start[j])
				temp[index++]=start[i++];
			else
				temp[index++]=start[j++];
		}
		while(i<=R1) temp[index++]=start[i++];
		while(j<=R2) temp[index++]=start[j++];
		for(i =0;i<index;i++){
			start[L1+i]=temp[i];
		}
	}
}

时间复杂度：O(n logn)

空间复杂度：O(n)

稳定

计数排序

void CountSort(int* start, int* stop){
	int n=stop-start;
	int max=start[0];
	int min=start[0];
	for(int i=0;i<=n;i++){
		if(start[i]>max){
			max=start[i];
		}
		if(start[i]<min)
		{
			min=start[i];
		}
	}
	int range=max-min+1;
	int* count=(int*)malloc(sizeof(int)*range);
	assert(count);
	memset(count,0,sizeof(int)*range);
	for(int i=0;i<=n;i++){
		count[start[i]-min]++;
	}
	int j=0;
	for(int i=0;i<range;i++){
		while(count[i]--){
			start[j++]=i+min;
		}
	}
	return;
}

时间复杂度：O(n+k)

空间复杂度：O(n+k)

稳定

基数排序

void RadixSort(int* start, int* stop){
	int n=stop-start;
	int d=1;
	int p=10;
	for(int i = 0; i < n; ++i){
		while(start[i]>=p){
			p*= 10;
			++d;
		}
	}
	int digits=d;
	list<int> lists[stop-start+10];
	int j,k,factor;
	for(d=1,factor=1;d<=digits;factor*=10,d++){
		for(j = 0; j < n; j++){
			lists[(start[j]/factor) %10].push_back(start[j]);
		}
		for(j=k=0;j<10;j++){
			while(!lists[j].empty()){
				start[k++] = lists[j].front();
				lists[j].pop_front();
			}
		}
	}
}

时间复杂度：O(n+k)

空间复杂度：O(n+k)

稳定