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("  ");
        }
    
 }

}