我要做技术！！-java基础篇学习笔记&理解6---冒泡，选择，插入， 归并排序算法

常用的集中排序算法及实现

1.冒泡法

• 算法描述：假设总共有n个元素需要排序，从第一位开始比较相邻两个元素，如果此次比较的首位元素比后位元素大，则交换顺序（让大元素排到后面），比较范围是n。第一次比较完之后，最大值应该排到末位，然后进行第二次比较，比较范围是n-1…依次类推，直到比较了n-1次之后这个排序完成。
• e.g代码实现

package com.leeyu.testsort;

import java.util.ArrayList;
import java.util.List;

/**
 * 冒泡法排序实现
 * @author lijie
 *
 */
public class TestSortMethod1 {
public static void main(String[] args) {
	int[] array=new int[20];
	//数组list中添加20个随机数
	for(int i=0;i<20;i++) {
		array[i]= (int)Math.round(Math.random()*20);
	}
	//输出一下list集合中的值
	int num=0;
	for(int i:array) {
		System.out.print(i+" ");
		num++;
		if(num%5==0) {
			System.out.println();
		}
	}
	//使用冒泡法排序
	//总循环次数n-1
	for(int i=1;i<array.length;i++) {
		//内循环次数n-i
		for(int j=0;j<array.length-i;j++) {
			//如果比较的首位元素比末尾元素大则交换元素
			if(array[j]>array[j+1]) {
				int tmp=array[j+1];
				array[j+1]=array[j];
				array[j]=tmp;
			}
		}
	}
	System.out.println("**********");
	//打印测试结果
	num=0;
	for(int i:array) {
		System.out.print(i+" ");
		num++;
		if(num%5==0) {
			System.out.println();
		}
	}
}
}
//使用了随机数所以结果可能不同，但是排序结果肯定是从小到大。
结果----------------------------
8 3 1 7 15 
9 12 17 5 12 
2 6 4 3 6 
1 6 9 14 5 
**********
1 1 2 3 3 
4 5 5 6 6 
6 7 8 9 9 
12 12 14 15 17 

选择排序

• 算法描述：依旧是排序n个元素，用第一个元素依次对比剩下的元素，如果后面元素比第一位元素小，则记录最小元素索引，等全部元素比对完成之后，交换记录的最小元素下标对应的元素和首位元素，之后再从第二位元素开始比对，知道比对完n-1个元素。
• e.g.算法实现

package com.leeyu.testsort;
/**
 * 测试选择排序算法
 * @author lijie
 *
 */
public class TestSortMethod2 {
public static void main(String[] args) {
	//同样使用随机数赋值
	int[] array=new int[10];
	//向array中插入10个不同的1-10之间的整数。
	int[] nums=new int[]{1,2,3,4,5,6,7,8,9,10};
	for(int i=0;i<array.length;i++) {
			int index=(int)Math.round((Math.random()*(nums.length-i-1)));
			array[i]=nums[index];
			nums[index]=nums[nums.length-1-i];
	}
	//打印输出结果
	for(int i:array) {
		System.out.print(i+" ");
	}
	System.out.println("************");
	//排序算法排序
	//外循环控制循环次数n-1
	for(int i=0;i<array.length-1;i++) {
		//把最小值的索引初始化成循环首位
		int min=i;
		//内循环对比最小值索引对应的元素和后面所有的元素大小
		//用min保存每次比较的最小值得索引
		for(int j=i;j<array.length-1;j++) {
			min=array[min]>array[j+1]?(j+1):min;
		}
		//把循环首位元素与最小值交换，之后进入下次循环
		int tmp=array[i];
		array[i]=array[min];
		array[min]=tmp;
	}
	//打印输出结果
		for(int i:array) {
			System.out.print(i+" ");
		}
}
}
结果------------------------------------------------
6 3 5 1 10 9 2 4 7 8 ************
1 2 3 4 5 6 7 8 9 10 

插入法排序

• 描述：对于n个需要排序的元素，首先取出第二位元素和首位元素进行比较，若第二位元素要小，则把第二位元素插入到首位之前；然后取出第三位元素，先和第二位元素比较（此时第二位元素已经比首位元素大），如果比之要小，在和首位比较，若比首位小，则插入首位，若比首位大则插入到第二位…依次类推。
  e.g

