Question

我正在尝试对冒泡排序，选择排序和插入排序MYSELF进行编程。但是，我在插入排序方面遇到了麻烦。我将提供我的代码以及每一行的作用

public void sortMethod() {
    int count = 1;
    for (int j = 0; j < Unsorted.length - 1; j++) {
        int index = 0;
        if (Unsorted[count] < Unsorted[count - 1]) {
            int temp = Unsorted[count];
            for (int i = count; i > 0; i--) {
                if (Unsorted[i] > Unsorted[count]) {
                    index = i;
                    Unsorted[i] = Unsorted[i - 1];
                }
            }
            Unsorted[index] = Unsorted[count];
        }
        count = count + 1;
    }
}

好的，所以int计数是要找出排序数组的起始位置。然后，我声明了index，以查找将元素放在已排序数组之后的位置，并为未排序数组的第一个元素（如果它小于已排序数组的最后一个元素）声明了一个临时int。然后，它反转数组直到第一个元素，如果它大于我要添加的元素，则将索引分配给它的索引。从本质上讲，所以我知道将其放置在哪里。然后unsorted [I] = unsorted [I-1]将已排序的数组从未排序数组的第一个元素所属的位置移开。然后将未排序数组的第一个元素分配给它所属的位置。每次增加计数

Array: 31 27 45 23 22 3 1 13 1 42 
Array after sort: 27 1 1 3 22 23 1 1 1 42 
BUILD SUCCESSFUL (total time: 0 seconds)

Answer 1

这是我必须更改代码才能进行插入排序的最低数量，因为我了解这种工作方式。请注意，您使用的整数值多于必要的整数值，并且这里不需要多余的if。我提出了很多评论以反映我在解决问题时的想法，因此您可以希望理解代码在做什么：

public class Test
    private static int[] Unsorted = {444, 7, 22, 4, 3, 2, 1, -34, -999};

    public static void sortMethod() {

        // We'll consider each position in the array in order.  For each round,
        // 'j' is pointing at the last item in the part of the array that we know is
        // correctly sorted.  The first item after 'j' is the next candidate.  We
        // want to INSERT it into the right place in the part of the array that
        // is already sorted. NOTE: The first item is never a candidate because
        // an array with one element is always sorted.
        for (int j = 0; j < Unsorted.length - 1; j++) {
            // save off next candidate value, the first value that may be out of order
            int temp = Unsorted[j + 1];

            // Move all the items in the sorted part of the array that are greater
            // than the candidate up one spot.  We know we have room to shift up
            // because we've saved off the value at the candiate position.
            int i = j;
            while (i >= 0 && Unsorted[i] > temp) {
                Unsorted[i + 1] = Unsorted[i];
                i = i - 1;
            }
            // Put the candidate in the hole that is left.  This inserts it such
            // that everything below it has a value smaller than it, and everything
            // above it has a value greater than it.
            Unsorted[i + 1] = temp;

            // Now the array is sorted up to  the position j is pointing to and one
            // beyond, so we'll advance j by one position for the next round
        }
    }

    public static void main(String[] args) {
        sortMethod();
        for (int i = 0 ; i < Unsorted.length ; i++)
            System.out.println(Unsorted[i]);
    }
}

结果：

插入排序Java未正确排序

1 个答案: