数据结构常见排序算法总结（java实现）

目录

1.插入排序

1.1 直接插入排序

1.2 希尔排序

2.选择排序

2.1 简单选择排序

3.交换排序

3.1 冒泡排序

---

1.插入排序

---

1.1 直接插入排序

直接插入排序的核心思想就是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已经排序好的元素小，则交换，直到全部元素都比较过。

因此，从上面的描述中我们可以发现，直接插入排序可用用两层循环来实现：

• 第一层循环：遍历待比较的所有数组元素
• 第二层循环：将本轮选择的元素（selected）与已经排序好的元素（ordered）依次进行比较。如果：selected > ordered，那么将两者交换。

代码实现：

/**
	 * 简单插入排序
	 */
	public static void simpleInsertSort() {
		
		int[] array = new int[] {12,9,34,23,65,25,65,63,21,33};
		//设置临时变量
		int temp;
		for(int i=1;i<10;i++) {
			for(int j=i;j>0;j--) {
				//如果array[j]小于array[j-1]则交换
				if(array[j-1]>array[j]) {
					temp = array[j];
					array[j] = array[j-1];
					array[j-1] = temp;
				}else {
					//如果array[j]大于array[j-1]，则找到位置，开始下一轮比较
					break;
				}
			}
		}
		for(int a:array) {
			System.out.print(a+" ");
		}
	}

1.2 希尔排序

算法思想：

 希尔排序的算法思想：将待排序数组按照步长gap进行分组，然后将每组的元素利用直接插入排序的方法进行排序；每次将gap折半减小，循环上述操作；当gap=1时，利用直接插入，完成排序。
同样的，从上面的描述中我们可以发现，希尔排序的总体实现应该由三个循环完成：

•  第一层循环：将gap依次减半，对序列进行分组，直到gap=1
•  第二、三层循环：也即直接插入排序中所需要的两次循环。具体描述见上。

代码描述：

/**
	 * 希尔排序
	 */
	public static void shellSort() {
		
		int[] array = new int[] {9,1,2,5,7,4,8,6,3,5};
		//首先给定步长为数组长度的一半
		int gap = (int)(array.length/2);
		//设置临时变量
		int temp;
		while(gap >= 1) {
			gap = gap / 2;
			//接下来采用直接插入排序
			for(int i=gap;i<array.length;i++) {
				for(int j=i;j>=gap;j=j-gap) {
					if(array[j] < array[j-gap]) {
						temp = array[j];
						array[j] = array[j-gap];
						array[j-gap] = temp;
					}else {
						break;
					}
				}
			}
		}
		for(int a:array) {
			System.out.print(a+" ");
		}
	}

2.选择排序

---

2.1 简单选择排序

简单选择排序的基本思想：比较+交换。

1. 从待排序序列中，找到关键字最小的元素；
2. 如果最小元素不是待排序序列的第一个元素，将其和第一个元素互换；
3. 从余下的 N - 1 个元素中，找出关键字最小的元素，重复(1)、(2)步，直到排序结束。
   因此我们可以发现，简单选择排序也是通过两层循环实现。
   第一层循环：依次遍历序列当中的每一个元素
   第二层循环：将遍历得到的当前元素依次与余下的元素进行比较，符合最小元素的条件，则交换。

代码如下：

/**
	 * 简单选择排序
	 */
	public static void simpleSelectSort() {
		
		int[] array = new int[] {9,1,2,0,7,4,8,6,3,5};
		//记录最小值的位置
		int minIndex;
		//设置临时变量用于交换
		int temp;
		for(int i=0;i<array.length-1;i++) {
			minIndex = i;
			//从待排序序列中找到最小值
			for(int j=i;j<array.length-1;j++) {
				if(array[j+1] < array[minIndex]) {
					minIndex = j+1;
				}
			}
			//如果此最小值不是待排序序列中的第一个，则将此最小值和待排序序列中的第一个进行交换
			if(array[minIndex] != array[i]) {
				temp = array[minIndex];
				array[minIndex] = array[i];
				array[i] = temp;
			}
		}
		for(int a:array) {
			System.out.print(a+" ");
		}
	}

3.交换排序

---

3.1 冒泡排序

冒泡排序算法思想：

1. 将序列当中的左右元素，依次比较，保证右边的元素始终大于左边的元素；
   （ 第一轮结束后，序列最后一个元素一定是当前序列的最大值；）
2. 对序列当中剩下的n-1个元素再次执行步骤1。
3. 对于长度为n的序列，一共需要执行n-1轮比较

代码如下：

	/**
	 * 冒泡排序
	 */
	public static void bubbleSort() {
		
		int[] array = new int[] {9,1,2,0,7,4,8,6,3,5};
		int temp;
		//外层循环，总共进行n-1轮循环
		for(int i=1;i<array.length;i++) {
			//内层循环，一次进行比较交换
			for(int j=0;j<array.length-i;j++) {
				if(array[j] > array[j+1]) {
					temp = array[j];
					array[j] = array[j+1];
					array[j+1] = temp;
				}
			}
		}
		for(int a:array) {
			System.out.print(a+" ");
		}
	}