Java排序算法

1. 冒泡排序算法

public class Solution {
    public int[] bubble(int[] nums){
        // 外层循环
        for (int i=0; i<nums.length; i++){
            // 内层循环--比较相邻的数大小
            for (int j=1; j<nums.length; j++){
                // 判断大小
                if(nums[j-1] > nums[j]){
                    // 前面大于后面--互换
                    int temp = nums[j-1];
                    nums[j-1] = nums[j];
                    nums[j] = temp;
                }
            }
        }
        return nums;
    }
    public static void main(String[] args){
        int[] nums = {3,4,1,2,4,6,8,1};
        Solution solution = new Solution();
        int[] bubble = solution.bubble(nums);
        for (int bu : bubble) System.out.print(bu+" ");
    }
}

2. 插入排序算法

public class Solution {
    public int[] insert(int[] nums){
        // j是记忆要插入的位置，外循环结束时插入进去
        // 定义临时变量temp 保存每次要插入的数
        int j, temp = 0;
        // 外循环， i=1 开始，第0位是默认排序好的
        for (int i=1; i<nums.length; i++){
            // 要插入的数
            temp = nums[i];
            // 内循环
            // 第i位数字 与 i前面 的数字比较，
            // 1.如果 nums[i] > nums[j] 即i前面的数，
            //   后面的 j 往后移一位 ， 前面的位置空出来插入nums[i]，
            //   在 j-1 在继续往前比较， 直到找到一个不大于nums[i]的数，
            //   或者移到 第 0 位 结束内循环，
            //   跳出内循环 把 j+1 位就是要插入的位置，
            //   为什么是j+1 位呢？ 每次比较完 j都进行了一次 j--，
            //   所有 j是比实际位置小一位， 所以要加一，
            
            // 2.如果从一开始 nums[i] 大于前面的，就直接跳出循环，
            //   因为前面的是排序好的，一定比后面的小，
            //   不像冒泡排序法， 每次内循环结束前面可能出现没有排序好的。
            
            for (j = i-1; j>=0; --j){
                // 要插入的数 与 前面的数 比较
                if(nums[j] > temp){
                    // 前面一个往后移一位
                    nums[j+1] = nums[j];
                }else{
                    break;
                }
            }
            // 记录的临时变量插入 要插入的位置 j+1
            nums[j+1] = temp;
        }
        return nums;
    }
    public static void main(String[] args){
        int[] nums = {3,4,1,2,4,6,8,1};
        Solution solution = new Solution();
        int[] insert = solution.insert(nums);
        for (int inset : insert) System.out.print(inset+" ");
    }
}

**3. 链表插入排序算法 **

public class Solution {
    public ListNode insertionSortList(int[] nums) {
        // 数组为空 返回空数组
        if (nums.length == 0) return null;
        
        // 创建一个链表 , 把数组第一个元素作为头节点
        ListNode head = new ListNode(nums[0]);
        // 创建一个节点 指向头节点 current = head
        // -1 -> null
        ListNode current = head;
        for (int i = 1; i < nums.length; i++) {
            // ListNode(nums[i]) 创建一个节点
            // 并赋给 current下一个节点 current.next 
            current.next = new ListNode(nums[i]);
            // -1 -> 5 -> null
            // current = current.next 指向下一个节点
            // 指针往下移
            current = current.next;
           
        }
        
        // 创建一个 哑节点 当作头节点
        ListNode dummyHead = new ListNode(0);
        // dummyHead.val = 0
        // dummyHead.next -> head 就等于
        // 0 -> -1 -> 5 -> 3 -> 4 -> 0 -> null
        dummyHead.next = head;
        // 创建一个排序的 要排序比较节点 lastSorted 
        // lastSorted 前面的节点都是排序好的
        
        // 和当前的节点 curr
        // 注意的是 curr = head.next 比 lastSorted = head 后一位
        //       curr：      5 -> 3 -> 4 -> 0 -> null
        // lastSorted：-1 -> 5 -> 3 -> 4 -> 0 -> null
        ListNode lastSorted = head, curr = head.next;
        
        // 如果 curr 还有节点就继续循环
        while (curr != null) {
            // lastSorted 当前节点 <= curr当前节点
            // lastSorted 和 curr 都要移一位
            // -1 < 5
            if (lastSorted.val <= curr.val) {
                // lastSorted 往下移
                lastSorted = lastSorted.next;
            }
            // 5 > 3
            else {
                // 创建一个y临时节点，当作 前节点
                ListNode prev = dummyHead;
                // 因为 lastSorted.val <= curr.val
                // 所以 要找到 lastSorted前一个节点
                // prev.next.val <= curr.val 来找到前一个节点       
                while (prev.next.val <= curr.val) {
                    // 没有找到继续往下走
                    prev = prev.next;
                }
                // 跳出循环说明找到了 
                // prev = -1 lastSorted = 5 curr = 3
                
                // lastSorted.next = curr.next;
                // lastSorted.next -> 4 -> 0 -> null
                // curr 的前节点断开了
                lastSorted.next = curr.next;
                
                
                // curr.next = prev.next;
                // curr.next 指向prev.next节点
                // prev.next 原来是指向 lastSorted
                // lastSorted.val = 5
                // 所以现在 curr.next -> 5 -> 4 -> 0 -> null
                // curr.val的位置没有变 还是等于 3 
                curr.next = prev.next;
                
                // prev.next = curr;
                // curr.val = 3
                // prev.next -> 3 -> 5 -> 4 -> 0 -> null
                prev.next = curr;
                
                // 最后 prev = -1 lastSorted = 5 curr = 3
                // 节点指向的next 改变了
            }
            // -1 -> 3 -> 5 -> 4 -> 0 -> null
            // curr 往下移一位
            curr = lastSorted.next;
        }
        return dummyHead.next;
    }


    public static void main(String[] args){
        int[] x = {-1,5,3,4,0};
        Solution solution= new Solution();
        ListNode listNode = solution.insertionSortList(x);
        while (listNode != null){
            System.out.printf("%d -> ",listNode.val);
            listNode = listNode.next;
        }
    }

}

** 4. 选择排序算法**

public class Solution {
    public int[] select(int[] nums){
        // 外循环
        for (int i=0; i<nums.length; i++){
            // 记录要排序的位置， 从0开始一位一位 排序
            int minInt = i;
            // 内循环
            // 第 i 位要排序的位置 不用比较
            // i 前面的都是排序好的
            for(int j=i+1; j<nums.length; j++){
                // nums[j] < nums[minInt]
                // 找到 最小数的 的位置(下标)
                if(nums[j] < nums[minInt]){
                    minInt = j;
                }
            }
            // 如果 i != minInt 说明最小的位置不是在 i 位继续交换
            // 如果 第 i 位是最小的 j 就没有赋给过 minInt， i = minInt
            // 所以加上判断 减少比较
            if(i != minInt){
                // 要排序的位置的值 与 最小的的位置的值 进行 交换
                int temp = nums[i];
                nums[i] = nums[minInt];
                nums[minInt] = temp;
            }
        }
        return nums;
    }
    public static void main(String[] args) {
        int[] nums = {3, 4, 1, 2, 4, 6, 8, 1};
        Solution solution = new Solution();
        int[] select = solution.select(nums);
        for (int se : select) System.out.print(se + " ");
    }
}

这是我自己理解的排序算法，
看不懂得可以问我，我也是一个菜鸡，
刚学算法不久。

关注我公众号： 老许学Java

大家一起学习呀。