经典排序算法之冒泡、选择和插入排序

排序算法学了好久了，今天再来复习一下。毕竟是很经典的排序算法。

1 冒泡排序

算法描述

  设待排序记录序列中的记录个数为n
  一般地，第i趟起泡排序从1到n-i+1
  依次比较相邻两个记录的关键字，如果发生逆序，则交换之。
  其结果是这n-i+1个记录中，关键字最大的记录被交换到第n-i+1的位置上，最多作n-1趟。

算法实现：

package cn.hncu.sortAlgorithm;

public class SortMethods1 {
/*
* 算法好坏的评价指标：
* 1.时间复杂度，就是算法运行的快慢(时间)-----通常用计算机的运算(算术，赋值)次数来代替
* 2.空间复杂度，占用内存空间的大小------通常用程序中使用了多少变量(栈内存，堆内存)，这些变量总共占了多少内存
*/
public static void main(String[] args) {
int a[]={5,8,-3,11,7,28,95,-12,8};//8个数
//1.冒泡排序
//1.1普通的冒泡排序
//bubbleSort(a);
//1.2带优化的冒泡排序
bubbleSort2(a);
}
//1.1普通的冒泡排序
private static void bubbleSort(int[] a) {
for(int i=0;i<a.length-1;i++){//趟数：n-1
for(int j=0;j<a.length-i-1;j++){//让第j个和第j+1个数进行比较，违反需求则交换。j:0->j:n-i-1
if(a[j]>a[j+1]){
swap(a,j,j+1);
}
}
}
}

//1.2 冒泡排序(优化)----只要发现一趟走下来没有一次交换那么就认为已经排好序，后面的数就无需再遍历了
private static void bubbleSort2(int[] a) {
for(int i=0;i<a.length-1;i++){
boolean isOk=true;
for(int j=0;j<a.length-i-1;j++){
if(a[j]>a[j+1]){
swap(a,j,j+1);
isOk=false;
}
}
if(isOk) break;
}
}

算法评价

2 选择排序

算法描述

  首先通过n-1次比较，从n个数中找出最小的，将它与第一个数交换——第一趟选择排序，结果最小的数被安置在第一个元素位置上。
  再通过n-2次比较，从剩余的n-1个数中找出关键字次小的记录，将它与第二个数交换——第二趟选择排序。
  重复上述过程，共经过n-1趟排序后，排序结束。

算法实现：

//2.选择排序
//2.1 选择排序的类似思维但性能不好----例如排手机
//selectSort0(a);
//2.2 真正的选择排序
selectSort(a);
//2.1 选择排序的类似思维但性能不好
private static void selectSort0(int[] a) {
for(int i=0;i<a.length-1;i++){
for(int j=i+1;j<a.length;j++){
if(a[i]>a[j]){
swap(a,i,j);
}
}
}
}
//2.2 选择排序
private static void selectSort(int[] a) {
for(int i=0;i<a.length-1;i++){
int k=i;
for(int j=i+1;j<a.length;j++){
if(a[k]>a[j]) k=j; //要用a[k]和a[j]依次作比较，找出最小的那个
}
//经过上面的循环，第k个元素一定是当前(从第i个元素到最后这些元素中)最小的
if(i!=k) swap(a,i,k);
}
}

算法评价

3 插入排序

算法描述：

  记录存放在数组R[0….n-1]中，排序过程的某一中间时刻，R被划分成两个子区间R[0…i-1]和R[i….n-1]，其中：前一个子区间是已排好序的有序区；后一个子区间则是当前未排序的部分。

基本操作：

  将当前无序区的第1个记录R[i]插入到有序区R[0….i-1]中适当的位置，使R[0…i]变为新的有序区。

操作细节：

  当插入第i(i≥1)个对象时, 前面的r[0], r[1], …, r[i-1]已经排好序。

  用r[i]的关键字与r[i-1],r[i-2], …的关键字顺序进行比较(和顺序查找类似)，如果小于，则将r[x]向后移动(插入位置后的记录向后顺移)；找到插入位置即将r[i]插入。

算法实现：

//3. 插入排序
//3.1 简单插入排序
//insertSort(a);
// 3.1 简单插入排序
private static void insertSort(int[] a) {
//依次把每个元素拿来插入到有序序列当中(从第二个开始，到最后就行)
for(int i=0;i<a.length-1;i++){
//待插入的数
int temp=a[i+1];

//下面的这一段是决定temp所在的位置(j+1)以及 让比temp大的数往后挪动一个位置
int j=i;
//System.out.println(a[j]+".."+temp+".."+a[temp]);
while(a[j]>temp){//如果有序数列中 第j位置的数 比待插入的数 大，则把a[j]往后挪动一个位置
a[j+1]=a[j];// a[j] 挪到了a[j+1]的位置
j--;
if(j<0) break;
}
//这样找出来的第a[j]数是比temp小的数，所以让temp坐在第j个数的后一个位置：即j+1
a[j+1]=temp;
}
}

3.2 二分插入排序（直接插入排序的优化）

算法描述：

  在直接插入排序的基础上，利用二分(折半)查找算法决策出当前元素所要插入的位置。

    二分查找：找到中间元素，如果中间元素比当前元素大，则当前元素要插入到中间元素的左侧；否则，中间元素比当前元素小，则当前元素要插入到中间元素的右侧。

  找到当前元素的插入位置i之后，把i和high之间的元素从后往前依次后移一个位置，然后再把当前元素放入位置i。

算法实现：

//3.2 加入二分查找的插入排序 //注：二分查找的前提要有序
binaryInsertSort(a);
//3.2 加入二分查找的插入排序
private static void binaryInsertSort(int[] a) {
for(int i=0;i<a.length-1;i++){
int temp=a[i+1];

//用二分查找决定插入的位置
int low=0;
int high=i;
while(low<=high){
int mid=(low+high)/2;
//用中间位置元素和当前待插入的数(temp)作比较
if(a[mid]>temp)//落在左半区
high=mid-1;
else
low=mid+1;
}
//上面这段只是找到插入位置

//移位：把待插入位置腾出来
for(int j=i;j>high;j--){
a[j+1]=a[j];
}
//让temp坐在a[high+1]的位置上或者a[low]的位置上
a[low]=temp;
}
}

亲测都是可以排序成功的哦。