经典排序

1.冒泡排序

1.冒泡排序
Public static void bubbleSort1(int[] arr) {
    int length = arr.length;
    for (int i = length - 1; i > 0; i--) {
        for (int j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
冒泡排序改进(增加一个flag)
public static void bubbleSort2(int[] arr) {
    int length = arr.length;
    boolean flag;
    for (int i = length - 1; i > 0; i--) {
        flag = true;
        for (int j = 0; j < i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                flag = false;
            }
        }
        if (flag) break;
    }

2.直接插入排序

public static void insertSort(int[] arr) {
    int length = arr.length;
    for (int i = 1; i < length; i++) {
        for (int j = i - 1, k = i; j >= 0; j--, k--) {
            if (arr[j] > arr[k]) {
                int temp = arr[j];
                arr[j] = arr[k];
                arr[k] = temp;
            } else break;
        }
    }
}

public static void insertSort(int[] arr) {
    int length = arr.length;
    for (int i = 1; i < length; i++) {
        for (int j = i; j > 0; j--) {
            if (arr[j] < arr[j - 1]) {
                int temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
            } else break;
        }
    }
}

3.选择排序

public static void selectSort(int[] arr) {
    int length = arr.length;
    for (int i = 0; i < length; i ++) {
        int min = i;
        for (int j = i + 1; j < length; j++) {
            if (arr[j] < arr[min]) {
                min = j;
            }
        }
        if (min != i) {
            int temp = arr[min];
            arr[min] = arr[i];
            arr[i] = temp;
        }
    }
}

4.归并排序

1.数组实现

public static void main(String[] args) {
        int[] arr = {5,4,2,3,5,6};
        sort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }


    public static void sort(int[] arr) {
        mergeSort(arr,0, arr.length - 1);
    }

    public static void mergeSort(int[] arr, int L, int R) {
        if (L >= R) return;
        int mid = ((R - L) >> 1) + L;
        mergeSort(arr, L, mid);
        mergeSort(arr, mid + 1, R);
        merge(arr,L, R, mid);
    }

    public static void merge(int[] arr, int L, int R, int mid) {
        int[] temp = new int[R - L + 1];
        int i = L, j = mid + 1, k = 0;
        while (i <= mid && j <= R) {
            temp[k++] = arr[i] > arr[j] ? arr[j++] : arr[i++];
        }
        while (i <= mid) temp[k++] = arr[i++];
        while (j <= R) temp[k++] = arr[j++];
        for (i = 0; i < k; i++) {
            arr[L + i] = temp[i];
        }
    }

2.链表实现

public static void main(String[] args) {
        ListNode head = new ListNode(5);
        ListNode node1 = new ListNode(4);
        ListNode node2 = new ListNode(3);
        ListNode node3 = new ListNode(5);
        ListNode node4 = new ListNode(2);
        ListNode node5 = new ListNode(1);
        ListNode node6 = new ListNode(6);
        head.next = node1;node1.next = node2;
        node2.next = node3;node3.next = node4;
        node4.next = node5;node5.next = node6;
        ListNode newhead = mergeSortList(head);
        ListNode p = newhead;
        while (p != null) {
            System.out.print(p.val + " ");
            p = p.next;
        }
    }

    public static ListNode mergeSortList(ListNode head) {
        if (head == null || head.next == null) return head;
        ListNode slow = head;
        ListNode fast = head;
        ListNode prev = null;
        while (fast != null && fast.next != null) {
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }
        prev.next = null;
        ListNode l = mergeSortList(head);
        ListNode r = mergeSortList(slow);
        return merge(l, r);
    }

    public static ListNode merge(ListNode l, ListNode r) {
        ListNode head = new ListNode(0);
        ListNode cur = head;
        while (l != null && r != null) {
            if (l.val <= r.val) {
                cur.next = l;
                cur = l;
                l = l.next;
            } else {
                cur.next = r;
                cur = r;
                r = r.next;
            }
        }
        if (l != null) cur.next = l;
        if (r != null) cur.next = r;
        return head.next;
    }

5.快速排序

1.数组实现

public static void main(String[] args) {
        int[] arr = {5,4,6,5,3,4,2};
        quickSort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    public static void quickSort(int[] arr) {
        quickSort(arr, 0, arr.length - 1);
    }

    public static void quickSort(int[] arr, int left, int right) {
        if (left >= right) return;
        int mid = partition(arr, left, right);
        quickSort(arr, left, mid - 1);
        quickSort(arr, mid + 1, right);
    }

    public static int partition(int[] arr, int left, int right) {
        int key = arr[left];
        while (left < right) {
            while (left < right && arr[right] >= key) right--;
            arr[left] = arr[right];
            while (left < right && arr[left] <= key) left++;
            arr[right] = arr[left];
        }
        arr[left] = key;
        return left;
    }

2.链表实现

public static void main(String[] args) {
        ListNode head = new ListNode(5);
        ListNode node1 = new ListNode(2);
        ListNode node2 = new ListNode(6);
        ListNode node3 = new ListNode(4);
        ListNode node4 = new ListNode(1);
        ListNode node5 = new ListNode(5);
        ListNode node6 = new ListNode(3);
        head.next = node1;node1.next = node2;
        node2.next = node3;node3.next = node4;
        node4.next = node5;node5.next = node6;
        ListNode newhead = quickSortList(head);
        ListNode p = newhead;
        while (p != null) {
            System.out.print(p.val + " ");
            p = p.next;
        }

    }
    public static ListNode quickSortList(ListNode head) {
        if (head == null || head.next == null) return head;
        quickSortList(head,null);
        return head;
    }

    public static void quickSortList(ListNode head, ListNode tail) {
        if (head == tail || head.next == tail) return;
        ListNode mid = partition(head,tail);
        quickSortList(head,mid);
        quickSortList(mid.next,tail);
    }
    public static ListNode partition(ListNode head, ListNode tail) {
        int key = head.val;
        ListNode l = head;
        ListNode r = head.next;
        while (r != tail) {
            if (r.val < key) {
                l = l.next;
                swap(l,r);
            }
            r = r.next;
        }
        swap(l,head);
        return l;
    }

    public static void swap(ListNode node1, ListNode node2) {
        int temp = node1.val;
        node1.val = node2.val;
        node2.val = temp;
    }

6.堆排序

public static void main(String[] args) {
        int[] arr = {5,4,6,5,3,4,2};
        heapSort(arr);
        for (int i : arr) {
            System.out.print(i + " ");
        }
    }

    public static void heapSort(int[] arr) {
        if (arr == null || arr.length <= 1) return;
        buildMaxHeap(arr);
        for (int i = arr.length - 1; i > 0; i--) {
            swap(arr, 0, i);
            adjustHeap(arr,0,i);
        }
    }

    public static void buildMaxHeap(int[] arr) {
        int len = arr.length;
        for (int i = len / 2 - 1; i >= 0; i--) {
            adjustHeap(arr,i,arr.length);
        }
    }

    public static void adjustHeap(int[] arr, int i, int len) {
        int left = 2 * i + 1;
        int right = 2 * i + 2;
        int maxindex = i;
        if (left < len && arr[left] > arr[maxindex]) {
            maxindex = left;
        }
        if (right < len && arr[right] > arr[maxindex]) {
            maxindex = right;
        }
        if (i != maxindex) {
            swap(arr,i,maxindex);
            adjustHeap(arr,maxindex, len);
        }
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }