选择排序：

    public void sort(int[] i) {
        //排序完是从小到大
        //只需要排序 i.length - 1 轮

        for (int j = 0; j < i.length - 1; j++) {
            //外层循环保证循环多少次
            int min = i[j]; //假定最小值为当前值
            int temp = j;   //记录最小值的下标
            for (int z = j; z < i.length; z++) {
                //开头的位置可以后移，所以跟着j走
                //内层循环干活，找最小值并交换
                if(i[z] < min) {
                    min = i[z];
                    temp = z;
                }

                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]);
                }
            }
        }
    }