冒泡，选择，插入，快速，归并，堆，桶排序总结（附代码实现）

选择排序

// An highlighted block
public static void ChooseSort(int[] nums) {
	  for(int i=0;i 
插入排序
 
// An highlighted block
 public static void InsertSort(int[] nums) {
	  for(int i=1;i0;j--) {
			  if(nums[j] 
冒泡排序
 
public static void BubbleSort(int[] nums) {
	  for(int i=0;inums[j]) {
				  swap(nums, i, j);
			  }
		  }
	  }
 }

 
归并排序
 
  public static void MergeSort(int[] nums) {
	  partion(nums,0,nums.length-1);  
  }
	  
	  public static void partion(int[] nums,int l,int r) {
		  if(l>=r)
			  return;
		  int mid=l+((r-l)>>1);
		  partion(nums,l,mid);
		  partion(nums,mid+1,r);
		  merge(nums,l,mid,r);
	  }
	  public static void merge(int[] nums,int l,int mid,int r) {
		  int[] cur=new int[r-l+1];
		  int p1=l,p2=mid+1,index=0;
		  while(p1<=mid&&p2<=r) {	  
			 cur[index++]=nums[p1]<=nums[p2]?nums[p1++]:nums[p2++];
		 }
		  while(p1<=mid) {
			  cur[index++]=nums[p1++];
		  }
		  while(p2<=r) {
			  cur[index++]=nums[p2++];
		  }
		  for(int i:cur) {
			  nums[l++]=i;
		  }
  }

 
//堆排序
 
 public static void HeapSort(int[] nums) {
		 PriorityQueue queue=new PriorityQueue<>();
		 for(int i=0;i 
//堆排序（不借助额外数据结构）最小堆
 
  public static void HeapSort(int[] nums) {
		  if(nums.length==1)
			  System.out.println(nums[0]);
		buildTree(nums);
		int len=nums.length-1;
		while(len>0) {
		swap(nums, 0, len);
		 modify(nums,len);
		 len--;
		}
		
	  }
	  public static void buildTree(int[] nums) {   //当前结点为i时，父结点序号为（i-1）/2
		  for(int i=0;inums[(i-1)/2]) {
				 swap(nums, i, (i-1)/2);
				  i=(i-1)/2;
			  }
			  i=cur;
		  }
	  }
	  public static void modify(int[] nums,int len) {
		 if(len<=1)
			 return ;
		 int i=0;
		while(i=nums[right]?left:right;
			  swap(nums, i, cur);
			  i=cur;
		 }else if(left 
//桶排序
 
    public static void BucketSort(int[] nums) {
  	  int maxdigit=0,max=Integer.MIN_VALUE,digit=1;
  	  int[] bucket=new int[nums.length];//新建一个辅助数组
  	//获取最大值的位数
  	for(int i=0;imax) {
  			max=nums[i];
  		}
  		
  	}
  	while(max!=0) {
  		maxdigit++;
  		max=max/10;
  	}
  	  int[] count=new int[10];//每位数0~9
  	 while(maxdigit>0) {		 
  	    digit*=10;
  	  for(int i=0;i=0;i--) {
  		  bucket[count[(nums[i]%digit)/(digit/10)]-1]=nums[i];
  		  count[(nums[i]%digit)/(digit/10)]--;
  	  }
  	  for(int i=0;i 
快速排序
 划分了大于，小于，等于区
 
	  public static void QuickSort(int[] nums) {
		  if(nums.length<2)
			  return ;
		QuickSort(nums,0,nums.length-1);
		
	  }
	  public static void QuickSort(int[] nums,int l,int r) {
		  if(l>=r)
		  return ;
		  int part=l+new Random().nextInt(r-l); //随机挑选基准数
		  swap(nums, part, r);
		  int[] a=partionQ(nums,l,r);
	      QuickSort(nums,l,a[0]);
	
		  QuickSort(nums,a[1],r);
		  
	  }
	  public static  int[] partionQ(int[] nums,int l,int r) {
         int i=l-1,j=r+1;  //i为小于区，j为大于区
          while(lnums[r]) {
            	swap(nums, l, --j); 
        	}else {
        		l++;
        	}
         }
       return new int[]{i,j};
		  
	  }
 
交换代码
 
public static void swap(int[] nums,int i,int j) {
		if(i==j)
			return ;
		nums[i]=nums[i]^nums[j];
		  nums[j]=nums[i]^nums[j];
		  nums[i]=nums[i]^nums[j];
	}