基本排序算法

1  ，冒泡排序算法

多的不说，直接上代码，分析和说明都有注释

import java.util.Arrays;

/*
 * 冒泡排序算法
 * 算法简要说明：
 * 例如有一个无序数组{10，23，1，8}
 * 1，先从数组的第一个位置开始，与他的下一个数字进行比较，如果后边的数字比他小，则交换位置，否则，下标+1
 * 2， 每一次排序，都会选出当前数组最大的数字，放到排序数组的最后一位
 * 3，第一次排序需要比较的次数为：3，第二次为：2，第三次为：1
 * 4，据此类推，长度为N的数组，第一需要比较的次数为N-1，第二次为：N-2 ，最后一次为1
 * */
public class BuddleSort {
	
	
	//交换数组i和j 位置上的元素
	public static void swap(int [] arr,int i,int j) {
		int temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}
	
	
	
	//得到一个长度随机，数组元素随机的数组，size:数组最大长度，value:元素最大值
	public static int [] getRadomArray(int size,int value) {
		int [] arr=new int [(int)(size*Math.random())];
		
		for(int i=0;i<arr.length;i++) {
			arr[i]=(int)(Math.random()*value)-(int)(Math.random()*value);
		}
		return arr;
	}
	
	//判断两个数组是否相等
	public static boolean isEquals(int [] arr1,int [] arr2) {
		if(arr1.length!=arr2.length||(arr1==null&&arr2!=null)||(arr2==null&&arr1!=null)) {
			return false;
		}
		if(arr1==null&&arr2==null) {
			return true;
		}
		int size=arr1.length;
		for(int i=0;i<size;i++) {
			if(arr1[i]!=arr2[i]) {
				return false;
			}
		}
		return true;
	}
	
	//冒泡排序
	public static int [] buddleSort(int [] arr) {
		if(arr==null||arr.length<2) {
			return arr;
		}
		for(int end=arr.length-1;end>=0;end--) {
			for(int i=0;i<end;i++) {
				if(arr[i]>arr[i+1]) {
					swap(arr,i,i+1);
				}
			}
		}
		return arr;
	}
	
	//打印数组
	public static void printArray(int [] arr) {
		if(arr==null||arr.length<1) {
			System.out.println("非法长度");
		}else {
			for(int i: arr) {
				System.out.print(i+",");
			}
			System.out.println();
		}
	}
	
	//拷贝一个数组
	public static int [] copyArray(int [] arr2) {
		if(arr2!=null||arr2.length>0) {
			int [] arr1=new int[arr2.length];
			int size=arr2.length;
			for(int i=0;i<size;i++) {
				arr1[i]=arr2[i];
			}
			return arr1;
		}else {
			return arr2;
		}
	}
	
	//测试用例，随机生成50000000个数组，然后分别用buddleSort()方法和Arrays.Sort()进行排序，
	//如果两个方法的结果相等，则说明buddleSort()方法无误，打印Nice，只要有一组不相等，则退出循环，打印当前数组
	public static void main(String [] args0) {
		int [] arr=buddleSort(new int[]{3,9,1});
		int time=50000;
		int arr2[]=new int[] {};
		boolean sucess=true;
		for(int i=0;i<time;i++) {
			int [] arr1=getRadomArray(10,10);
			arr2=copyArray(arr1);
			Arrays.sort(arr1);
			int [] arr3=buddleSort(arr1);
			if(!isEquals(arr1, arr3)) {
				sucess=false;
			}
		}
		if(!sucess) {
			System.out.println("FUCKING !");
			printArray(arr2);
		}else {
			System.out.println("Nice!");
		}
	}

import java.util.Arrays;
/*
 * 选择排序
 * */
public class SelectSort {
	
	
	//选择排序
	public static int [] selectSort(int [] arr) {
		int index=0;
		int len=arr.length;
		for(int i=0;i<len;i++) {
			for(int j=i+1;j<len;j++) {
				if(arr[j]<arr[index]) {
					util.swap(arr, index, j);
				}
			}
		}
		return arr;
	}
	
	
	public static void main(String [] arg0) {
		int [] arr=selectSort(new int[]{3,9,1});
		int time=50000;
		int arr2[]=new int[] {};
		boolean sucess=true;
		for(int i=0;i<time;i++) {
			int [] arr1=util.getRadomArray(10,10);
			arr2=util.copyArray(arr1);
			Arrays.sort(arr1);
			int [] arr3=selectSort(arr1);
			if(!util.isEquals(arr1, arr3)) {
				sucess=false;
			}
		}
		if(!sucess) {
			System.out.println("FUCKING !");
			util.printArray(arr2);
		}else {
			System.out.println("Nice!");
		}
	}
	}

/*
 * 插入排序
 * 从数组第二个位置开始，依次和他之前的元素比较，如果之前的元素比他小，那么就不变，反之则换位置
 * */
public class InsertSort {
	
	
	//插入排序
	public static int [] insertSort(int [] arr) {
		int len=arr.length;
		for(int i=0;i<len;i++) {
			for(int j=i-1;j>0;j--) {
				if(arr[j]<arr[j-1]) {
					util.swap(arr, j, j-1);
				}
			}
		}
		return arr;
	}