八大排序java实现

八大排序介绍

1、插入排序:直接插入排序、希尔排序。
2、选择排序:直接选择排序、堆排序。
3、交换排序:冒泡排序、快速排序。
4、归并排序。
5、基数排序。

直接插入排序

一、思路:我们先对前两个数进行排序,即先确定第二个数的位置,然后确定第三个数的位置,以此类推,直至全部排完。我们把这个数放入c中保存,然后依次拿前面的数和c比较,若比c大,则后移,直到达到0位置或者找到比c小的数,我们再把c插入空位即可。
二、算法分析:
1、最好的情况:已经有序,复杂度O(n)
2、最坏的情况:顺序相反,复杂度O(n^2)
3、平均时间复杂度:O(n^2)
4、空间复杂度:O(1)
5、稳定性:稳定
三、算法实现:

	/**
	 * 直接插入排序
	 * @param a
	 * @return
	 */
	public int[] sort1(int[] a){
		 for(int i=1;i<a.length;i++){
			 int c=a[i];
			 int t;
			 for(t=i-1;t>=0&&a[t]>c;t--){
				 a[t+1]=a[t];
			 }
			 a[t+1]=c;			 
		 }		 
		 return a;
	}

四、算法优缺点:在一个数组接近顺序的前提下排序会很快,但在逆序下,所花的时间较多。

希尔排序

一、思路:我们在直接插入排序中可以发现,如果在逆序这类情况下,会花费程序很大的时间,而在接近顺序时,时间复杂度可以接近O(n),因此,我们在直接插入排序的基础上做了一些改进。我们把数据分组,设立一个gap,刚开始为1/2,之后逐渐减小为原来的1/2,最终为1,它的作用便是把数据分割,控制排序的组数,我们来看一下示意图,便可以理解了。
在这里插入图片描述
我们可以发现,最后一趟排序前数据已经基本上有序,我们可以得到一个总体上相对较少的时间完成排序,这避免了直接插入法的缺点。
二、算法分析:
1、最好的情况:O(nlog2 n)
2、最坏的情况:O(nlog2 n)
3、平均时间复杂度:O(nlog2 n)
4、空间复杂度:O(1)
5、稳定性:不稳定
三、算法实现:

	/**
	 * 希尔排序
	 * @param a
	 * @return
	 */
	public int[] sort2(int a[]){     
		int gap;
		for(gap = a.length/2; gap>=1; gap/=2)
		{		      
				for(int i=0;i<a.length;i++)
				{                   
					 for(int k=i;k<=a.length-gap;k+=gap)  //直接插入排序部分
					 {
						     int c=a[k];
						     int t;
						     for( t=k-gap;t>=0&&a[t]>c;t-=gap)
						     {
						    	a[t+gap] = a[t];						    	 						   
						         if(t<gap)
						         {
						        	t-=gap;
						        	break;
						         }	 
						     }
						     a[t+gap]=c;							
					 }						 
				}			
		}				
		return a;  
	}

四、算法优缺点:相比直接插入排序,它的效率更高,避免了直接插入排序在乱序情况下的不足。但因为在不同的排序组内会有数的移动,因此希尔排序是不稳定的。

直接选择排序

一、思路:选择排序的思路很简单:第一次遍历整个数组找到最小的数,换到数组的第一个位置,然后从第二个数组开始寻找第二小的数,换到数组第二个位置,以此类推,全部排完。
二、算法分析:
1、最好的情况:O(n^2)
2、最坏的情况:O(n^2)
3、平均时间复杂度:O(n^2)
4、空间复杂度:O(1)
5、稳定性:不稳定(涉及到角标值的被后者覆盖问题)
三、算法实现:

	/**
	 * 选择排序
	 * @param a
	 * @return
	 */
	public int[] sort3(int a[]){	
		for(int i=0;i<a.length-1;i++){
			int c=i;
			int min=a[i];
			for(int j=i+1;j<a.length;j++){
				if(a[j]<min){
				  c=j;
				  min=a[j];
				}
			}		
			int temp=a[i];
			a[i]=a[c];
			a[c]=temp;
		}	
		return a;
	}

四、算法优缺点:算法逻辑简单直观,但时间复杂度较高,算法不稳定。

堆排序

