几种排序算法及Java实现排序的几种方式

几种排序算法

下面的例子介绍了4种排序方法: 冒泡排序, 选择排序, 插入排序, 快速排序

package date201709.date20170915;

public class SortUtil {

    private static int quickSortTimes = 1;

    /**
     * 冒泡排序:<br>
     * 两层循环，每次循环比较前后两个元素，如果他们的顺序错误就把他们交换过来，一次循环后最终会把最大的数沉到数列的末端<br>
     * 下次循环时,上次循环沉到数列的末端的数不用再参与到本次循环中来比较<br>
     */
    // 第1次排序结果: 30 59 12 46 15 83 10 59 27 91
    // 第2次排序结果: 30 12 46 15 59 10 59 27 83 91
    // 第3次排序结果: 12 30 15 46 10 59 27 59 83 91
    // 第4次排序结果: 12 15 30 10 46 27 59 59 83 91
    // 第5次排序结果: 12 15 10 30 27 46 59 59 83 91
    // 第6次排序结果: 12 10 15 27 30 46 59 59 83 91
    // 第7次排序结果: 10 12 15 27 30 46 59 59 83 91
    // 第8次排序结果: 10 12 15 27 30 46 59 59 83 91
    // 第9次排序结果: 10 12 15 27 30 46 59 59 83 91
    public static void bubbleSort(int[] nums) {
        int temp = 0;
        int size = nums.length;
        for (int i = 0; i < size - 1; i++) {
            for (int j = 0; j < size - 1 - i; j++) {
                if (nums[j] > nums[j + 1]) {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
            printLog(nums, i + 1);
        }
    }

    /**
     * 选择排序:<br>
     * 在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环<br>
     */
    // 第1次排序结果: 10 83 59 12 46 15 91 30 59 27
    // 第2次排序结果: 10 12 59 83 46 15 91 30 59 27
    // 第3次排序结果: 10 12 15 83 46 59 91 30 59 27
    // 第4次排序结果: 10 12 15 27 46 59 91 30 59 83
    // 第5次排序结果: 10 12 15 27 30 59 91 46 59 83
    // 第6次排序结果: 10 12 15 27 30 46 91 59 59 83
    // 第7次排序结果: 10 12 15 27 30 46 59 91 59 83
    // 第8次排序结果: 10 12 15 27 30 46 59 59 91 83
    // 第9次排序结果: 10 12 15 27 30 46 59 59 83 91
    public static void selectSort(int[] nums) {
        int temp = 0;
        int size = nums.length;
        for (int i = 0; i < size - 1; i++) {
            // 记录每一次循环最小值的位置
            int pos = i;
            for (int j = i + 1; j < size; j++) {
                if (nums[pos] > nums[j]) {
                    pos = j;
                }
            }
            // 最小的数与第i个位置的数交换
            temp = nums[i];
            nums[i] = nums[pos];
            nums[pos] = temp;

            printLog(nums, i + 1);
        }
    }

    /**
     * 插入排序<br>
     * 每步将一个待排序的记录，按其大小插入到前面已经排序的字序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。<br>
     */
    // 第1次排序结果: 30 83 59 12 46 15 91 10 59 27
    // 第2次排序结果: 30 59 83 12 46 15 91 10 59 27
    // 第3次排序结果: 12 30 59 83 46 15 91 10 59 27
    // 第4次排序结果: 12 30 46 59 83 15 91 10 59 27
    // 第5次排序结果: 12 15 30 46 59 83 91 10 59 27
    // 第6次排序结果: 12 15 30 46 59 83 91 10 59 27
    // 第7次排序结果: 10 12 15 30 46 59 83 91 59 27
    // 第8次排序结果: 10 12 15 30 46 59 59 83 91 27
    // 第9次排序结果: 10 12 15 27 30 46 59 59 83 91
    private static void insertSort(int[] nums) {
        int temp = 0;
        int size = nums.length;
        // 从第2个元素开始，第1个元素可以认为已经被排序
        for (int i = 1; i < size; i++) {
            // 取出下一个元素
            temp = nums[i];
            // 在已经排序的元素序列中从前向后扫描
            for (int j = 0; j < i; j++) {
                // 假如temp比前面的某个值小，则将这个值及之后的值后移
                if (temp < nums[j]) {
                    for (int k = i; k > j; k--) {
                        nums[k] = nums[k - 1];
                    }
                    nums[j] = temp;
                    break;
                }
            }

            printLog(nums, i);
        }
    }

    /**
     * 快速排序:<br>
     * 选取当前数组段的第一个数作为中轴，和最后一个比，如果比它小交换，比它大(或相等)不做任何处理<br>
     * 交换了以后再和小的那端比，比它小不交换，比他大交换<br>
     * 这样循环往复，一趟排序完成，左边就是比中轴小的，右边就是比中轴大的，然后再递归对左边和右边的数组排序<br>
     */
    // 第1次排序结果: 27 10 15 12 30 46 91 59 59 83
    // 第2次排序结果: 12 10 15 27 -- -- -- -- -- --
    // 第3次排序结果: 10 12 15 -- -- -- -- -- -- --
    // 第4次排序结果: -- -- -- -- -- 46 91 59 59 83
    // 第5次排序结果: -- -- -- -- -- -- 83 59 59 91
    // 第6次排序结果: -- -- -- -- -- -- 59 59 83 --
    // 第7次排序结果: -- -- -- -- -- -- 59 59 -- --
    public static void quickSort(int[] numbers) {
        if (numbers.length > 1) {
            quickSort(numbers, 0, numbers.length - 1);
        }
    }

    private static void quickSort(int[] nums, int low, int high) {
        if (low < high) {
            // 选取中轴
            int middle = getMiddle(nums, low, high);
            printQuickSortLog(nums, low, high);
            if (low < middle - 1) {
                // 对低字段表进行递归排序
                quickSort(nums, low, middle - 1);
            }
            if (middle + 1 < high) {
                // 对高字段表进行递归排序
                quickSort(nums, middle + 1, high);
            }
        }
    }

    private static int getMiddle(int[] nums, int low, int high) {
        // 选取当前数组段的第一个数作为中轴
        int temp = nums[low];
        while (low < high) {
            // 比中轴大(或相等)不做任何处理(high--)，直到找到比中轴小的
            while (low < high && nums[high] >= temp) {
                high--;
            }
            // 比中轴小的记录移到低端
            nums[low] = nums[high];
            // 比中轴小不做任何处理(low++)，直到找到比中轴大(或相等)的
            while (low < high && nums[low] < temp) {
                low++;
            }
            // 比中轴大(或相等)的记录移到高端
            nums[high] = nums[low];
        }
        // 中轴记录到尾
        nums[low] = temp;
        // 返回中轴的位置
        return low;
    }

    private static void printLog(int[] nums, int times) {
        System.out.println("第" + times + "次排序结果:	" + formatNums(nums));
    }

    private static void printQuickSortLog(int[] nums, int low, int high) {
        System.out.println("第" + quickSortTimes++ + "次排序结果:	" + formatNums(nums, low, high));
    }

    private static String formatNums(int[] nums) {
        return formatNums(nums, 0, nums.length - 1);
    }

    private static String formatNums(int[] nums, int low, int high) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < low; i++) {
            sb.append("-- ");
        }
        for (int i = low; i <= high; i++) {
            sb.append(nums[i]).append(" ");
        }
        for (int i = high + 1; i < nums.length; i++) {
            sb.append("-- ");
        }
        return sb.toString().trim();
    }

