Java实现插入、冒泡、选择排序

一 插入排序（InsertSort）

  插入排序算法的思想如下：

  （1）将整个数组划分成两部分：有序区和无序区。初始情况下，有序区包括数组的第一元素，无序区包括剩余的其他元素。

（2）遍历无序区，每次向有序区增加一个元素，在增加元素后要保证有序区的有序性。

实现代码如下：

package com.test10;
 
import java.util.Arrays;
 
public
classInsertSort {
 
   public
static int[] insertSort(int[] array){
      for(int i=1;i<array.length;i++){
         //从第二个元素开始遍历数组
         int temp = array[i];//保存新增加的元素
         int j = 0;//定义有序区数组的下标
         //对有序区进行排序
         for(j=i-1;(j>-1)&&(temp<array[j]);j--){
            array[j+1]=array[j];
         }
         array[j+1]=temp;
      }
      return array;
   }
   public
static void main(String[] args) {
      // TODO Auto-generated method stub
       int[] array={9,8,7,6,5,4,3,2,1};
       System.out.println("排序前："+Arrays.toString(array));
      System.out.println("排序后："+Arrays.toString(insertSort(array)));
   }
}

结果如下：

排序前：[9,8, 7, 6, 5, 4, 3, 2, 1]
排序后：[1,2, 3, 4, 5, 6, 7, 8, 9]
 

总结:插入排序归根结底就是把第一个元素作为一个基准，分成两部分，左边是排好序的，然后，拿右边无序的第一个元素与左边排好序的元素进行比较排好序后，一个一个加入到左边，做种最终排成升序的数组。

二 冒泡排序（BubbleSort）

  对数组元素进行排序，通常使用冒泡排序法，冒泡排序法的排序原理如下：

  （1）对数组中相邻的两个元素从前向后进行扫描。

  （2）如果相邻两个元素中的第一个数比第二个数大，就交换这两个数，这样经过一次扫描之后，最大的元素移动到数据序列的最后。

  （3）重复（1）、（2）两个步骤，用同样的方法再对其前面的所有其他元素进行比较，当经过某次扫描后，如果没有需要交换的数据了，则算法结束。

实现代码如下：

package com.test10;
 
import java.util.Arrays;
 
public
classBubbleSort {
   public
static void main(String[] args) {
      // TODO Auto-generated method stub
      int[]array={50,13,55,97,27,38,49,65};
      System.out.println("原始数组中各元素的顺序如下："+Arrays.toString(array));
//    for(inti =0;i<array.length;i++){
//       System.out.print(array[i]+"  ");//输出数组中各元素的值
//    }
      System.out.println();
      System.out.println("排序后数组中各元素的顺序："+Arrays.toString(bubbleSort(array)));
     
   }
   public
static int[] bubbleSort(int[] array){
      //使用冒泡排序法对数组array进行排序
      for(int i = 0;i<array.length-1;i++){
         for(int j =0;j<array.length-1;j++){
            //如果数组中前边元素值比后边相邻元素值大
            if(array[j]>array[j+1]){
                //声明变量x用于保存数组中前边元素的值
                int x = array[i];
                //将前边元素的值替换为后边相邻的元素
                array[j]=array[j+1];
                //用原来前边元素的值替换后边相邻元素的值
                array[j+1]=x;
            }
         }
      }
      return array;
   }
}

结果如下：

原始数组中各元素的顺序如下：[50, 13, 55, 97, 27, 38, 49, 65]
 
排序后数组中各元素的顺序：[13,13, 27, 27, 38, 49, 50, 65]

总结：冒泡排序就是数组中相邻的两个数进行比较，循环一次以后，把最大的那个数，比较交换到最后。多次进行比较交换以后，最终得到升序的数组。

三 选择排序算法（SelectSort）

  选择排序算法的思想如下：

  （1）将序列分成有序区和无序区两部分，初始时有序区为空，无序区包括全部元素。

（2）每次从无序区中选择最小的元素将其与无序区第一个元素进行交换。

（3）重复步骤（2），直到无序区没有元素。

程序代码如下：

package com.test10;
 
import java.util.Arrays;
 
public
classSelectSort {
   public
static void main(String[] args) {
      // TODO Auto-generated method stub
      int[]array={9,8,7,6,5,4,3,2,1};
          System.out.println("排序前："+Arrays.toString(array));
          System.out.println("排序后："+Arrays.toString(selectSort(array)));
   }
 publicstaticint[]selectSort(int[]array){
     int temp=0;//定义用于交换元素的临时变量
     int index=0;//保存元素的下标
     for(inti =0;i < array.length;i++){
        index = i;
        for(intj = i +1;j <array.length;j++){
           //查找最小元素
           if(array[j]<array[index]){
              index=j;
           }
        }
        //将最小元素进行交换
        if(index!=i){
           temp=array[i];
           array[i]=array[index];
           array[index]=temp;
        }
     }
     return array;
 }
}

 

 

结果如下：

排序前：[9, 8, 7, 6, 5, 4, 3, 2,1]
排序后：[1, 2, 3, 4, 5, 6, 7, 8,9]

总结：

   选择排序还是将数字分成两块，一块为有序区，一块为无序区。只不过与插入排序不同的事，有序区为空而已。然后，先假定整个数组第一个位置为有序区第一个位置，且无序区第一个位置为整个数组的第一个位置。在排序过程中，假定有序区第一个位置不变，使得二维循环的j右边+1,使得array[index]与array[j+1]进行比较，如果array[index=i(这里为i)]<array[j+1],把j赋值给index，判断下标是否不等，进行交换。多次交换以后，得到升序数组。