基本排序算法Java实现

1、冒泡排序：

/*冒泡排序（Bubble Sort，台湾另外一种译名为：泡沫排序）是一种简单的排序算法。
 * 它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
 * 走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
 * 这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
 * 
 * 冒泡排序对n个项目需要O(n^2)的比较次数，且可以原地排序。
 * 尽管这个算法是最简单了解和实现的排序算法之一，但它对于少数元素之外的数列排序是很没有效率的。
 * 
 * 冒泡排序是与插入排序拥有相等的运行时间，但是两种算法在需要的交换次数却很大地不同。
 * 在最好的情况，冒泡排序需要O(n^2)次交换，而插入排序只要最多O(n)交换。
 * 冒泡排序的实现（类似下面）通常会对已经排序好的数列拙劣地运行（O(n^2)），而插入排序在这个例子只需要O(n)个运算。
 * 因此很多现代的算法教科书避免使用冒泡排序，而用插入排序取代之。
 * 冒泡排序如果能在内部循环第一次运行时，使用一个旗标来表示有无需要交换的可能，也可以把最好的复杂度降低到O(n)。
 * 在这个情况，已经排序好的数列就无交换的需要。若在每次走访数列时，把走访顺序反过来，也可以稍微地改进效率。
 * 有时候称为鸡尾酒排序，因为算法会从数列的一端到另一端之间穿梭往返。
 * 
 * 冒泡排序算法的运作如下：
 * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
 * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
 * 针对所有的元素重复以上的步骤，除了最后一个。
 * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。*/

public class BubbleSort {
	public static void main(String [] args){
		int[] number = {95,45,15,78,84,51,24,12};
		for(int i=0;i<number.length-1;i++){
			for(int j=0;j<number.length-i-1;j++){
				if(number[j]>number[j+1]){
					int temp=number[j];
					number[j]=number[j+1];
					number[j+1]=temp;
				}
			}
		}
		for(int num:number){
			System.out.print(num+" ");
		}
	}
}

2、插入排序：

/*一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
 * 
 * 从第一个元素开始，该元素可以认为已经被排序
 * 取出下一个元素，在已经排序的元素序列中从后向前扫描
 * 如果该元素（已排序）大于新元素，将该元素移到下一位置
 * 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
 * 将新元素插入到该位置后
 * 重复步骤2~5
 * 如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。
 * 该算法可以认为是插入排序的一个变种，称为二分查找插入排序。*/
public class InsertionSort {
	public static void main(String[] args){
		int[] number = {95,45,15,78,84,51,24,12};
		for(int i=1;i<number.length;i++){
			int temp=number[i];
			int j=i;
			//短路，先比较j>0
			while(j>0&&number[j-1]>temp){
				number[j]=number[j-1];
				j--;
			}
			number[j]=temp;
			
		}
		for(int num:number){
			System.out.print(num+" ");
		}
	}
}

3、快速排序：

/*快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。
 * 
 * 步骤为：
 * 从数列中挑出一个元素，称为"基准"（pivot），
 * 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。
 * 在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
 * 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
 * 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。
 * 虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
*/
public class QuickSort {
	public static void main(String[] args){
		Integer[] number = {95,45,15,78,84,51,24,12};
		Comparator1 comparator1= new Comparator1();
		sort(number,comparator1);
		
		for(Integer num:number){
			System.out.print(num+"");
		}
	}
	
	public static final Random RND=new Random();
	
	private static void swap(Object[] array,int i,int j){
		Object temp=array[i];
		array[i]=array[j];
		array[j]=temp;
	}
	private static<E> int partition(E[]array,int begin,int end,Comparator<? super E> cmp){
		int index=begin+RND.nextInt(end-begin+1);
		E pivot=array[index];
		swap(array,index,end);
		for(int i=index=begin;i<end;i++){
			if(cmp.compare(array[i], pivot)<0){
				swap(array,index++,i);
			}
			
		}
		swap(array,index,end);
		return index;
	}
	private static<E> void qsort(E[] array,int begin,int end,Comparator<? super E> cmp){
		if(end>begin){
			int index=partition(array, begin, end, cmp);
			qsort(array,begin,index-1,cmp);
			qsort(array,index+1,end,cmp);
			
		}
	}
	public static<E> void sort(E[] array,Comparator<? super E> cmp){
		qsort(array,0,array.length-1,cmp);
	}
	
}
class Comparator1 implements Comparator<Integer>{