package com.leeyu.testsort;
/**
 * 插入法排序实现
 * @author lijie
 *
 */
public class TestSortMethod3 {
	static int count=0;
public static void main(String[] args) {
	int[] array=new int[10];
	TestSortMethod3 testSortMethod3=new TestSortMethod3();
	for(int i=0;i<array.length;i++) {
		int num=(int)Math.round(Math.random()*9+1);
//		System.out.println(num);
		//判断是否给首位元素赋值
		if(i!=0) {
			//不是首位元素时，需要判断随机数的值是否和数组中存在的数值相等。
			//相等时更新随机数，计数器增加，继续判断
			while(testSortMethod3.isEqualToArray(num, array,i)) {
				num=(int)Math.round(Math.random()*9+1);
				TestSortMethod3.count++;
			}
			//不等时赋值
			array[i]=num;
		}else {
			//给首位元素赋值
			array[i]=num;
		}
	}
	//记录循环次数
	System.out.println(TestSortMethod3.count);
	//输出结果
	for(int i:array) {
		System.out.print(i+" ");
	}
	//插入法排序
	for(int i=1;i<array.length;i++) {
		int tmp=array[i];
		int j=i-1;
		for(;j>=0&&tmp<array[j];j--) {
			array[j+1]=array[j];
		}
		array[j+1]=tmp;
	}
	System.out.println("***************");
	for(int i:array) {
		System.out.print(i+" ");
	}
}
//判断传入的数值是否存在于数组的前j位中。
public boolean isEqualToArray(int i,int[] array,int j) {
	boolean flag=false;
	for(int n=0;n<j;n++) {
		if(i==array[n]) {
			flag=true;
		}
	}
	return flag;
}

}
结果---------------
5
6 7 1 9 4 5 2 3 8 10 ***************
1 2 3 4 5 6 7 8 9 10 

归并排序

• 描述：把相邻两个数据看做一个整体（一共有n/2个整体），进行排序，完成之后得到n/2个有序的子序列，然后把相邻两个子序列看做一个整体进行排序，得到n/4个有序的子序列…直到最后得到一个子序列。
• e.g

package com.leeyu.testsort;

import java.util.Arrays;

/**
 * 归并算法实现
 * @author lijie
 *
 */
public class TestSortMethod4 {
public static void main(String[] args) {
	//自定义一个随机数组，存储1-10之间不重复的数字
	int[] array=new int[10];
	for(int i=0;i<array.length;i++) {
		int num=(int)Math.round(Math.random()*9+1);
		while(isExist(array, num, i)) {
			num=(int)Math.round(Math.random()*9+1);
		}
		array[i]=num;
	}
	
	//打印输出
	for(int i:array) {
		System.out.print(i+" ");
	}
	System.out.println("-------------------------");
	//归并排序
	int[] sortedArray=devideArray(array);
	for(int i:sortedArray) {
		System.out.print(i+" ");
	}
	
}
//判断num是否在array的前index个数之前存在
public static boolean isExist(int[] array,int num,int index) {
	boolean flag=false;
	for(int i=0;i<index;i++) {
		if(num==array[i]) {
			flag=true;
		}
	}
	return flag;
}
public	static int[] devideArray(int[] array) {
	if(array.length<=1) {
		return array;
	}
	int num=array.length/2;
	int left[]=Arrays.copyOfRange(array, 0, num);
	int right[]=Arrays.copyOfRange(array, num, array.length);
	//递归调用排序算法
	return sort(devideArray(left), devideArray(right));
}

//排序算法，对左右两个数组相同位置元素比较，合并序列时把较小值放于前面
public static int[] sort(int[] left,int[] right) {
	int[] result=new int[left.length+right.length];
	int i=0;//left
	int j=0;//right
	//当左边数组个数小时：
	for(int k=0;k<result.length;k++) {
		
		if(i>=left.length) {
			result[k]=right[j];
			j++;
		}else if(j>=right.length) {
			result[k]=left[i];
			i++;
		}else if(left[i]<right[j]) {
			result[k]=left[i];
			i++;
		}else {
			result[k]=right[j];
			j++;
		}
	}
	return result;
}
}
结果-----------------------------------------------
2 1 5 3 6 9 7 4 8 10 -------------------------
1 2 3 4 5 6 7 8 9 10