排序算法

1.快速排序的递归写法

int partaction(int *a,int left,int right)
{
	int tmp=a[left];
	while(left<right)
	{
		while(right>left&&a[right]>=tmp)//要有等号要不会出现你换过来我换过去的情况发生
		{
			right--;
		}
		a[left]=a[right];
		while(left<right&&a[left]<=tmp)
		{
			left++;
		}
		a[right]=a[left];
	}
	a[left]=tmp;
	return left;
}
int qsort(int *a,int left,int right)
{
	if(left<right)
	{
		int pos=partaction(a,left,right);
		qsort(a,left,pos-1);
		qsort(a,pos+1,right);
	}
}

非递归算法（利用stack和map因为要记录left和right）：

算法如下

void qsort(int *a,int left,int right)
{
	stack<pair<int,int>> s;
	s.push(make_pair(left,right));
	while(s.empty())
	{
		pair<int,int> tmp=s.top();
		s.pop();
		int pos=partaction(a,tmp.first,tmp.second);
		s.push(pair<int,int>(tmp.first,pos-1));
		s.push(pair<int,int>(pos+1,tmp.second));
	}
}

归并排序

递归版本

void partaction(int *arr, int left, int middle, int right, int *temp)//每次比较都去获取
{
	int i = left;
	int j = middle + 1;
	int k = 0;
	while (i <= middle&&j <= right)
	{
		if (arr[i]<arr[j])
			temp[k++] = arr[i++];
		else
			temp[k++] = arr[j++];
	}
	while (i>middle&&j <= right)
	{
		temp[k++] = arr[j++];
	}
	while (i <= middle&&j>right)
	{
		temp[k++] = arr[i++];
	}
	k = 0;
	for (int i = left; i <= right; i++, k++)
	{
		arr[i] = temp[k];
	}
}
void mergesort(int *a, int left, int right, int *temp)
{
	if (left<right)
	{
		int middle = (right + left)/ 2;
		mergesort(a, left, middle, temp);
 		mergesort(a, middle + 1, right, temp);
		partaction(a, left, middle, right, temp);

	}
}

非递归版本

void merage(int *a, int left, int right, int *temp)
{
	//最后如果是偶数是好的，如果是基数最后多排一次；
	int i = 0;
	for (int step = 1; step <= right; step = step * 2)
	{
		for (i = 0; i <= right; i = i + 2*step)
		{
			if (i+2*step-1>right||i+step-1>right||i>right)
			{
				break;
			}
			partaction(a, i, i + step - 1, i + 2 * step - 1, temp);
		}
		partaction(a,i,i+step-1, right, temp);//判断多的话就直接最长的一组和当前组比较/并且保证当前组是有序的
	}
	
}

2018/1/31 补充

