简单排序算法（Java实现）

喜欢ヅ旅行 2022-01-29 00:21 195阅读 0赞

简单排序算法：冒泡排序，选择排序，插入排序

## 一、冒泡排序 ##

### 1.1 原理： ###

1.  从第一个数据开始，与第二个数据相比较，如果第二个数据小于第一个数据，则交换两个数据的位置
2.  指针由第一个数据移向第二个数据，第二个数据与第三个数据相比较，如果第三个数据小于第二个数据，则交换两个数据的位置
3.  依此类推，完成第一轮排序。第一轮排序结束后，最大的元素被移到了最右面
4.  依照上面的过程进行第二轮排序，将第二大的排在倒数第二的位置
5.  重复上述过程，没排完一轮，比较次数就减少一次

### 1.2 例子： ###

待排序数据：7, 6, 9, 8, 5,1

第一轮排序过程：

指针先指向7，7和6比较，6<7，交换6和7的位置，结果为：6,7,9,8,5,1

指针指向第二个元素7，7和9比较，9>7，不用交换位置，结果仍为：6,7,9,8,5,1

指针指向第三个元素9，比较9和8，8<9，交换8和9的位置，结果为：6,7,8,9,5,1

指针指向第四个元素9，比较9和5，5<9，交换5和9，结果为：6,7,8,5,9,1

指针指向第五个元素9，比较9和1，1<9，交换1和9的位置，结果为6,7,8,5,1,9

第一轮排序结束后，最大的数字9被移到了最右边。

进行第二轮排序，过程同上，只是由于最大的9已经放在最右边了，因此不用在比较9了，少了一次比较，  
第二轮结束的结果为：6,7,5,1,8,9

第三轮结果：6,5,1,7,8,9

第四轮比较结果：5,1,6,7,8,9

第五轮比较结果：1,5,6,7,8,9

最终排序结果为：1,5,6,7,8,9，由上可知N个数据排序，需要进行N-1轮排序；第i轮排序需要的比较次数为N-i次。

### 1.3 代码实现 ###

//1.冒泡排序(默认升序)O(n*n)
    public void bobSort(int [] arr) { 
    	if(arr == null || arr.length<2) { 
    		return;
    	}
    	int temp=0, len = arr.length;
    	for(int i=0;i<len;i++) { 
    		for(int j=i+1;j<len;j++) { 
    			if(arr[i] > arr[j]) { 
    				temp = arr[i];
    				arr[i] = arr[j];
    				arr[j] = temp;
    			}
    		}
    	}
    }

## 二、选择排序 ##

选择排序是对冒泡排序的改进，它的比较次数与冒泡排序相同，但交换次数要小于冒泡排序。当数据量较大时，效率会有很大的提升，但时间复杂度仍为O(n\*n)

### 2.1 原理： ###

1.  从第一个元素开始，分别与后面的元素向比较，找到最小的元素与第一个元素交换位置
2.  从第二个元素开始，分别与后面的元素相比较，找到剩余元素中最小的元素，与第二个元素交换
3.  重复上述步骤，直到所有的元素都排成由小到大为止

### 2.2 例子： ###

待比较数据：7, 6, 9, 8, 5,1

第一轮：此时指针指向第一个元素7，找出所有数据中最小的元素，即1，交换7和1的位置，排序后的数据为：1,6,9,8,5,7

第二轮：第一个元素已经为最小的元素，此时指针指向第二个元素6，找到6,9,8,5,7中最小的元素，即5，交换5和6的位置，排序后的结果为：1,5,9,8,6,7

第三轮：前两个元素为排好序的元素，此时指针指向第三个元素9，找到9,8,6,7中最小的元素，即6，交换6和9的位置，排序后的结果为：1,5,6,8,9,7

第四轮：前三个元素为排好序的元素，此时指针指向第四个元素8，找到8,9,7中最小的元素，即7，交换8和7的位置，排序后的结果为：1,5,6,7,9,8

第五轮：前四个元素为排好序的元素，此时指针指向第五个元素9，找到9,8中最小的元素，即8，交换9和8的位置，排序后的结果为：1,5,6,7,8,9

到此，全部排序完成。

分析：从上面的原理可以看出，与冒泡排序不同，选择排序每排完一轮都把最小的元素移到了最左面，然后下一轮排序的比较次数比上一轮减少一次，即第i轮排序需要比较N-i次。因此，和冒泡排序一样，N个数据比较大小，需要排序N-1轮，第i轮排序需要比较N-i次。

### 2.3 代码实现 ###

