JAVA实现冒泡、归并、希尔、堆排、快速、插入、简单选择、排序算法

冒泡排序

public void bubbleSort(int []nums)
	{
		int exchange=nums.length-1;
		while(exchange!=0)
		{
			int bound=exchange;
			exchange=0;
			for(int i=0;i<bound;i++)
			{
				if(nums[i]>nums[i+1])
				{
					int temp=nums[i];
					nums[i]=nums[i+1];
					nums[i+1]=temp;
					exchange=i;
				}
			}
		}
		System.out.println(Arrays.toString(nums));
	}

归并排序

public  void mergerSort(int[] arr,int low,int high){
		if(low<high){ 
			int mid=(low+high)/2; 
			mergerSort(arr,low,mid);//左边排序+分解
			mergerSort(arr,mid+1,high);//右边排序+分解 
			merge(arr,low,mid,high);//合并+排序 
			} 
		}
public  void merge(int[] arr,int low,int mid,int high)//合并 
	{ 
		int i=low;
		int j=mid+1; 
		int k=0;
		int temp[]=new int[high-low+1];//临时数组存放元素
		while(i<=mid && j<=high){ 
			if(arr[i]<arr[j])
				temp[k++]=arr[i++];
			else
				temp[k++]=arr[j++]; 
			} 
		while(i<=mid)
			temp[k++]=arr[i++];
		while(j<=high)
			temp[k++]=arr[j++];
		for(int x=0;x<temp.length;x++)
			arr[x+low]=temp[x];
	}

希尔排序

public void shellSort(int []nums)
	{
		for(int d=nums.length/2;d>=1;d=d/2)
		{
			for(int i=d;i<nums.length;i++)
			{
				int target=nums[i];
				int j=i-d;
				for(;j>=0&&nums[j]>target;j-=d)
				{
					nums[j+d]=nums[j];
				}
					nums[j+d]=target;
			}
		}
		System.out.println(Arrays.toString(nums));
	}

堆排

//堆排序
	public void heapSort(int []nums)
	{
		for(int i=nums.length/2-1;i>=0;i--)
			shift(nums,i,nums.length-1);
		for(int j=nums.length-1;j>0;j--)
		{
			int temp=nums[j];
			nums[j]=nums[0];
			nums[0]=temp;
			shift(nums, 0, j-1);
		}
	}
	public void shift(int []nums,int k,int m)
	{
		int i=k;
		int j=2*k+1;
		while(j<=m)
		{
			if(j<m&&nums[j]<nums[j+1])
				j++;
			if(nums[i]>nums[j])
				break;
			else
			{
				int temp=nums[i];
				nums[i]=nums[j];
				nums[j]=temp;
				i=j;
				j=2*i+1;
			}	
		}
	}

快速排序

	//快速排序
    public void quickSort(int []nums,int start,int end)
	{
		if(start<end)
		{
			int pivot=partition(nums,start,end);
			quickSort(nums,start,pivot-1);
			quickSort(nums, pivot+1, end);
		}
	}
	public int partition(int []nums,int i,int j)
	{
		while(i<j)
		{
			while(i<j&&nums[i]<nums[j])
				j--;
			if(i<j)
			{
				int temp=nums[i];
				nums[i]=nums[j];
				nums[j]=temp;
				i++;
			}
			while(i<j&&nums[i]<nums[j])
				i++;
			if(i<j)
			{
				int temp=nums[i];
				nums[i]=nums[j];
				nums[j]=temp;
				j--;
			}
		}
		return i;
	}
	

插入排序

//直接插入排序
	public void insertSort(int []nums)
	{
		
		for(int i=1;i<nums.length;i++)
		{
			int target=nums[i];
			int j=i-1;
			for(;j>=0&&nums[j]>target;j--)
			{
				
				nums[j+1]=nums[j];
			}
			
				nums[j+1]=target;
			
		}
	}
	//最好情况：n-1
	//最坏情况：1,2,...,n-1   n(n-1)/2

简单选择排序

public void selectSort(int []nums)
	{
		for(int i=0;i<nums.length;i++)
		{
			for(int j=i;j<nums.length;j++)
			{
				if(nums[j]<nums[i])
				{
					int temp=nums[j];
					nums[j]=nums[i];
					nums[i]=temp;
				}
			}
		}
	}