java数组的排序，选择排序，冒泡排序，插入排序

/*数组的排序:让数组的所有元素按照一种固定的顺序进行排列
1.选择排序：
    外层循环，每次将相应的最大数放在对应的位置，位置i从0~length-2
    内层循环，假设i位置的元素为最大数max，用一个pos先记住i，遍历从i+1的位置开始到末尾所有的元素
    如果有比max大的就让max记住该数，pos记住该数的位置，这样循环下来，pos一定是记住i~length-1中
    最大的数所在的位置，让pos位置的元素和i位置的元素换一把，即使i位置的元素就是最大了，自己和自己换
    也每关系
2.冒泡排序：
    两层循环，外层循环，每次将最小数放在相应的位置，假设i为最小数的位置，i的取值：0~length-2
    内层循环，不停冒泡，每次让当前数和前一个数比，小就换，假设j为当前数，j的取值：length-1~i+1
3.插入排序
*/

class Demo2
{
    public static void main(String args[])
    {
        int[] arr = {38,12,1,189,456,237,98,199,7};
        System.out.println("排序前：");
        listArr(arr);
        
        System.out.println("选择排序后：");
        selectSort(arr);
        listArr(arr);
        
        
        System.out.println("冒泡排序后：");
        bubbleSort(arr);
        listArr(arr);
        
        System.out.println("插入排序后：");
        insertSort(arr);
        listArr(arr);
    }
    
    /*选择排序
    思路：
    1.定义一个循环，控制要排列的次数，每次搞定一个最大数
        假设用i来代表每次最大数摆放的位置，i的取值：0~length-2
    2.定义一个变量pos记住最大数所在的位置，定义一个变量max记住最大数
        max初始值为i位置的元素,pos初始值为i
    3.定义一个内层循环，用于遍历数组找最大数
        假设i位置的最大，找出i+1~length-1里面最大的比i还大的
        遍历数组，如果有比max大的，将值给max，同时用pos记住该元素的角标
    4.让最大数和i位置的元素交换
    */
    static void selectSort(int[] arr)
    {
        //456,12,     1,189,38,237,98,199,7
        for(int i=0; i<arr.length-1; i++)    //i: 1
        {
            int pos = i;    // pos:4
            int max = arr[i];    //max:456
            //找最大数
            for(int j=i+1; j<arr.length; j++)    //j:8
            {
                if(arr[j]>max)    //
                {
                    max = arr[j];
                    pos = j;
                }
            }
            exchange(arr, i, pos);
        }
    }
    
    /*冒泡排序
    思路：
    1.定义一个外层循环，每次搞定一个最小数，i为最小数的位置，i的取值：0~length-2
    2.定义一个内层循环，从数组的末尾开始向前冒泡，直到i+1的位置和i位置的元素进行完冒泡
        j的取值：length-1~i+1
    
    */
    static void bubbleSort(int[] arr)
    {
        for(int i=0; i<arr.length-1; i++)
        {
            for(int j=arr.length-1; j>i; j--)
            {
                if(arr[j]<arr[j-1])
                    exchange(arr, j, j-1);
            }
            //一次循环后
            //listArr(arr);
        }
    }
    
    /*插入排序
    思路：
    1.外层循环，每次搞定一个数(i)的位置，i的取值：1~length-1
    2.内层循环，让第i个数不断和前面的数比较，小就换位置，直到遇上前面一个元素比它还小就停
            还有，如果此元素被换到了第0个位置，也要停
    */
    static void insertSort(int[] arr)
    {
        for(int i=1; i<arr.length; i++)
        {
            int pos = i;    //pos记住被插入的元素的角标
            while(pos>0&&arr[pos]<arr[pos-1])
            {
                exchange(arr, pos, pos-1);
                pos--;
            }
        }
    }
    
    //交换数组两个元素的位置
    static void exchange(int[] arr, int pos1, int pos2)
    {
        int temp = arr[pos1];
        arr[pos1] = arr[pos2];
        arr[pos2] = temp;
    }
    
    //输出数组的元素
    static void listArr(int[] arr)
    {
        StringBuffer sb = new StringBuffer();
        for(int i=0; i<arr.length; i++)
            sb.append(arr[i] + ",");
        sb.delete(sb.length()-1, sb.length());
        System.out.println(sb);
    }
}