//2.选择排序,相对冒泡来说，改进在于交换的次数减少
    //(O(n*n))
    public void chooseSort(int [] arr) { 
    	if(arr == null || arr.length<2) { 
    		return;
    	}
    	int len = arr.length, curIndex =0, temp=0 ;
    	for(int i=0;i<len;i++) { 
    		curIndex = i;
    		for(int j=0;j<len-i;j++) { 
    			if(arr[curIndex] > arr[j]) { 
    				curIndex = j;
    			}
    		}
    		temp = arr[curIndex];
    		arr[curIndex] = arr[len-i-1];
    		arr[len-i-1] = temp;
    	}
    }

## 3、插入排序 ##

插入排序是简单排序中最快的排序算法，虽然时间复杂度仍然为O(n\*n)，但是却比冒泡排序和选择排序快很多。

### 3.1 原理： ###

1.  将指针指向某个元素，假设该元素左侧的元素全部有序，将该元素抽取出来，然后按照从右往左的顺序分别与其左边的元素比较，遇到比其大的元素便将元素右移，直到找到比该元素小的元素或者找到最左面发现其左侧的元素都比它大，停止
2.  此时会出现一个空位，将该元素放入到空位中，此时该元素左侧的元素都比它小，右侧的元素都比它大
3.  指针向后移动一位，重复上述过程。每操作一轮，左侧有序元素都增加一个，右侧无序元素都减少一个

### 3.2 例子： ###

待比较数据：7, 6, 9, 8, 5,1

第一轮：指针指向第二个元素6，假设6左面的元素为有序的，将6抽离出来，形成7,*,9,8,5,1，从7开始，6和7比较，发现7>6。将7右移，形成*,7,9,8,5,1，6插入到7前面的空位，结果：6,7,9,8,5,1

第二轮：指针指向第三个元素9，此时其左面的元素6,7为有序的，将9抽离出来，形成6,7,\_,8,5,1，从7开始，依次与9比较，发现9左侧的元素都比9小，于是无需移动，把9放到空位中，结果仍为：6,7,9,8,5,1

第三轮：指针指向第四个元素8，此时其左面的元素6,7,9为有序的，将8抽离出来，形成6,7,9,*,5,1，从9开始，依次与8比较，发现8<9，将9向后移，形成6,7,*,9,5,1，8插入到空位中，结果为：6,7,8,9,5,1

第四轮：指针指向第五个元素5，此时其左面的元素6,7,8,9为有序的，将5抽离出来，形成6,7,8,9,*,1，从9开始依次与5比较，发现5比其左侧所有元素都小，5左侧元素全部向右移动，形成*,6,7,8,9,1，将5放入空位，结果5,6,7,8,9,1。

第五轮：同上，1被移到最左面，最后结果：1,5,6,7,8,9。

### 3.3 代码实现 ###

//插入排序(O(n*n),简单排序算法里效率相对最好的)
    public void insertSort(int [] arr) { 
    	if(arr == null || arr.length<2) { 
    		return;
    	}
    	int len = arr.length, temp=0 ;
    	for(int i=1;i<len;i++) { 
    		temp = arr[i];
    		int j=i-1;
    		for(;j>=0 && arr[j]>temp;j--) { 
    			arr[j+1] = arr[j];
    			
    		}
    		if(j != i-1) { 
    			arr[j] = temp;
    		}
    	}
    	
    }

## 4、测试代码 ##

public static void main(String[] args) { 
    	Test test = new Test();
    	int[] arr = { 77,29,28,36,33,25,10};
    	test.bobSort(arr);
    	System.out.println(Arrays.toString(arr));
    	test.chooseSort(arr);
    	System.out.println(Arrays.toString(arr));
    	test.insertSort(arr);
    	System.out.println(Arrays.toString(arr));
    }

## 5、拓展 ##

侏儒排序（类似直接插入排序，直接插入排序更优）  
[https://www.cnblogs.com/9-de/p/6600640.html][https_www.cnblogs.com_9-de_p_6600640.html]

图书馆排序：  
基于插入排序，做的优化为在每本书之间预留一定的空隙，然后在插入的时候就能少移动一些书。说白了就是在插入排序的基础上,给书与书之间留一定的空隙,这个空隙越大,需要移动的书就越少,这是它的思路,**用空间换时间**

[https://blog.csdn.net/u014723529/article/details/41958545][https_blog.csdn.net_u014723529_article_details_41958545]

[https_www.cnblogs.com_9-de_p_6600640.html]: https://www.cnblogs.com/9-de/p/6600640.html
[https_blog.csdn.net_u014723529_article_details_41958545]: https://blog.csdn.net/u014723529/article/details/41958545