常见排序算法原理和实现（一）

1. 内部排序:
   指将需要处理的所有数据都加载到内部存储器中进行排序。
2. 外部排序法：
   数据量过大，无法全部加载到内存中，需要借助外部存储进行
   排序。
   

冒泡排序

基本介绍：
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。
以及优化
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较。
原理图解：

代码实现：

public static void bubbleSort(int arrs[]){
		int temp = 0;//辅助变量，用于交换值
		boolean flag = false;//标识，用于优化
		for(int i = 0; i < arrs.length - 1 ; i++){
			for(int j = 0; j < arrs.length -i-1;j++){
				if (arrs[j] > arrs[j+1]) {
					flag = true;
					temp = arrs[j];
					arrs[j] = arrs[j+1];
					arrs[j+1] = temp;
				}
			}
			if ( !flag) {
				break;
			}else {
				flag = false;
			}
		}
	}

选择排序

基本介绍：
选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。

原理思想：
选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从arr[0]_{arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]}arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]_{arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]}arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

代码实现：

/**
 * 
 */
package com.matao.sort;

import java.util.Arrays;

/**
 * @author MT
 *
 */
public class SelectSort {
	public static void main(String[] args) {
		int arr[] = {1,4,2,34,23,12,45,42};
		selectSort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	public static void selectSort(int arr[]){
		int minValue = 0;
		int minIndex = 0;
		for(int i = 0;i < arr.length-1;i++){
			minValue = arr[i];
			minIndex = i;
			
			for(int j = i+1; j < arr.length; j++){
				if (minValue > arr[j]) {
					minValue = arr[j];
					minIndex = j;
				}
			}
			if (minIndex != i) {
				arr[minIndex] = arr[i];
				arr[i] = minValue;
			}
			
			
		}
		
	}

}

插入排序：

插入排序法思想:
插入排序（Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

/**
 * 
 */
package com.matao.sort;

import java.util.Arrays;

/**
 * @author MT
 *
 */
public class InsertSort {
	public static void main(String[] args) {
		int arr[] = {1,4,2,34,23,12,45,42};
		insertSort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	public static void insertSort(int arr[]){
		
		int insertVaue=0;
		int insertIndex=0;
		for(int i =1; i<arr.length;i++){
			insertVaue = arr[i];
			insertIndex= i-1;
			
			while(insertIndex >=0 && insertVaue <arr[insertIndex]){
				arr[insertIndex +1] = arr[insertIndex];
				insertIndex--;
			}
			
			if (insertIndex +1 !=i) {
				arr[insertIndex + 1] = insertVaue;
			}
		}
	}

}

希尔排序

希尔排序法介绍
希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。

希尔排序法基本思想
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

// 使用逐步推导的方式来编写希尔排序
	// 希尔排序时， 对有序序列在插入时采用交换法, 
	// 思路(算法) ===> 代码
	public static void shellSort(int[] arr) {
		
		int temp = 0;
		int count = 0;
		// 根据前面的逐步分析，使用循环处理
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			for (int i = gap; i < arr.length; i++) {
				// 遍历各组中所有的元素(共gap组，每组有个元素), 步长gap
				for (int j = i - gap; j >= 0; j -= gap) {
					// 如果当前元素大于加上步长后的那个元素，说明交换
					if (arr[j] > arr[j + gap]) {
						temp = arr[j];
						arr[j] = arr[j + gap];
						arr[j + gap] = temp;
					}
				}
			}
		}

//对交换式的希尔排序进行优化->移位法
	public static void shellSort2(int[] arr) {
		
		// 增量gap, 并逐步的缩小增量
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			// 从第gap个元素，逐个对其所在的组进行直接插入排序
			for (int i = gap; i < arr.length; i++) {
				int j = i;
				int temp = arr[j];
				if (arr[j] < arr[j - gap]) {
					while (j - gap >= 0 && temp < arr[j - gap]) {
						//移动
						arr[j] = arr[j-gap];
						j -= gap;
					}
					//当退出while后，就给temp找到插入的位置
					arr[j] = temp;
				}

			}
		}
	}