基础数据结构算法_快速排序,堆排序,归并排序

还是把基础数据结构复习一下吧，算法虽然简单，但是想把后面的思想完全领悟还是比较困难的。

这个是排序的三件套，快速排序，堆排序，归并排序。

快速排序：以第一个数为支点，把比他小的放前面，比他大的放后面。

完成这一步需要在一个大循环里嵌套两个并列的小循环。

大循环控制是否结束，第一个小循环控制把小数往前移，第二个控制把大数往前移。

然后以支点的位置分别左右递归。

        #include<iostream>
		#include<vector>
		#include<algorithm>
		#include<ctime>
		using namespace std;
		
		void quicksort(vector<int> &arr,int x,int y)
		{
			int l=x,r=y;
			if(x>=y) return ;
			while(y>x)
			{
				while(true)
				{
					if(arr[x]<=arr[y]&&x!=y)
					{
						y--;
				    }
	                else
	                {
	                	swap(arr[x],arr[y]);
						break; 
					}
				}
				
				while(true)
				{
					if(arr[x]<=arr[y]&&x!=y)
					{
						x++;
					}
					else
					{
						swap(arr[x],arr[y]);
						break;
					}
				}				
			}
			
			quicksort(arr,l,x-1);
			quicksort(arr,x+1,r);	
		}
		
		int main()
{ 
        srand(time(NULL));
        int n;
        cin>>n;
        vector<int> arr(n);
        for(int i=0;i<n;i++)
            arr[i]=rand();
            
        quicksort(arr,0,arr.size()-1);
		 
        for(int i=0;i<n;i++)
            cout<<arr[i]<<" ";

        return 0;
}

堆排序：堆有以下基础操作，上溯 up 和下溯 down，up是往一个堆的最后面加一个入数据后 使得该数据上升到合法位置，down是删除第一个元素 把最后一个元素放到第一个的位置 使得该数据下降到合法位置，有这两个操作就能完成堆排序了。

        #include<iostream>
        #include<vector>
        #include<algorithm>
        #include<ctime>
        using namespace std;
        
        void up(vector<int> &tem)
        {
        	int loop=tem.size()-1;
        	while(loop>0&&tem[loop]<tem[(loop-1)/2])
        	{
        	 	swap(tem[loop],tem[(loop-1)/2]);
        	 	loop=(loop-1)/2;
			}
		} 
		
		void down(vector<int> &tem)
		{
			int loop=0;
			while(2*loop+1<tem.size())
			{
				if(2*loop+2>=tem.size()||tem[2*loop+1]<=tem[2*loop+2])
				{
					if(tem[loop]<=tem[2*loop+1]) break;
					swap(tem[loop],tem[2*loop+1]);
					loop=2*loop+1;
				}
				else
				{
					if(tem[loop]<=tem[2*loop+2]) break;
					swap(tem[loop],tem[2*loop+2]);
					loop=2*loop+2;
				}
			}
		} 
        
        void makeheap(vector<int> &tem,vector<int> &arr)
		{
			for(int i=0;i<arr.size();i++)
			{
				tem.push_back(arr[i]);
				up(tem);
			}
		}
        
        void heapsort(vector<int> &arr)
        {
        	vector<int> tem;
        	makeheap(tem,arr);
        	
        	for(int i=0;tem.size()!=0;i++)
        	{
        		arr[i]=tem[0];
        		swap(tem[0],tem[tem.size()-1]);
        		tem.pop_back();
        		down(tem);
			}
		}
        
        int main()
{ 
        srand(time(NULL));
        int n;
        cin>>n;
        vector<int> arr(n);
        for(int i=0;i<n;i++)
            arr[i]=rand();
        
        heapsort(arr);
        
        for(int i=0;i<n;i++)
            cout<<arr[i]<<" ";
        return 0;
}

归并排序：这个很简单就是把两个有序序列合并，反复进行这个操作就行了。

        #include<iostream>
        #include<vector>
        #include<cstdlib>
        #include<ctime>
        using namespace std;
        
        void merger(vector<int> &arr,int x1,int y1,int x2,int y2)
        {
        	vector<int> tem(y2-x1+1);
        	int s1=x1,s2=x2;
        	int c=0;
        	while(s1<=y1||s2<=y2)
        	{
        		if(s1<=y1&&(arr[s1]<=arr[s2]||s2>y2))
        			tem[c++]=arr[s1++];
        		else
        	        tem[c++]=arr[s2++];
			}
			
			for(int i=x1,c=0;i<=y2;)
				arr[i++]=tem[c++];
		}
        
        void mergersort_loop(vector<int> &arr)
        {
         	int m=2;//合并的总长度，即每个区间为长度为 m/2
			int len=arr.size();//把无符号的数转化为int 
         	while(len>m/2)//能否进行一次合并 
         	{
         		for(int i=0;len-i>m/2;i+=m)//能合并多少次 
         		{
         			if(i+m-1<len)
         			    merger(arr,i,i+m/2-1,i+m/2,i+m-1);
         			else
         			    merger(arr,i,i+m/2-1,i+m/2,len-1);
				}
				m*=2;
			}
		}
        
        int main()
{       
        srand(time(NULL));
	    int n;
	    cin>>n;
	    vector<int> arr(n);
	    for(int i=0;i<n;i++)
	    	arr[i]=rand();
	    
	    mergersort_loop(arr);
	    
	    for(int i=0;i<arr.size();i++)
	        cout<<arr[i]<<" ";
	    return 0;
}