#include <stdio.h>
int count;
void bubbleSort(int *arr,int len)//冒泡排序 int count
{
	int temp=0;
	int flag;
	for(int i=0;i<len;i++)
	{
		flag=0;
		for(int j=0;j<len-i-1;j++)
		{
			count++;
			if(arr[j]>arr[j+1])
			{
				flag=1;
				temp=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=temp;
			}
		}
		if(flag!=1)
		{
			return ;
		}
	}
}//效率冒泡排序的优话
int partaction(int *arr,int left,int right)
{
	int temp=arr[left];
	while(left<right)
	{
		if(arr[right]>=temp&&right>left)//等号记住我求你了比较是temp不是这个细心的
		{
			right--;
		}
		
		arr[left]=arr[right];
		if(arr[left]<=temp&&right>left)
		{
			left++;
		}
		arr[right]=arr[left];
	}
	arr[left]=temp;
	return left;
}
void qsort(int *arr,int left,int right)
{
		if(left<right)//小于号我求你了两次了
		{
			int middle=partaction(arr,left,right);
			qsort(arr,left,middle-1);
			qsort(arr,middle+1,right);
		}
}
void insertSort(int *arr,int len)//插入排序前面就是已经排列好的稳定
{
	for(int i=0;i<len-1;i++)
	{
			int temp=arr[i+1];
			for(int k=i;k>=0;k--)
			{
				if(temp>arr[k])
				{
						arr[k+1]=temp;
						break;
				}
				arr[k+1]=arr[k];
			}
	}
}
void selectSort(int *arr,int len)//选择排序；；
{
	int temp;
	for(int i=0;i<len-1;i++)
	{
		int min;
		int j;
		min=i;
		for(j=i;j<len;j++)
		{
		   
			if(arr[min]>arr[j])//选择算法不稳定。
			{
				min=j;
			}
		}
		if(min!=i)
		{
			int temp=arr[i];
			arr[i]=arr[min];
			arr[min]=temp;
		}
	}
}
void print(int *arr,int len)
{
	for(int i=0;i<len;i++)
	{
		printf("%d\n",arr[i]);
	}
	printf("count:%d",count);
}
int main()
{
	int arr[20]={1,2,3,45,23,
				 21,22,12,23,22,
				 12,2,4,5,2,
				 2,1,0,-3,2
				};
	int brr[5]={2,3,421,12,23};
	//bubbleSort(arr,20);
	//selectSort(arr,20);
	//insertSort(arr,20);
	qsort(arr,0,19);
	print(arr,20);

}
void heap_adjust(int *arr,int start,int end)
{
	int i;
	int tmp = arr[start];
	for(i=2*start+1; i<=end; i=2*i+1)
	{
		if (i+1<=end && arr[i]<=arr[i+1])//如果有右孩子且右孩子大于左孩子
		{
			i++;
		}

		if (tmp < arr[i])
		{
			arr[start] = arr[i];
			start = i;
		}
		else
		{
			break;
		}
	}
	arr[start] = tmp;
}
void swap(int *x,int *p)
{
	int tmp=*x;
	*x=*p;
	*p=tmp;
}
void heap_sort(int *arr,int len)
{
	for (int i=(len-2)/2; i>=0;i--)
	{
		heap_adjust(arr,i,len-1);
	}
	swap(&arr[0],&arr[len-1]);
	for(int i=len-2;i>0;i--)
	{
		heap_adjust(arr,0,i);
		swap(&arr[0],&arr[i]);
	}
}
int main()
{
	int arr[] = {0,15,2,3,4,132,4,68,1,0,45,213,54,23};
	heap_sort(arr,sizeof(arr)/sizeof(sizeof(arr[0])));
	for (int i = 0; i<sizeof(arr)/sizeof(sizeof(arr[0])); i++)
	{
		printf("%d ",arr[i]);
	}
	return 0;

}
/*基数排序首先要确定的是这个只能是非负数他是一种非比较类型的一种排序法空间换时间
#include <iostream>
#include <vector>
using namespace std;
const int MaxPos=10;//默认最长位数是10位数
int GetBucketNum(int number, int pos)//获取对应的桶号
{
	int temp=1;
	for(int i=0;i<pos-1;i++)
	{
		temp*=10;
	}
	return (number/temp)%10;
}
bool ClearBucket(vector<vector<int>> &bucket)//因为每个桶中的元素个数不一定为1个所以二维采用vector
{
	for(int i=0;i<bucket.size();i++)
	{
		bucket[i].clear();
	}
	return true;
}
void RadixSort(vector<int> &vec)
{
	vector<vector<int>> bucket;
	bucket.resize(10);
	int cnt;
	for(int pos=1;pos<=MaxPos;++pos)
	{
		for(int i=0;i <vec.size();i++)
		{
			int index=GetBucketNum(vec[i],pos);
			bucket[index].push_back(vec[i]);//放到对应的桶中
		}
		cnt =0; //新的数据排列放到桶中
		for(int i=0;i<vec.size();i++)
		{
			for(int j=0;j<bucket[i].size();++j)
			{
				vec[cnt++]=bucket[i][j];
			}
		}
		ClearBucket(bucket);
	}
}
int main()
{
	vector<int> arr;
	arr.resize(10);
	for(int i=0;i<10;i++)
	{
		arr[i]=rand();
	}
	RadixSort(arr);
	auto it=arr.begin();
	for(;it!=arr.end();it++)
	{
		cout<<*it<<endl;
	}
}

个数