【排序】【java】选择排序和冒泡排序

不带注释的选择排序：

    public void sort(int[] i) {
        for (int j = 0; j < i.length - 1; j++) {
            int min = i[j]; //假定最小值为当前值
            int temp = j;   //记录最小值的下标
            for (int z = j; z < i.length; z++) {
                if(i[z] < min) {
                    min = i[z];
                    temp = z;
                }
                
                if(z == i.length - 1) {
                    if(min != i[j]) {
                        i[temp] = (i[temp] ^ i[j]);
                        i[j] = (i[temp] ^ i[j]);
                        i[temp] = (i[temp] ^ i[j]);
                    }
                }
            }
        }
    }

不带注释的冒泡排序：

	public void sort(int[] i) {
        for(int j = 0; j < i.length - 1; j++) {
            for (int m = i.length - 1, n = 0; m >= 1; m--,n++) {
                if(i[n + 1] < i[n]) {
                    i[n] = (i[n] ^ i[n + 1]);
                    i[n + 1] = (i[n] ^ i[n + 1]);
                    i[n] = (i[n] ^ i[n + 1]);
                }
            }
        }
    }

带注释的选择排序：

    public void sort(int[] i) {
        //排序完是从小到大
        //只需要排序 i.length - 1 轮
        //54321
        //14325
        //12345
        
        for (int j = 0; j < i.length - 1; j++) {
            //外层循环保证循环多少次
            int min = i[j]; //假定最小值为当前值
            int temp = j;   //记录最小值的下标
//            System.out.println("j = " + j);
//            System.out.println("min = " + min);
//            System.out.println("temp = " + temp);
            for (int z = j; z < i.length; z++) {
                //开头的位置可以后移，所以跟着j走
                //内层循环干活，找最小值并交换
//                System.out.println("\tz = " + z);
                if(i[z] < min) {
                    min = i[z];
//                    System.out.println("\t\tmin = " + min);
                    temp = z;
//                    System.out.println("\t\ttemp = " + temp);
                }
                
                if(z == i.length - 1) {
                    //循环到最后一个位置了，上面那个if也走过了
                    if(min != i[j]) {
                        //如果最小值是i[j]就不用动位置，所以这里判断不是i[j]的才调换位置
                        i[temp] = (i[temp] ^ i[j]);
                        i[j] = (i[temp] ^ i[j]);
                        i[temp] = (i[temp] ^ i[j]);
                    }
                }
            }
        }
    }

带注释的冒泡排序

    public void sort(int[] i) {
        for(int j = 0; j < i.length - 1; j++) {
            //只要做数组长度 - 1 轮就可以排序完毕
            for (int m = i.length - 1, n = 0; m >= 1; m--,n++) {
                //m是判断遍历到哪个位置截止
                //n是保证从0开始
                
                //每一轮遍历的数量都比上一轮遍历的数量 - 1
                //假设数组长度为5
                //第一轮应该遍历从1 - 5(0 - 4)  5
                //第二轮应该遍历从1 - 4(0 - 3)  4
                //第四轮应该遍历从1 - 2(0 - 1)  1
                
                //实属是自己把自己绕晕了……
                
                if(i[n + 1] < i[n]) {
                    //交换
                    i[n] = (i[n] ^ i[n + 1]);
                    i[n + 1] = (i[n] ^ i[n + 1]);
                    i[n] = (i[n] ^ i[n + 1]);
                }
            }
        }
    }