	@Override
	public int compare(Integer o1, Integer o2) {
		// TODO Auto-generated method stub
		if(o1<o2){
			return -1;
		}else if(o1>02){
			return 1;
		}
		return 0;
	}
}

4、选择排序：

public class SelectionSort {
	public static void main(String[] args){
		int[] number = {95,45,15,78,84,51,24,12};
		
		for(int i=0;i<number.length;i++){
			int maxnum=number[i];
			//
			int flag=i;
			for(int j=i;j<number.length;j++){
				if(maxnum<number[j]){
					maxnum=number[j];
					flag=j;
				}
			}
			number[flag]=number[i];
			number[i]=maxnum;
		}
		for(int num:number){
			System.out.print(num+" ");
		}
	}
}

5、归并排序：

实现的时候忘记将重新排序的数组返回，导致排序失败。

public class MergeSort {
	public static void main(String[] args){
		int[] number = {95,45,15,78,84,51,24,12,1};
		int[] result=mergeSort(number);
		for(int num:result){
			System.out.print(num+" ");
		}
	}
	private static int[] mergeSort(int [] arr){
		if(arr.length==1){
			return arr;
		}
		int half=arr.length/2;
		System.out.println("half:"+half);
		int [] arr1=new int[half];
		int [] arr2=new int[arr.length-half];
		
		System.arraycopy(arr, 0, arr1, 0, arr1.length);
		System.arraycopy(arr, half, arr2, 0, arr2.length);
		//
		System.out.print("arr1:");
		for(int arrr1:arr1){
			System.out.print(arrr1+" ");
		}
		System.out.println();
		System.out.print("arr2:");
		for(int arrr1:arr2){
			System.out.print(arrr1+" ");
		}
		System.out.println();
		//改变数组忘了传回来
		arr1=mergeSort(arr1);
		arr2=mergeSort(arr2);
		System.out.print("arr1+arr2 ");
		for(int arrr1:arr1){
			System.out.print(arrr1+" ");
		}
		for(int arrr1:arr2){
			System.out.print(arrr1+" ");
		}
		System.out.println();
		int[] result=mergeSortSub(arr1, arr2);
		System.out.print("re: ");
		for(int re:result){
			System.out.print(re+" ");
		}
		System.out.println();
		return result;
	}
	private static int[] mergeSortSub(int[] arr1,int[] arr2){
		int i=0,j=0,k=0;
		int[] result1=new int[arr1.length+arr2.length];
		while(i<arr1.length&&j<arr2.length){
			if(arr1[i]<arr2[j]){
				System.out.println("i:"+i);
				result1[k]=arr1[i];
				i=i+1;
			}else{
				System.out.println("j:"+j);
				result1[k]=arr2[j++];
			}
			System.out.println("k:"+k);
			k++;
		}
		for(;i<arr1.length;i++){
			System.out.println("i:"+i);
			result1[k++]=arr1[i];
		}
		for(;j<arr2.length;j++){
			System.out.println("j:"+j);
			result1[k++]=arr2[j];
		}
		return result1;
	}
}

6、计数排序

public class CountSort {
	public static void main(String[] args){
		int a[]={100,93,97,92,96,99,92,89,93,97,90,94,92,95};
		int[] b=countSort(a);
		for(int i:a){
			System.out.print(i+" ");
		}
		System.out.println();
		for(int i:b){
			System.out.print(i+" ");
		}
	}
	public static int[] countSort(int[] arr){
		int[] b=new int[arr.length];
		int max=arr[0];
		int min=arr[0];
		for(int i:arr){
			if(i>max){
				max=i;
			}
			if(i<min){
				min=i;
			}
		}
		//
		int k=max-min+1;
		int[] c=new int[k];
		/*for(int i:c){
			System.out.print(i);
		}
		System.out.println();*/
		for(int i=0;i<arr.length;i++){
			c[arr[i]-min]+=1;
		}
		/*for(int i:c){
			System.out.print(i+" ");
		}
		System.out.println();*/
		for(int i=1;i<c.length;i++){
			c[i]=c[i]+c[i-1];
		}
		/*for(int i:c){
			System.out.print(i+" ");
		}
		System.out.println();*/
		for(int i=arr.length-1;i>=0;--i){
			b[--c[arr[i]-min]]=arr[i];
		}
		return b;
	}
}