七大排序Java实现

 

1.冒泡排序

public static void sort(int []nums)
    {
        for(int i=0;i<nums.length-1;i++)
        {
            for(int j=0;j<nums.length-1-i;j++)
            {
                if(nums[j]>nums[j+1])
                    nums[j]=nums[j+1]+(nums[j+1]=nums[j])*0;//互换值
            }
        }
    }

2.选择排序

public static void sort(int []nums)
    {
        for(int i=0;i<nums.length-1;i++)
        {
        	int min=nums[i];
        	int min_j=i;
            for(int j=i+1;j<nums.length;j++)
            {
                if(min>nums[j])
                {
                	min=nums[j];
                	min_j=j;
                } 
            }
            nums[i]=nums[min_j]+(nums[min_j]=nums[i])*0;
        }
    }

3.插入排序 

public static void sort(int []nums)
    {
       for(int i=0;i<nums.length-1;i++)
       { 
    	   int temp=nums[i+1];
    	   for(int j = i;j>=0;j--)
    	   {
    		   if(temp<nums[j])
    		   {
    			  nums[j+1]=nums[j];
    			  nums[j]=temp;
    		   }
    		   else {
    			   break;
    		   }
    		   
    	   }
    	   
       }

    }

4.希尔排序 

public static void sort(int []nums)
    {
		int gap=nums.length/2;//增量
		for(;gap>0;gap/=2)//对增量逐渐减半
		{
			for(int i=gap;i<nums.length;i++)//开始插入排序
			{
				int cur=nums[i];//移动值
				for(int j=i-gap;j>=0;j-=gap)
				{
					if(cur<nums[j])//和前面已经排好序的位置上面的数逐个比较
					{
						nums[j+gap]=nums[j];//将正在比较位置的数赋给后一位置
						nums[j]=cur;//当前位置设为移动值
					}
					else 
						break;
				}
				
			}
		}
		for(int k =0;k<nums.length;k++)
        	System.out.print(nums[k]+" ");
        System.out.println();
    }

5.归并排序

public static void sort(int []nums,int left,int right) {
		int mid=(left+right)/2;
		if(right>left)
		{
			sort(nums, left, mid);//将左边递归分割
			sort(nums, mid+1, right);//将右边递归分割
			merge(left,mid,right,nums);	//按顺序合并分组
		}
			
	}
	public static void merge(int left,int mid,int right,int nums[]) {
		int i=left;
		int j=mid+1;
		int k=0;
		int a[]=new int[right-left+1];
		while(j<=right&&i<=mid) {
			if(nums[i]>nums[j])
			{
				a[k++]=nums[j++];
			}
			else {
				a[k++]=nums[i++];
			}
		}
		while (i<=mid) {
			a[k++]=nums[i++];
		}
		while(j<=right)
		{
			a[k++]=nums[j++];
		}
		for(k=0;k<a.length;k++)
		{
			nums[left+k]=a[k];
		}
	}

6.快速排序

public static void sort(int []a,int left,int right)
    {
        int i=left,j=right;
        int x=a[left];
        int gps=left;
        if(left>=right)
        	return;
        while(i<j)
        {
        	while(i<j&&x<=a[j])
        		j--;
        	a[gps]=a[j];
        	gps=j;
        	while(i<j&&x>=a[i]) 
        		i++;
        	a[gps]=a[i];
        	gps=i;
        	
        }
        a[gps]=x;
        sort(a,left,gps);
        sort(a,gps+1,right);
    }

7.堆排序 

public static void sort(int nums[])
	{
		buildHeap(nums);//构建最大堆  时间复杂度N
		for(int i=nums.length-1;i>=0;i--)//N
		{
			sink(nums,0,i);//对根元素进行下沉 logN
			int temp=nums[i];
			nums[i]=nums[0];
			nums[0]=temp;
		}
	}
	
	public static void sink(int a[],int index,int l)//下沉
	{
		if(index>=a.length/2)//下沉到叶子节点返回
			return;
		int left=index*2+1;
		int right=index*2+2;
		int parent=index;
		if(left<=l&&a[parent]<a[left])
			parent=left;
		if(right<=l&&a[parent]<a[right])
			parent=right;
		if(index!=parent)//取父左右三个节点中的最大值进行交换
		{
			int temp=a[index];
			a[index]=a[parent];
			a[parent]=temp;
			sink(a,parent,l);
		}		
	}
	
	public static void buildHeap(int a[])
	{
		for(int i=a.length/2;i>0;i--)
		{
			sink(a,i,a.length-1);
			
		}
	}