package cn.luxh.app.test;



public class SimpleSortUtil {

    

    /

      冒泡排序

      从小到大排序

      思路：

      1）第一趟排序进行了len-1次斗劲，数组中的最大值元素排到了最末尾，地位已固定，该元素不再参与下趟斗劲

      2）第二趟排序进行了len-2次斗劲，因为只须要斗劲到第一个地位固定的元素（第一趟排序中的最大值元素）即可，数组中的第二大值元素地位也已固定，该元素不再参与下趟斗劲

      3）第三趟排序进行了len-3次斗劲，因为只须要斗劲到第一个地位固定的元素（第二趟排序中的最大值元素）即可，数组中的第三大值元素地位也已固定，该元素不再参与下趟斗劲

      4）依次类推...

      

      ＠param array

      ＠return

     /

    public static int[] bubbleSort（int[] array） {

        int out;//外层轮回计数

        int in;//内层轮回计数

        int len = array.length;

        

         //1）外层for轮回计数器out从数组的最后开端，即out便是len-1，每经过一次轮回，out减1（往左移）；

         //2）下标大于out的元素都是已经排好序的了；

         //3）内层for轮回计数器in从数组的开端算起，即in=0，每完成一次内部轮回加1，当in便是out时停止一次轮回。

         //4）在内层轮回中，斗劲in和in+1的两个元素

        for（out=len-1;out>1;out--） {

            //下标大于out的元素都是已经排好序的，不消再处理惩罚。

            for（in=0;in<out;in++） {

                if（array[in]>array[in+1]） {

                    //当前元素值比后面的元素值大，则互换两个元素的地位

                    int temp = array[in];

                    array[in] = array[in+1];

                    array[in+1] = temp;

                }

            }

        }

        return array;

    }

    

    

    /

      选择排序

      从小到大排序

      思路：

      1）第一趟斗劲时，找到小元素，然后这个最小元素和数组最左边（下标为0）的元素互换地位，这个最小值不再参与下次斗劲

      2）第二趟斗劲时，从下标为1的元素开端，找到小元素，然后把这个最小值元素和下标为1的元素互换地位，这个最小元素不再参与下次斗劲

      3）依次类推...

      ＠param array

      ＠return

     /

    public static int[] ionSort（int[] array） {

        int min;//最小值下标

        int in;//内层轮回计数

        int out;//外层轮回计数

        int len = array.length;

        

        

        for（out=0;out<len-1;out++） {

            min = out;//最小值下标初始化

            for（in=out+1;in<len;in++） {

                //若是有元素比array[min]小，则把下标赋给min

                if（array[in]<array[min]） {

                    min = in;

                }

            }

            //内层轮回每停止一次，就把找到的最小元素和外层轮回开端的元素互换

            int temp = array[out];

            array[out] = array[min];

            array[min] = temp;

        }

        return array;

    }

    

    /

      插入排序

      从小到大

      在外层的for轮回中，out计数器从1开端，向右移动，它标识表记标帜了未排序项目组的最左端的数据；

      在内层的while轮回中，in计数器从out开端，向左移动，直到temp变量（标记位）的值小于in所指的数组值和in不克不及再向左移动为止

      while轮回的每一趟都向右移动了一个已排序的元素

      

      

      ＠param array

      ＠return

     /

    public static int[] Sort（int[] array） {

        int in;//内层轮回计数

        int out;//外层轮回计数

        int len = array.length;

        for（out=1;out<len;out++） {

            //移出标记位值

            int temp = array[out];

            in = out;

            while（in>0 && array[in-1] >=temp） {

                //大于标记位的值，则右移

                array[in] = array[in-1];

                in--;//左移计数器

            }

            //插入标记为值

            array[in] = temp;

        }

        return array;

    }

    

}

package cn.luxh.app.test;



import org.junit.Test;



public class SimpleSortTester {

    

    ＠Test

    public void testSort（） {

        int[] array = {6，45，35，23，78，34，26，67，38，90，345，2345，12，3568，80，100};

        //SimpleSortUtil.bubbleSort（array）;

        //SimpleSortUtil.ionSort（array）;

        SimpleSortUtil.Sort（array）;

        displayArray（array）;

    }

    

    public void displayArray（int[] array） {

        for（int a:array） {

            System.out.println（a）;

        }

    }

    

}