一、什么是堆:堆排序分为大根堆和小根堆两种形式,顾名思义,我们可以把它理解为一个堆(如果学过树的知识,我们可以把它理解为一个完全二叉树),大根堆就是堆顶的数为最大,在二叉树中我们可以定义双亲节点的值大于其子节点的值,从上往下以此类推;小根堆就是双亲节点小于其左右子节点。
二、堆排序的步骤:先建立一个初始堆,即按照数组的序号从上到下,从左到右,建立一个类似完全二叉树的结构,但节点之间没有指针关系,只是把数组摆成了堆的形式。接下来从下到上调整堆,分别拿双亲节点和子节点比较大小,如果双亲节点小于最大子节点,则交换位置,最后我们会得到一个初始的大根堆。接下来我们把堆顶元素(最大)和数组的最后一个元素交换位置,除此最后一个数外,我们继续调整堆,使其满足大根堆的条件,再把堆顶元素和数组倒数第二个元素交换,以此类推,最终整个数组有序(从小到大)。
三、算法分析:
1、最好的情况:O(nlog2 n)
2、最坏的情况:O(nlog2 n)
3、平均时间复杂度:O(nlog2 n)
4、空间复杂度:O(1)
5、稳定性:不稳定(有大量元素的交换)
四、算法实现:

	/**
	 * 堆排序
	 * @param a
	 * @return
	 */
	public void heapSort(int a[]){		
		for(int i=a.length/2;i>=0;i--){			//建初始堆
			HeapAdjust(a,i,a.length); //长度恒为数组长度,修改角标逐渐全部排完
		}		
		for(int i=a.length-1;i>0;i--)
		{
			int temp=a[0]; //交换堆顶和数组末尾,实现有序区
			a[0]=a[i];
			a[i]=temp;			
			HeapAdjust(a, 0, i);  //调整堆,使其满足大根堆
		}			
	}
	/**
	 *堆排序(堆调整)
	 * @param a
	 * @param parent
	 * @param length
	 */
	private void HeapAdjust(int[] a, int parent, int length) {
	     int temp = a[parent]; //暂存该节点值	     
	     int child = 2*parent+1;//获得左孩子节点角标	     
		 while(child<length){     //length取不到,那个点不能修改		     					 
		     if(a[child+1]>a[child]&&child+1<length){ //若右孩子节点大于左孩子节点,则取右孩子节点
		    	 child++;  
		     }			
		     if(temp>=a[child]){   //若父节点大于最大子节点,则满足大根堆条件
		    	 break;
		     }	     
		     a[parent]=a[child];  //向上赋值		     
		     parent=child; //把子节点变为父节点,继续循环查找
		     child = 2*child +1; //确定新的子节点
		 }	     
	     a[parent]=temp;  //插入那个调整前的堆顶元素
	}

四、算法的优缺点:堆排的效率比较高,但是算法不稳定。另外,初始化堆的过程中比较的次数较多,它不适用于小序列。

冒泡排序

一、思路:从第一个和第二个开始,依次比较数组中的相邻数,若第一个数大于第二个数,则交换位置,再比较第二个数和第三个数,若第二个数大于第三个数,则交换,以此类推,最终最大的数会出现在数组的末尾,就像“冒泡”一样。第二趟排序出现第二大的数,放在数组的倒数第二个位置,最终,整个数组有序。
二、算法分析:
1、最好的情况:O(n^2)
2、最坏的情况:O(n^2)
3、平均时间复杂度:O(n^2)
4、空间复杂度:O(1)
5、稳定性:稳定(相同大小的元素不会交换位置)
三、算法实现:

	/**
	 * 冒泡排序
	 * @param a
	 */
	public void sort4(int[] a){
		
		for(int i=a.length;i>1;i--)
		{
           for(int j=0;j<i-1;j++)
			if(a[j]>a[j+1])
			{
				int temp=a[j];
				a[j]=a[j+1];
				a[j+1]=temp;
			}
		}
		
	}

四、算法优缺点:算法比较稳定,但效率低。

快速排序

一、思路:通过的递归的思想也可以实现高效的排序。我们选取一个基准,假设我们取数组中的第一个数为基准数,取出并保存在变量中,然后分别设立左指针和右指针指向数组的两端,右指针左移直到找到第一个比基数小的数,赋值给基数所在的位置,然后左指针向右寻找大于基数的第一个值,赋给右指针;直到两指针相遇,把基数赋给指针指向的位置,数组被指针分为两部分,分别再进行快排,递归直至有序。
二、算法分析:
1、最好的情况:O(nlog₂n)
2、最坏的情况:O(n^2)
3、平均时间复杂度:O(nlog₂n)
4、空间复杂度:O(1)
5、稳定性:不稳定
三、算法实现:

	/**
	 * 快速排序
	 * @param a
	 */
	public void quickSort(int[] a , int low ,int high){		
		if(low>=high)
			return;
		if(a.length<=0)
		    return;
		int left=low;
		int right=high;
		int value = a[left];		
		while(left<right){						
			while(a[right]>=value&&left<right)
			    right--;
			a[left]=a[right];
			while(a[left]<=value&&left<right)
				left++;
			a[right]=a[left];								
		}
		  a[left]=value;
		  quickSort(a, low , left-1);
		  quickSort(a, left+1, high);	      
	}

四、算法的优缺点:快速排序在数组乱序的情况下有相比其他排序很高的效率,但它在排序中涉及到了数的交换,也是一种不稳定的算法,但它的高效性使得这种算法应用广泛。

归并排序

