排序

排序

1.冒泡排序

public class BubbleSort{
	public static void bubblesort(int[] arr){
		if(arr==null||arr.length<2){
			return;
		}
		for(int i=arr.length-1;i>=0;i--){
			for(int j=0;j<i;j++){
				if(arr[j]>arr[j+1]){
					swap(arr,j,j+1);
				}
			}
		}
	}
	public static void swap(int[] arr,int i,int j){
		arr[i]=arr[i]^arr[j];
		arr[j]=arr[i]^arr[j];
		arr[i]=arr[i]^arr[j];
	}
 }

2.选择排序

public class SelectionSort{
	public static void selectionSort(int[] arr){
		if(arr==null||arr.length<2){
			return ;
		}
		for(int i=0;i<arr.length-1;i++){
			int minindex=i;
			for(int j=i+1;j<arr.length;j++){
				mininindex=arr[minindex]>arr[j]?j:mininindex;
			}	
			if(minindex!=i){
				swap(arr,i,mindex);
			}
		}
	}
	public static void swap(int[] arr,int i,int j){
		arr[i]=arr[j]^arr[i];
		arr[j]=arr[i]^arr[j];
		arr[i]=arr[i]^arr[j];
	}
}

3.插入排序

public class InsertSort{
	public static void insertSort(int[] arr){
		if(arr.length<2||arr==null){
			return ;
		}
		for(int i=1;i<a.length-1;i++){
			for(int j=i-1;j>=0&&arr[j]>arr[j+1];j--){
				swap(arr,j,j+1);
			}
		}
	}
	public static void swap(int[] arr,int i,int j){
	}
	
}

4.归并排序

public class MergeSort{
	public static void mergeSort(int[] arr){
		if(arr.length<2||arr==null){
			return ;
		}
		mergeSort(arr,0,arr.length-1);
	}
	public static void mergeSort(int[] arr,int l,int r){
		if(l==r){
			return;
		}
		int mid=l+(r-l)>>1;
		mergeSort(arr,l,mid);
		mergeSort(arr,mid+1,r);
		merge(arr,l,mid,r);
	}
	public static void merge(int[] arr,int l,int mid,int r){
		int[] res=new int[r-l+1];
		int i=0;
		int p1=l;
		int p2=mid+1;
		while(p1<=mid&&p2<=r){
			res[i++]=arr[p1]>arr[p2]?arr[p2++]:arr[p1++];
		}
		while(p1<=mid){
			res[i++]=arr[p1++];
		}
		while(p2<=r){
			res[i++]=arr[p2++];
		}
		for(int j=0;j<res.length;j++){
			arr[left+j]=res[j];
		}
	}
}

5.快速排序

public class QuickSort{
	public static void quicksort(int[] arr){
		if(arr.length<2||arr==null){
			return;
		}
		quicksort(arr,0,arr.length-1);
	}
	public static void quicksort(int[] arr,int l,int r){
		if(l<r){
			swap(arr,l+(int)(Math.random()*(r-l+1)),r);
			int[] p=partition(arr,l,r);
			quicksort(arr,l,p[0]-1);
			quicksort(arr,p[1]+1,r);
		}
	}
	public static int[] partition(int[] arr,int l,int r){
		int less=l-1;
		int more=r;
		while(l<more){
			if(arr[l]<arr[r]){
				swap(arr,++less,l++);
			}
			else if(arr[l]>arr[r]){
				swap(arr,--more,l);
			}
			else{
				l++;
			}
		}
		swap(arr,more,r);
		return new int[]{less+1,more};
	}
	public static void swap(int[] arr,int i,int j){
	}
}

6.堆排序

public class HeapSort{
	public static void heapsort(int[] arr,int length){
		for(int i=0;i<length;i++){
			heapinsert(arr,i);
		}
		int heapsize=length;
		swap(arr,0,--heapsize);
		while(heapsize>0){
			heapify(arr,0,heapsize);
			swap(arr,0,--heapsize);
		}
		//heapinsert:新节点加入进来并向上调整为大根堆过程
		public static void heapinsert(int[] arr,int i){
			while(arr[index]>arr[(index-1)/2]){
				swap(arr,index,(index-1)/2);
				index=(index-1)/2;
			}
		}
		//heapify:假设一个值变小了，重新调整为大根堆过程
		public static void heapify(int[] arr,int index,int length){
			int left=2*index+1;
			while(left<length){
				int largest=(left+1)<length&&arr[left]<arr[left+1]?left+1:left;
				largest=arr[index]>arr[largest]?index:largest;
				if(largest==index){
					break;
				}
				swap(arr,index,largest);
				index=largest;
				left=2*index+1;
			}
		}
		public static void swap(int[] arr,int i,int j){
		}
	}
}