常用算法原理及实现（Java）

一.冒泡算法原理

    比较两个相邻的元素，将值大的元素交换至右端。

冒泡算法的思想

    依次比较相邻的两个数，每一次将小数放在前面，大数放在后面。如在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放在前，大数放在后，如此循环，直至比较最后两个数，将小数放在前，大数放在后。重复第一趟步骤，直至全部排序完成。

    例如存在待排序数组 int[] a = {5,3,2,6,1};

    第一趟排序：

        第一次：比较a[0]和a[1]，交换a[0]和a[1]，排序后结果为：a={3,5,2,6,1}

        第二次：比较a[1]和a[2]，交换a[1]和a[2]，排序后结果为：a={3,2,5,6,1}

        第三次：比较a[2]和a[3]，不用交换,排序结果为：a={3,2,5,6,1}

        第四次：比较a[3]和a[4]，交换a[3]和a[4]，排序结果为：a={3,2,5,1,6}

    第二趟排序：

        第一次：比较a[0]和a[1]，交换a[0]和a[1]，排序后结果为：a={2,3,5,1,6}

        第二次：比较a[1]和a[2]，不用交换，排序后结果为：a={2,3,5,1,6}

        第三次：比较a[2]和a[3]，交换a[2]和a[3],排序结果为：a={2,3,1,5,6}

        第四次：比较a[3]和a[4]，不用交换，排序结果为：a={2,3,1,5,6}

   第三趟排序：

        第一次：比较a[0]和a[1]，不用交换，排序后结果为：a={2,3,1,5,6}

        第二次：比较a[1]和a[2]，交换a[1]和a[2]，排序后结果为：a={2,1,3,5,6}

        第三次：比较a[2]和a[3]，不用交换，排序结果为：a={2,1,3,5,6}

        第四次：比较a[3]和a[4]，不用交换，排序结果为：a={2,1,3,5,6}

   第四躺排序：

        第一次：比较a[0]和a[1]，交换a[0]和a[1]，排序结果为：a={1,2,3,5,6}

        第二次：比较a[1]和a[2]，不用交换，排序后结果为：a={1,2,3,5,6}

        第三次：比较a[2]和a[3]，不用交换，排序结果为：a={1,2,3,5,6}

        第四次：比较a[3]和a[4]，不用交换，排序结果为：a={1,2,3,5,6}

   根据以上可以看出长度为5的数组在进行4趟排序后就已经将数组的顺序整理出来了，还可以看出每趟中只需要比较（5-趟数）次就可以得出排序，归纳出当长度为N的数则进行冒泡排序的时候共需要比较N-1趟，每趟比较N-i次，i为比较趟数。

    因此用for循环控制整个算法时，可以用两层for循环，外层控制比较趟数，内层控制每趟比较的次数。

	public static void bubbleSort(int[] a){
		if(a == null)
			return ;
		for(int i=1;i< a.length;i++){
			for(int j=0;j<a.length -i;j++){
				if(a[j] > a[j+1]){
					int temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
				}
			}
		}
	}

二.选择排序的原理

    每一趟从待排序的记录中选出最小的元素，顺序放在已排好序的序列最后，直到全部记录排序完毕。也就是：每一趟在n-i+1(i=1，2，…n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。

选择排序的基本思想

    给定数组：int[] arr={里面n个数据}；第1趟排序，在待排序数据arr[1]~arr[n]中选出最小的数据，将它与arrr[1]交换；第2趟，在待排序数据arr[2]~arr[n]中选出最小的数据，将它与r[2]交换；以此类推，第i趟在待排序数据arr[i]~arr[n]中选出最小的数据，将它与r[i]交换，直到全部排序完成。选择排序的时间复杂度为O(n^2)。

代码实现：

public static void selectSort(int[] a){
		if(a == null)
			throw new IllegalArgumentException("Invalid Parmeters");
		for(int i=0;i<a.length-1;i++){
			int minIndex = i;
			for(int j=i+1;j<a.length;j++){
				if(a[minIndex] > a[j]){
					minIndex = j;	
				}				
			}
			if(minIndex != i){
				int temp = a[i];
				a[i] = a[minIndex];
				a[minIndex] = temp;
			}
	}
}

三.插入排序的原理

    一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序。

插入排序的基本思想

    每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

    如有以下序列int[] a = {5,3,1,4,2}

    我们先将第一个位置的数就是5看成是已经排序后的元素，故从第二个位置3开始插入排序

    第一次：将索引为1即值为3看作要插入的元素，3去寻找自己应该插入的位置，将3和5比较发现3比5小，故交换3和5的位置，排序后为：{3，5，1，4，2}

    第二次：将索引为2即值为1看作要插入的元素，1去寻找自己的要插入的位置，先将1和前一个位置就是5比较，发现1比5小，待插入位置的索引减1，这时它还没有比较完，继续向前搜索和3比较，交换1和3的位置排序后的结果为{1，3，5，4，2}

    如此循环去将每一个元素都插入到自己对应的位置。此处推荐一个很好的在线可视化演示地址，一目了然https://visualgo.net/zh/sorting

    代码实现

public static void insertSort(int [] a){
		if(a == null || a.length < 0)
			throw new IllegalArgumentException("Invalid Parmeter");
		//假设第一个元素（索引为0）已经排序好，故从i=1开始扫描
		for(int i=1;i<a.length;i++){
			int toBeInserted = a[i];//设置一个标记用于存储将要被插入的数
			//向后移  j用来搜索待插入数据应该插入的确切位置
			int j = i;
			while(j > 0 && a[j-1] > toBeInserted){
				a[j] = a[j-1];
				j--;
			}
			a[j] = toBeInserted;
		}
	}