Java数组的选择，冒泡，快速，插入，反转排序算法详解

Java的数组排序有选择排序，冒泡排序，快速选择排序，直接插入排序，当然还有反转数组中的元素顺序等等多种算法

选择排序
基本思想:每次循环选择最小(最大)的一个元素，顺序排在已经排好元素的最后(前面)，直到所有待排序的元素排完。

如:
待排序的数组 {5,6,3,5,7,4};

第一次: {5,6,3,5,4,7};

第二次: {5,4,3,5,6,7};
….
实现代码:

  int [] array={5,6,3,5,7,4};
int index;
  for(int i=1;i<array.length;i++){
      index=0;//先认为是最大的
      for(int j=1;j<=array.length-i;j++)
      {
          if(array[j]>array[index])
          {
              index=j;  //如果比目前的大，就取这个，找出最大的
          }
      }
     int temp=array[array.length-i];//保存要交换的位置
      array[array.length-i]=array[index];//交换最大的值
      array[index]=temp;
   }
   System.out.println(Arrays.toString(array));//输出

算法心得:如果有数组重复，选择这个算法。

冒泡排序

基本思想:对比相邻的元素，如果满足比较条件，大的向后，小的向前。跟选择排序的差别是，冒泡是每次比较，就交换位置，而选择排序是先找最大的再交换。

实现代码:

int [] array={5,6,3,5,7,4};
for(int i=1;i<array.length;i++){
      for(int j=0;j<array.length-i;j++)
      {
          if(array[j]>array[j+1]) //如果大于后面的就交换到后面再于后面的比
          {
              int temp=array[j+1];//保存要交换的位置
              array[j+1]=array[j];//交换最大的值
              array[j]=temp;
          }
      }
   }
System.out.println(Arrays.toString(array));//输出

快速选择排序

基本思想:快速选择排序是对冒泡排序的升级，通过一趟的排序把数据分成2部分，其中一部分的所有数据小于另一部数据，然后再按这个方法对每个部分进行再分割，可以使用递归算法。

实现代码:

   int [] array={5,6,3,5,7,4};
   sort(array,0,array.length-1);
private void sort(int array[],int low,int high){
int lo=low;         //记录最小索引
int hi=high;        //记录最大索引
int mid;            //记录分点元素
if (high>low){
    mid=array[(low+high)/2];   //记录分点元素
    while (lo<=hi){
        while ((lo<high)&&(array[lo]<mid)){
            ++lo;                  //记录不大于分点元素的索引
        }
        while ((hi>low)&&(array[hi]>mid)){
            --hi;                //记录大于分点元素的索引
        }
        if (lo<=hi){              //如果最小索引和最大索引没有重复
           int temp=array[lo];     //交换2个索引的元素
           array[lo]=array[hi];
           array[hi]=temp;
            ++lo;                   //增加最小索引
            --hi;                      //减小最大索引
        }
    }
    if (low<hi)
        sort(array,low,hi);        //递归排序没有分解的元素
    if (lo<high)
        sort(array,lo,high);       //递归排序没有分解的元素
  }

}
直接插入排序

基本思想:将n个有序的数存放在数组a中，要插入的数是x，首先确定x要插入的位置p，然后把p后面的元素向后移动一位，空出p，在插入这样插入后也是有序的。

实现代码:

int [] array={5,6,3,5,7,4};
int temp;        //定义临时保存变量
int j;
for(int i=1;i<array.length;i++){
    temp=array[i];      //保存临时变量
    for (j=i-1;j>=0&&array[j]>temp;j--){
        array[j+1]=array[j];   //数组元素交换
    }
    array[j+1]=temp;  //在排序位置插入数据
}
System.out.println(Arrays.toString(array));//输出

有反转数组中的元素顺序

基本思想:就是把最后一个元素与第一个元素交换，倒数第2个与第2个交换以此类推。

实现代码:

int [] array={5,6,3,5,7,4};
    int len=array.length;
    for(int i=0;i<len/2;i++){
        int temp=array[i];
        array[i]=array[len-1-i];
        array[len-1-i]=temp;
     }
    System.out.println(Arrays.toString(array));//输出

原创来源：滴一盘技术

• 上一篇： Java序列化和反序列化与transient关键字
• 下一篇： Java对象的浅克隆和2种深克隆的使用