常见排序算法

本文主要是介绍常见排序算法，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

目标：用 Junit 练习 4 个常见的排序算法

步骤：

设置成员变量 & 常量

private int[] arr;
private final int[] target = new int[]{19, 24, 29, 47, 47, 71, 78, 99};

加入 @Before 和 @After

@Before
public void start() {
    arr = new int[]{47, 29, 71, 99, 78, 19, 24, 47}; // 每个 @Test 运行前,把数组赋给 arr 成员变量

    System.out.println("========================== start ==========================");
    System.out.println(Arrays.toString(arr));
}

@After
public void after() {
    System.out.println(Arrays.toString(arr));
    System.out.println("==========================  end  ==========================");

    Assert.assertArrayEquals(target, arr); // 每个 @Test 方法运行后，校验排序结果 arr 是否符合预期
}

1 冒泡排序

@Test
public void bubbleSort(){
    System.out.println(String.format("the method %s is running", Thread.currentThread().getStackTrace()[1].getMethodName()));
    for (int i = 0; i < arr.length; i++) {
        for (int j = 1; j < arr.length - i; j++) {
            if (arr[j - 1] > arr[j]) {
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            }
        }
    }
}

2 选择排序

@Test
public void selectionSort() {
    System.out.println(String.format("the method %s is running", Thread.currentThread().getStackTrace()[1].getMethodName()));
    for (int i = 0; i < arr.length; i++)  {
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[i] > arr[j]) {
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

3 插入排序

@Test
public void insertionSort() {
    System.out.println(String.format("the method %s is running", Thread.currentThread().getStackTrace()[1].getMethodName()));
    for (int i = 1; i < arr.length; i++) {
        int insertVal = arr[i]; // 要插入的值
        int index = i - 1; // 要插入的位置
        for (;index >= 0 && arr[index] > insertVal; --index) {
            arr[index + 1] = arr[index];
        }
        arr[index + 1] = insertVal;
    }
}

4 快速排序

@Test
public void quickSort() {
    System.out.println(String.format("the method %s is running", Thread.currentThread().getStackTrace()[1].getMethodName()));
    equalsAndMove(0, arr.length - 1);
}

private void equalsAndMove(int start, int end) {
    if (start >= end) return; // 递归出口

    int inStart = start;
    int inEnd = end;
    int key = arr[instart]; // 基准值

    while (inStart != inEnd) {
　　　　 // 从右往左遍历，如果元素小于基准值，就把元素的值赋给 inStart（基准值动态位置）
        while (inStart < inEnd && key < arr[inEnd]) {
            inEnd--;
        }
        if (inStart < inEnd) {
            arr[inStart++] = arr[inEnd];
        }

        // 从左往右遍历，如果元素大于基准值，就把元素的值赋给 inEnd（基准值动态位置）
        while (inStart < inEnd && key > arr[inStart]) {
            inStart++;
        }
        if (inStart < inEnd) {
            arr[inEnd--] = arr[inStart];
        }
    }
    arr[inStart] = key; // 至此，左边元素都小于基准值，右边元素都大于基准值

    equalsAndMove(start, inEnd - 1); // 递归处理基准值左边的
    equalsAndMove(inStart + 1, end); // 递归处理基准值右边的
}

这篇关于常见排序算法的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！