基础算法3——直接选择排序和堆排序

public class MySelectionSort {

    // 直接选择排序
    public void StraightSelectionSort(double[] sorted) {
        for (int i = 1; i < sorted.length; i++) {
            int minIndex = findMinIndex(sorted, i);
            exchange(sorted, i, minIndex);
        }
    }

    private void exchange(double[] sorted, int i, int j) {
        // TODO Auto-generated method stub
        if (i < sorted.length && j < sorted.length && i < j && i >= 0 && j >= 0) {
            double temp = sorted[i];
            sorted[i] = sorted[j];
            sorted[j] = temp;
        }
    }

    private int findMinIndex(double[] sorted, int i) {
        // TODO Auto-generated method stub
        int minIndex = 1;
        double minValue = Double.MAX_VALUE;
        for (int j = i; j < sorted.length; j++) {
            if (sorted[j] < minValue) {
                minValue = sorted[j];
                minIndex = j;
            }
        }
        return minIndex;
    }

    //小顶堆
    public void heapSelectionSort(double[] sorted) {
        int sortedLen = sorted.length;

        for (int i = sortedLen / 2; i > 0; i--) {
            heapAdjust(sorted, i, sortedLen);
        }
        for (int i = sortedLen; i > 1; --i) {
            exchange(sorted, 1, i);
            heapAdjust(sorted, 1, i - 1);
        }
    }

    public void heapAdjust(double[] sorted, int start, int end) {
        if (start < end) {
            double temp = sorted[start];
            // 这个地方j<end与课本不同，j<=end会报错：
            for (int j = 2 * start; j < end; j *= 2) {
                if (j + 1 < end && sorted[j] - sorted[j + 1] > 10e-6) {
                    ++j;
                }
                if (temp <= sorted[j]) {
                    break;
                }
                sorted[start] = sorted[j];
                start = j;
            }
            sorted[start] = temp;
        }
    }

}