一、思路:归并排序和快排都用到了递归的思想,但和快排有所不同,快排是先把数组以一个基准划分为两部分,再在两个部分中分别递归,即排序和递归交替进行。归并的思路是先把数组不断划分并递归为最小单位,最小单位实现有序,然后向上回溯,把两个单位合并为一个长度是两单位之和的有序的数组,然后再在这个有序数组的层面上继续归并,直至回到第一次调用的位置,归并为一个有序的数组。总之,思路就是自上而下划分为最小单位,再自下而上恢复为有序数组。
二、算法分析:
1、最好的情况:O(nlog₂n)
2、最坏的情况:O(nlog₂n))
3、平均时间复杂度:O(nlog₂n)
4、空间复杂度:O(n)
5、稳定性:不稳定
为什么是O(nlog₂n))?我们在划分为最小子单位的时候,类似于不断二分,时间复杂度为O(log₂n)),此过程中我们把长为n的数组划分为n个单位,我们需要O(n)的空间复杂度来保存子数组。还原数组的过程中时间复杂度为O(n),所以综合来说我们的时间复杂度为O(nlog₂n))。
三、算法实现:
代码分为两部分,一部分是划分最小子数组的方法,一部分是二路归并的方法。在理解这段代码的时候我们可以先从理解二路归并入手,了解它是如何把两个有序数组合并为一个有序数组的,然后只需再走合并的代码流程就可以得到有序数组。

	/**
	 * 归并排序
	 */
	public void mergeSort(int[] a, int low , int high){
		if(low<high) {
			int mid = (low+high)/2; //划分为两个子表			
			mergeSort(a,low,mid);  //使得左半部分有序
			mergeSort(a, mid+1, high); //使得右半部分有序
			merge(a,low,mid,high);  //二路归并方法		
		}
	}
	/**
	 * 二路归并方法
	 */
	private void merge(int[] a, int low, int mid, int high) {
		
		    int[] temp = new int[a.length];
		    for(int i=low;i<=high;i++){       //把数组相应段复制一份
		    	temp[i]=a[i];
		    }
		    int i=low;
		    int j=mid+1;
		    int k=low;
		   while(i<=mid&&j<=high){   //优先存小的值,实现二路归并
			   
			   if(temp[i]<temp[j]){
				   a[k++]=temp[i++];
			   }else{
				   a[k++]=temp[j++];
			   }
		   } 
		   while(i<=mid)  //若有剩余,则插入补齐数组
		   {
			   a[k++]=temp[i++];
		   }
		   while(j<=high)
		   {
			   a[k++]=temp[j++];
		   }		   		
	}

四、算法的优缺点:归并排序速度较快,也比较稳定,但在数据量大的时候,可能会花费相对较多的时间。

基数排序(桶排序)

一、思路:基数排序其实非传统意义上的排序,它是一种关键字排序,我们先对个位数排序,定义一个二维数组,把原数组的数字取个位数存入二维数组(二维数组的纵坐标表示0~9的个位数分类,然后横坐标就是数据存放的累加,二维数组就像是10个桶,桶的深度即可存的最大数据数目,我们通过桶来辅助排序),设一个数组来计数,在存入完毕后,再从个位数为0开始逐个取出重新存入原数组。接下来,我们取原数组各元素的十位数,重新存入清空后的二维数组,即按照十位数排序,再次取出即为有序的数组(假设这里数据都小于100)。
二、算法分析:
1、最好的情况:O(d(n+r))
2、最坏的情况:O(d(n+r))
3、平均时间复杂度:O(d(n+r))
4、空间复杂度:O(n+r)
5、稳定性:稳定
三、算法实现:

	/**
	 * 基数排序(桶排序)
	 * @param a
	 */
	public void radixSort(int[] a , int n){
		    int divisor=1; //定义每一轮的除数
		    int[][] bucket = new int[10][10]; //定义10*10二维数组
		    int[] count = new int[10]; //用来表示每一位的指针位置,防止数据覆盖		    		    
		  while(divisor<100)  //确定循环重数
		  {
			    for(int i=0; i<n;i++)
			    {
			    	int temp =(a[i]/divisor)%10; //取个位数
			    	bucket[temp][count[temp]++]=a[i]; //把数据存入二维数组
			    }		    		    			  
			    int k=0;
			    for(int i=0;i<10;i++)  //把桶中的数据取出到数组
			    {
			    	for(int j=0; j<count[i] ; j++) 
			    	{
			    		a[k++]=bucket[i][j];			    		
			    		bucket[i][j]=0;  //每次赋值结束,数组相应位置清零
			    	}
			    	count[i]=0; //计数器清空
			    }
			    divisor*=10; 
		  }
	}

四、算法优缺点:桶排序速度快,而且在数据范围分布确定时,易于筛选;它的局限性也明显,如果数据有负数,会影响排序,而且它浪费了大量的空间复杂度。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值