    public static void main(String[] args) {

        // 10, 12, 15, 27, 30, 46, 59, 59, 83, 91
        int[] nums = { 30, 83, 59, 12, 46, 15, 91, 10, 59, 27 };
        // bubbleSort(nums);
        // selectSort(nums);
        // insertSort(nums);
        // quickSort(nums);
    }
}

Java实现排序的几种方式

(1) 需要排序的Bean实现Comparable<T>接口

package date201709.date20170915;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class User implements Serializable, Comparable<User> {

    private static final long serialVersionUID = 1L;

    private Integer id;

    private Integer age;

    private String name;

    public User(Integer id, Integer age, String name) {
        super();
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public Integer getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "User [id=" + id + ", age=" + age + ", name=" + name + "]";
    }

    @SuppressWarnings("serial")
    public static List<User> init() {
        return new ArrayList<User>() {
            {
                add(new User(5, 31, "Zhang San"));
                add(new User(2, 28, "Li Si"));
                add(new User(3, 26, "Wang Wu"));
                add(new User(1, 23, "Zhao Liu"));
                add(new User(4, 26, "Liu Qi"));
            }
        };
    }

    // 比较ID从而对User排序
    @Override
    public int compareTo(User o) {
        return this.getId().compareTo(o.getId());
    }
}

