实现int数组排序,内容(0~n-1),存在一固定方法swap()；功能为传入目标值与值0交换

题目: int数组排序 int[] array;

条件:

  1.存在int类型数组,{0~n-1}, 形如:{3,1,0,..,n-1};

  2.存在一固定不可修改方法swapMethod(array[], len, n); 功能:目标'值n'与'值0'进行交换(不是索引)

  3.实现sortMethod();实现数组排序;

以下为个人实现方式;  目前只知其然而不知其所以然, 期待各位大佬指点一二, 不胜感激!

实现一:

public class SortTest {

    public static void main(String[] args) {
        int[] array = {0, 1, 6, 3, 5, 2, 4, 10, 9, 8, 7};
        sortMethod(array);
        System.out.println(Arrays.toString(array));
    }

    /**
     * 数组排序
     * @param array int数组
     */
    private static void sortMethod(int[] array) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == i) {
                continue;
            }
            swapMethod(array, array.length, array[i]); //移动
            swapMethod(array, array.length, i);
        }
    }

    /**
     * !!!不可修改方法功能(只能传入值n与0交换),(该实现方式很挫..可自行.
     * 将目标值n与数组值0进行交换;(两个值都不是索引,指的是数组实际值)
     * @param array 数组
     * @param len 数组length
     * @param n 目标值n
     */
    public static void swapMethod(int[] array, int len, int n) {
        // 以下两处找索引的步骤应有更好的方式
        int index1 = 0;
        for (int i = 0; i < len; i++) {
            if (array[i] == 0) { // 找出值0的索引
                index1 = i;
                break;
            }
        }

        int index2 = 0;
        for (int i = 0; i < len; i++) {
            if (array[i] == n) { // 找出值n的索引
                index2 = i;
                break;
            }
        }

        int tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
    }
}

实现方式二: 变种实现, (跟除零的其他值交换)

public class SortTest2 {

    private static int swapVal = 3;

    public static void main(String[] args) {
        // 此处数组的"最小值"必须为swapVal(3);
        // 因为以最小值作为"交换位"或"缓冲位" ->才能排序, (另:理论上以最大值应该也可以,sortMethod相应修改)
        int[] array = {6, 3, 5, 4, 10, 9, 8, 7};
        sortMethod(array);
        System.out.println(Arrays.toString(array));
    }

    /**
     * 数组排序
     * @param array int数组
     */
    private static void sortMethod(int[] array) {
        int currRealVal;
        for (int i = 0; i < array.length; i++) {
            // 当前值 == i + swapVal;
            currRealVal = i + swapVal;
            if (array[i] == currRealVal) {
                continue;
            }
            swapMethod(array, array.length, array[i]);
            swapMethod(array, array.length, currRealVal);
        }
    }

    /**
     * !!!不可修改方法功能(只能传入值n与0交换),(该实现方式很挫..可自行.
     * 将目标值n与数组值0进行交换;(两个值都不是索引,指的是数组实际值)
     * @param array 数组
     * @param len 数组length
     * @param n 目标值n
     */
    public static void swapMethod(int[] array, int len, int n) {
        // 以下两处找索引的步骤应有更好的方式
        int swapIndex = 0;
        for (int i = 0; i < len; i++) {
            if (array[i] == swapVal) { // 找出交换值swapVal的索引
                swapIndex = i;
                break;
            }
        }

        int index2 = 0;
        for (int i = 0; i < len; i++) {
            if (array[i] == n) { // 找出值n的索引
                index2 = i;
                break;
            }
        }

        int tmp = array[swapIndex];
        array[swapIndex] = array[index2];
        array[index2] = tmp;

        /*array[swapIndex] = array[swapIndex] ^ array[index2];
        array[index2] = array[swapIndex] ^ array[index2];
        array[swapIndex] = array[swapIndex] ^ array[index2];*/
    }
}

期待大佬指点一二, 这到底是何原理, 依据什么理论??