Java中的简单排序：冒泡排序，选择排序，插入排序

来源：互联网发布：mac合盖不休眠编辑：程序博客网时间：2024/05/01 21:59

简单排序中包括了：冒泡排序、选择排序、插入排序；

原理与思想：

1.冒泡排序的思想：

假设有N个数据需要排序，则从第0个数开始，依次比较第0和第1个数据，如果第0个大于第1个则两者交换，否则什么动作都不做，继续比较第1个第2个…，这样依次类推，直至所有数据都“冒泡”到数据顶上。

冒泡排序的的java代码：

Public void bubbleSort()

{

int in,out;

for(out=nElems‐1;out>0;out‐‐)

  for(in=0;in<out;in++)

  {

    If(a[in]>a[in+1])

      Swap(in,in+1);

}

}

算法的不变性：许多算法中，有些条件在算法执行过程中始终是不变的。这些条件被称为算法的不变性，如果不变性不为真了，则标记出错了；

冒泡排序的效率O（N*N），比较N*N/2，交换N*N/4；

测试代码：

/**
* 冒泡排序
* @author Administrator
*
*/
public class test {

int arr[]={1,4,3,7,5,3,2,5,7,8,9};
public void bubbleSort(int a[]){

  /**
   * 核心排序方法1 从左到右比较
   */
  for(int i=0;i<a.length;i++){
   for(int j=i+1;j<a.length;j++){
    if(a[i]>a[j]){
     Swap(i,j);
    }
   }
  }
}

/**
* 核心排序方法2 从右到坐比较
*/
public void bubbleSort2(int a[]){
  for(int i=a.length-1;i>0;i--){
   for(int j=0;j<i;j++){
    if(a[i]>a[j]){
     Swap(i, j);
    }
   }
  }
}

public void Swap(int a,int b){
  int c=arr[a];
  arr[a]=arr[b];
  arr[b]=c;
}

public static void main(String[] args) {

  test t=new test();
  t.bubbleSort(t.arr);
     for(int i=0;i<t.arr.length;i++){
     System.out.print(t.arr[i]+" ");
     }

     System.out.println("\n");

     test t2=new test();
     t2.bubbleSort2(t2.arr);
     for(int i=0;i<t2.arr.length;i++){
     System.out.print(t2.arr[i]+" ");
     }

}
}

原理与思想：

2. 选择排序的思想：
假设有N条数据，则暂且标记第0个数据为MIN（最小），使用OUT标记最左边未排序的数据，然后使用IN标记第1个数据，依次与MIN进行比较，如果比MIN小，则将该数据标记为MIN，当第一轮比较完后，最终的MIN与OUT标记数据交换，依次类推；

选择排序的java代码：

Public void selectSort()

{

Int in,out,min;

For(out=0;out<nElems‐1;out++)

{

  Min=out;

For(in=out+1;in<nElems;in++)

  If(a[in]<a[min])

  Min=in;

Swap(out,min);

}

}

选择排序的效率：O（N*N），比较N*N/2，交换<N；选择排序与冒泡排序比较，比较次数没有明显改变，但交换次数明显减少了很多；

/**
* 选择排序
* @author Administrator
*
*/
public class test2 {
   /**
   * 选择排序核心代码
   */
   int arr[]={1,2,9,5,8,5,8,9,44,17};

   public void selectSort(int a[]){
       int min;
       for(int i=0;i<a.length;i++){
           min=i;
           for (int j = i+1; j < a.length; j++) {
           if (a[min]>a[j]) {
               min=j;
           }
       }
           Swap(min,i);
       }
   }

   public void Swap(int a,int b){
       int c=arr[a];
       arr[a]=arr[b];
       arr[b]=c;
   }

   public static void main(String[] args) {
   test2 test2=new test2();
   test2.selectSort(test2.arr);
    for(int i=0;i<test2.arr.length;i++){
       System.out.print(test2.arr[i]+" ");
    }
   }

}

3. 插入排序的思想：

插入排序是在部分数据有序的情况下，使用OUT标记第一个无序的数据，将其提取保存到一个中间变量temp中去，使用IN标记空位置，依次比较temp中的值与IN‐1的值，如果IN‐值大于temp的值，则后移，直到遇到第一个比temp小的值，在其下一个位置插入；

插入排序的java代码：

Public void InsertionSort()

  {

    Int in,out;

    For(out=1;out<nElems;out++)
    {

      Long temp=a[out]

      In=out;

      While(in>0&& a[in‐1]>temp)

      {

        A[in]=a[in‐1];

        ‐ ‐in;

}

A[in]=temp;

}

}

插入排序的效率：O（N*N）, 比较N*N/4，复制N*N/4；插入排序在随机数的情况下，比冒泡快一倍，比选择稍快；在基本有序的数组中，插入排序几乎只需要O（N）；在逆序情况下，并不比冒泡快；

/**
* 插入排序
* @author Administrator
*
*/
public class test3 {
   int arr[]={1,2,9,5,8,5,8,9,44,17};
   /**
   * 插入排序核心代码
   * @param a
   */
   public void insertionSort(int a[]){
       int temp;
       for(int i=1;i<a.length;i++){
           temp=a[i];
           while(i>0&&temp<a[i-1]){
               a[i]=a[i-1];
               i--;
           }
           a[i]=temp;
       }
   }

   public static void main(String[] args) {
       test3 t=new test3();
       t.insertionSort(t.arr);
       for(int i=0;i<t.arr.length;i++){
           System.out.print(t.arr[i]+" ");
        }
   }
}