java冒泡排序、选择排序、插入排序算法的核心思想及其比较

上代码：

package arithmetic;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.Scanner;

public class Bubble_Arithmetic {

 

//冒泡排序的核心思想：若有n个数据排序，从第0个数据开始，依次比较第0个数据与第一个数据，若第0个大于第一个则交换两者的位置，若小于或等于第一个，不交换，接

//着比较第一个与第二个数据，依此类推，直至所有的数据从前到后是按照以小到大的顺序排列的。——完毕。

 

 public static List bubble(List<Integer> list){

   int temp=0;

   for (int i = list.size()-1; i >=0; i--) {

   for (int j = 0; j < i; j++) {

    if(list.get(j)>list.get(j+1)){

     temp=list.get(j);

     list.set(j, list.get(j+1));

     list.set(j+1, temp);

    }

   }

  }

  return list;

 }

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

 //选择排序核心思想：有n个数据，第0个数据标记为min，用out来标记左边未排序的数据使用in标记未排序的第一个数据，依次与min比较，如果比min小，则将该数据标记

//为min,当第一轮比较完后，最终的min与out标记数据交换，依次类推。

    public static List SelectSort(List<Integer> list){

         int min,in,out,temp;

          for (out = 0; out < list.size()-1; out++) {

              min=out;

             for (in = out+1; in < list.size(); in++) {

                 if(list.get(in)<list.get(min)){

                    min=in;

                 }

             }

             temp=list.get(out);

                list.set(out, list.get(min));

                list.set(min, temp);

         }

         return list;

     }

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

  //插入排序核心思想：部分数据有序的情况下，使用out标记第一个无序的数据，将其提取保存到一个中间temp中，使用in标记空位置，依次比较temp中的值与in-1的值，若in值大于temp的值，则后移，直到遇到第一个比temp小的值，在其下一个位置插入；

  

    public static List InsertionSort(List<Integer> list){

        List<Integer> resultList= new ArrayList<Integer>(list.size());

        int[]result=new int[list.size()];

           int in,out;

           for (out = 0; out < list.size(); out++) {

               int  temp= list.get(out);

                in=out;

                while(in >0 && list.get(in-1)>temp){

                    result[in]= list.get(in-1);

                   --in;

                 }

                result[in]=temp;

               }

          for (int i = 0; i < result.length; i++)

            {

                   System.out.print(result[i]);

                   System.out.print("  ");

            }

           System.out.println("size:"+result.length );

           return resultList;

       }

 

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

//况下，不必冒泡快。

 public static void main(String[] args) {

   Scanner scanner=new Scanner(System.in); 

   System.out.println("请输入你想排序的整数，以分号；分隔：结束：回车");

   List<String> list=new ArrayList<String>();

  do{

    String line=scanner.nextLine();

    if(line.isEmpty()){

     break;

    }

    list.addAll(Arrays.asList(line.split(";")));

   }while(true);

   List<Integer> list_Int=new ArrayList<Integer>();

    for (String string : list) {

     list_Int.add(Integer.parseInt(string.trim()));

   }

    list_Int=bubble(list_Int);

          for (Integer integer : list_Int) {

            System.out.print(integer);

            System.out.print("  ");

        }

    

 }

}