package date201709.date20170915;

import java.util.Collections;
import java.util.List;

public class UserTest {

    public static void main(String[] args) {
        // (1) Id升序
        List<User> userList = User.init();
        Collections.sort(userList);
        printList(userList);

        // (2) Id降序
        Collections.reverse(userList);
        printList(userList);
    }

    private static void printList(List<User> param) {
        param.forEach(p -> {
            System.out.println(p.toString());
        });
    }
}

(2) 使用内部类实现Comparator<T>接口

package date201709.date20170915;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class UserTest {

    public static void main(String[] args) {
        // (1) Age升序
        List<User> userList = User.init();
        Collections.sort(userList, new AgeComparator());
        printList(userList);

        // (2) Age降序
        Collections.reverse(userList);
        printList(userList);
    }

    private static void printList(List<User> param) {
        param.forEach(p -> {
            System.out.println(p.toString());
        });
    }

    static class AgeComparator implements Comparator<User> {
        @Override
        public int compare(User o1, User o2) {
            return o1.getAge().compareTo(o2.getAge());
        }
    }
}

(3) 使用匿名内部类实现Comparator<T>接口

package date201709.date20170915;

import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class UserTest {

    public static void main(String[] args) {
        // (1) Age升序
        List<User> userList = User.init();
        Collections.sort(userList, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {
                return o1.getAge().compareTo(o2.getAge());
            }
        });
        printList(userList);

        // (2) Age降序
        Collections.reverse(userList);
        printList(userList);
    }

    private static void printList(List<User> param) {
        param.forEach(p -> {
            System.out.println(p.toString());
        });
    }
}

(4) 使用lambda表达式

package date201709.date20170915;

import java.util.Collections;
import java.util.List;

public class UserTest {

    public static void main(String[] args) {
        // (1) Age升序
        List<User> userList = User.init();
        Collections.sort(userList, (a, b) -> (a.getAge().compareTo(b.getAge())));
        printList(userList);

        // (2) Age降序
        Collections.reverse(userList);
        printList(userList);
    }

    private static void printList(List<User> param) {
        param.forEach(p -> {
            System.out.println(p.toString());
        });
    }
}

(5) 使用stream及::表达式

package date201709.date20170915;

import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

public class UserTest {

    public static void main(String[] args) {
        // (1) Age升序
        List<User> userList = User.init();
        List<User> result1 = userList.stream().sorted((a, b) -> a.getAge().compareTo(b.getAge()))
                .collect(Collectors.toList());
        printList(result1);

        // (2) Age降序
        List<User> result2 = userList.stream().sorted(Comparator.comparing(User::getAge).reversed())
                .collect(Collectors.toList());
        printList(result2);
    }

    private static void printList(List<User> param) {
        param.forEach(p -> {
            System.out.println(p.toString());
        });
    }
}