八大排序算法java实现

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArrayList<Integer> list = new ArrayList<>();
        while(sc.hasNextInt()) {
            int n = sc.nextInt();
            list.add(n);
        }

//        使用某种排序
//        mergeSort(list);
        for(int i = 0; i < list.size(); i++) {
            System.out.println("第" + i + "个数:" + list.get(i));
        }

        // 7 基数排序
    }

    public static void swap(ArrayList<Integer> list, int i, int j) {
        int x = list.get(i);
        int y = list.get(j);
        list.set(i, y);
        list.set(j, x);
    }

    // 1 插入排序
    public static void insertSort(ArrayList<Integer> list) {
        boolean flag;
        for(int i = 1; i < list.size(); i++) {
            flag = true;
            for(int j = i; j > 0 && flag; j--) {
                flag = false;
                if(list.get(j) < list.get(j - 1)) {
                    swap(list, j, j - 1);
                    flag = true;
                }
            }
        }
    }

    // 2 希尔排序
    public static void shellSort(ArrayList<Integer> list) {
        for(int gap = list.size() / 2; gap >= 1; gap /= 2) {
            for(int i = 0; i < gap; i++) {
                for(int j = i; j < list.size(); j += gap) {
                    while(j - gap > 0 && list.get(j - gap) > list.get(j)) {
                        swap(list, j - gap, j);
                        j -= gap;
                    }
                }
            }
        }
    }

    // 3 直接选择排序
    public static void chooseSort(ArrayList<Integer> list) {
        for(int i = 0; i < list.size() - 1; i++) {
            int min = list.get(i);
            for(int j = i + 1; j < list.size(); j++) {
                if(list.get(j) < min) {
                    swap(list, i, j);
                    min = list.get(i);
                }
            }
        }
    }

    // 4 堆排序
    public static void heapSort(ArrayList<Integer> list) {
        PriorityQueue<Integer> queue = new PriorityQueue<>(
                new Comparator<Integer>() {
                    @Override
                    public int compare(Integer o1, Integer o2) {
                        return o2 - o1;
                    }
                }
        );
        for(int i = 0; i < list.size(); i++) {
            queue.offer(list.get(i));
        }
        for(int i = 0; i < list.size(); i++) {
            list.set(i, queue.poll());
        }
    }

    // 5 快速排序
    public static void quickSort(ArrayList<Integer> list, int begin, int end) {
        if(begin >= end) return;
        int a = begin;
        int b = end;
        int temp = list.get(begin);
        while(begin < end) {
            while(begin < end && list.get(end) > temp) {
                end--;
            }
            if(begin == end) break;
            list.set(begin, list.get(end));
            begin++;
            while(begin < end && list.get(begin) < temp) {
                begin++;
            }
            if(begin == end) break;
            list.set(end, list.get(begin));
            end--;
        }
        list.set(end, temp);
        quickSort(list, a, end - 1);
        quickSort(list, end + 1, b);
    }

    // 6 冒泡排序
    public static void bubbleSort(ArrayList<Integer> list) {
        boolean flag = true;
        for(int i = 0; i < list.size() - 1 && flag == true; i++) {
            flag = false;
            for(int j = 0; j < list.size() - 1 - i; j++) {
                if(list.get(j) > list.get(j + 1)) {
                    swap(list, j, j + 1);
                    flag = true;
                }
            }
        }
    }

    // 7 基数排序
    // TODO
    

    // 8 归并排序
    public static void mergeSort(ArrayList<Integer> list) {
        int[] arr = new int[list.size()];
        supMergeSort(list, 0, list.size() - 1, arr);
    }

    public static void supMergeSort(ArrayList<Integer> list, int begin, int end, int[] arr) {
        if(begin < end) {
            int mid = (begin + end) / 2;
            supMergeSort(list, begin, mid, arr);
            supMergeSort(list, mid + 1, end, arr);
            merge(list, begin, mid, end, arr);
        }
    }

    public static void merge(ArrayList<Integer> list, int begin, int mid, int end, int[] arr) {
        int i = begin;
        int j = mid + 1;
        int index = 0;
        while(i <= mid && j <= end) {
            if(list.get(i) < list.get(j)) {
                arr[index++] = list.get(i++);
            } else {
                arr[index++] = list.get(j++);
            }
        }
        while(i <= mid) {
            arr[index++] = list.get(i++);
        }
        while(j <= end) {
            arr[index++] = list.get(j++);
        }
        for(i = begin, index = 0; i <= end; i++, index++) {
            list.set(i, arr[index]);
        }
    }
}

基数排序不会写。。

展开阅读全文

没有更多推荐了,返回首页