Java 插入排序-语法问题

我遇到了一种相当奇特的速记法：

a[j+1]=a[j--]

这行似乎执行两个操作：

向右移动[j]和递减j

有没有可能把它分解成单独的步骤来帮助我理解速记

伪代码：

n=A.length
for i <- 1 to n-1
    curr = A[i]
    j = i - 1
    while j >= 0 && A[j] > curr
        A[j+1] = A[j--]
    A[j+1] = curr

n=A.length
对于i=0&&A[j]>curr
A[j+1]=A[j--]
A[j+1]=当前

当然可以：

int targetIndex = j + 1;
int tmp = j;
j--;
A[targetIndex] = A[tmp];

请注意，

targetIndex

是在任何其他情况发生之前计算的-赋值运算符的左侧在右侧之前有效确定

但是，递减发生在赋值本身发生之前，甚至在计算右侧数组访问之前。您可以在这个示例代码中看到：

public class Test {
    public static void main(String[] args) {
        int[] x = { 0, 1, 2, 3, 4 };
        int j = 3;
        try {
            x[j + 1] = x[j-- + 10];
        } catch (Exception e) {
            System.out.println("Caught exception");
        }

        System.out.println(j); // Prints 2
    }
}

在这里，您可以看到

j

已被递减，即使赋值本身无法发生

事实上，如果我们使用

x[j+10]=x[j--]，也会发生同样的情况-换句话说，如果目标索引超出范围。发现时，减量已经发生。
确定：

int targetIndex = j + 1;
int tmp = j;
j--;
A[targetIndex] = A[tmp];

请注意，
targetIndex
是在任何其他情况发生之前计算的-赋值运算符的左侧在右侧之前有效确定

但是，递减发生在赋值本身发生之前，甚至在计算右侧数组访问之前。您可以在这个示例代码中看到：

public class Test {
    public static void main(String[] args) {
        int[] x = { 0, 1, 2, 3, 4 };
        int j = 3;
        try {
            x[j + 1] = x[j-- + 10];
        } catch (Exception e) {
            System.out.println("Caught exception");
        }

        System.out.println(j); // Prints 2
    }
}

在这里，您可以看到
j
已被递减，即使赋值本身无法发生

事实上，如果我们使用
x[j+10]=x[j--]，也会发生同样的情况-换句话说，如果目标索引超出范围。在发现时，减量已经发生。
因为在您的示例中，
j
总是小于
A.length

A[j+1] = A[j--];

与

int index = j + 1;
A[index] = A[j];
j = j - 1;

如以下程序所示：

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {

        int[] A = { 1, 2, 3, 4, 5 };

        int j = 2;
        A[j+1] = A[j--];

        // prints: [1, 2, 3, 3, 5]
        System.out.println(Arrays.toString(A));

    }
}

因为在您的示例中，
j
总是小于
A.length

A[j+1] = A[j--];

与

int index = j + 1;
A[index] = A[j];
j = j - 1;

如以下程序所示：

import java.util.Arrays;

public class Test {
    public static void main(String[] args) {

        int[] A = { 1, 2, 3, 4, 5 };

        int j = 2;
        A[j+1] = A[j--];

        // prints: [1, 2, 3, 3, 5]
        System.out.println(Arrays.toString(A));

    }
}

我不知道我是否很理解你的问题，但是如果你不确定j-，试试我的例子。显示了--j和j之间的差异--它可以在将来帮助您：

public static void main(String[] args) {
    int j = 10;
    System.out.println("Current=" + j);
    System.out.println(j--);
    System.out.println("Current=" + j);
    System.out.println(--j);
    System.out.println("Current=" + j);
}

输出：

Current=10
10
Current=9
8
Current=8

我不知道我是否很理解你的问题，但是如果你不确定j-，试试我的例子。显示了--j和j之间的差异--它可以在将来帮助您：

public static void main(String[] args) {
    int j = 10;
    System.out.println("Current=" + j);
    System.out.println(j--);
    System.out.println("Current=" + j);
    System.out.println(--j);
    System.out.println("Current=" + j);
}

输出：

Current=10
10
Current=9
8
Current=8

不，不是。我的答案中有一个反例——如果
a[index]=a[j]赋值失败（例如，由于索引超出范围），则
j
不会在翻译中更改。。。但事实上它会减少。我已经取消了否决票，但我认为更清楚的是讨论什么是一般翻译。。。编译器并不是真的要把减量放在赋值之后。是的，同意。我认为在这个问题上没有必要这样做，但我可能判断错了。不，不是。我的答案中有一个反例——如果
a[index]=a[j]赋值失败（例如，由于索引超出范围），则
j
不会在翻译中更改。。。但事实上它会减少。我已经取消了否决票，但我认为更清楚的是讨论什么是一般翻译。。。编译器并不是真的要把减量放在赋值之后。是的，同意。我认为在这个问题上没有必要这样做，但我可能判断错误。谢谢！你的回答很有帮助。为了进一步简化，我们可以用A[j+1]=A[j-]代替A[j+1]=A[j]；j--@爸爸：不，因为如果数组访问中出现异常，它不会最终递减
j
。这就是我的例子的要点——证明递减发生在数组索引之前。谢谢！你的回答很有帮助。为了进一步简化，我们可以用A[j+1]=A[j-]代替A[j+1]=A[j]；j--@爸爸：不，因为如果数组访问中出现异常，它不会最终递减
j
。这就是我的示例的要点——证明递减发生在数组索引之前。