leetcode算法数组篇day05-08

排序算法

1.冒泡排序

思想：从左到右依次比较相邻的泡泡，如果左侧>右侧，进行交换，否则保持不变，一次遍历完成最大的数据移到数组的最右侧，接下来除去右边最大的元素依次比较之前的元素，是右边第二个最大。
优化：设置一个flag，如果没有进行交换，说明元素有序，下次直接break不用进行交换。
最佳时间复杂度为O(n)–有序，最坏时间复杂度为O(n2)–降序
空间复杂度为O(1)–只有i，j和flag等常数变量的使用
输出数组的元素使用Arrays.toString(result)！
例如：5个数i=0时，冒泡4次（n-1）
i=1时，冒泡3次（n-i-1）

未加flag
import java.util.Arrays;

public class bubbleSort {
    public static void main(String[] args) {
        int[] nums = new int[]{5,4,2,3,1};
        int[] result = bubble(nums);
        System.out.println(Arrays.toString(result));
    }
    public static int[] bubble(int[] nums){
        int n = nums.length;
        for(int i = 0;i<n-1;i++){
            for(int j=0;j<n-i-1;j++){
                if(nums[j]>nums[j+1]){
                    //交换
                    int curr = nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=curr;
                }
            }
        }
        return nums;
    }
}

import java.util.Arrays;

public class bubbleSort {
    public static void main(String[] args) {
        int[] nums = new int[]{1,2,3,4,5};
        int[] result = bubble(nums);
        System.out.println(Arrays.toString(result));
    }
    public static int[] bubble(int[] nums){
        int n = nums.length;
        for(int i = 0;i<n-1;i++){
            //初始化
            boolean flag = true;
            for(int j=0;j<n-i-1;j++){
                if(nums[j]>nums[j+1]){
                    //交换
                    int curr = nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=curr;
                    // 进行交换说明有无序的
                    flag = false;
                }
            }
            //	进行某一轮交换后如果为true说明已经有序了，就不用在进行后面的比较了
            if(flag){
                break;
            }
        }
        return nums;
    }
}

2.选择排序

首先在未排序中找到最小元素存放到起始位置，再从剩余未排序元素中找到最小元素，存放到已排序元素的末尾。
时间复杂度为O(n2)
空间复杂度为O(1)

import java.util.+;

public class selectionSort {
    public static void main(String[] args) {
        int[] nums = new int[]{5,6,3,4,1};
        int[] result = selectionSort(nums);
        System.out.println(Arrays.toString(result));
    }

    public static int[] selectionSort(int[] nums){
        int n = nums.length;
        for(int i=0;i<n-1;i++){
            //记录最小元素的下标
            int minIndex = i;
            for(int j=i+1;j<n;j++){
                if(nums[j]<nums[minIndex]){
                    //找到最小的索引下标
                    minIndex = j;
                }
            }
            if(minIndex!=i){
                //交换
                int curr = nums[i];
                nums[i]=nums[minIndex];
                nums[minIndex]=curr;
            }
        }
        return nums;
    }
}

3.插入排序

待排序将第一个元素看成是有序的，从第二个元素比较看，插入到有序序列的适当位置。
最佳时间复杂度为O(n)–有序，最坏时间复杂度为O(n2)–降序
空间复杂度为O(1)

public class insertionSort {
    public static void main(String[] args) {
        int[] nums = new  int[]{3,4,1,6,7};
        int[] result = insertionSort(nums);
        System.out.println(Arrays.toString(result));
    }
    public static int[] insertionSort(int[] nums){
        int n = nums.length;
        for(int i=1;i<n;i++){
            int temp = nums[i];
            int j = i;
            while(j>0 && nums[j-1]>temp){
            //向前插入
                nums[j]=nums[j-1];
                j--;
            }
            if(i!=j){
                nums[j]=temp;
            }
        }
        return nums;
    }
}

4.归并排序

先分后合
将数组找到中点递归划分知道只有一个元素。
从长度为1的子数组开始合并，合并后的子数组有序。
时间复杂度为O(nlog(N))
空间复杂度为O(N)

import java.util.Arrays;

public class mergeSort {
    public static void main(String[] args) {
        int[] nums = new int[]{3, 5, 6, 2, 17, 8};
        mergeSort(nums, 0, nums.length - 1);
        System.out.println(Arrays.toString(nums));
    }

    public static void mergeSort(int[] nums, int left, int right) {
        //归并排序 直到拆成一个一个的数据
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(nums, left, mid);
            mergeSort(nums, mid + 1, right);
            merge(nums, left, mid, right);
        }
    }

    public static void merge(int[] nums, int left, int mid, int right) {
        int[] temp = new int[nums.length];
        int l = left, r = mid + 1;
        int index = 0;
        //左右两个子数组
        while (l <= mid && r <= right) {
            if (nums[l] < nums[r]) {
                temp[index++] = nums[l++];
            } else {
                temp[index++] = nums[r++];
            }
        }
        //某一块数据不存在了
        while (l <= mid) {
            temp[index++] = nums[l++];
        }
        while (r <= right) {
            temp[index++] = nums[r++];
        }
        //将新的数据赋值给原来的列表
        for (int i = left; i <= right; i++) {
            nums[i] = temp[i - left];
        }

    }
}

5.希尔排序(插入排序的变种)

将数组分为若按子数组按照一定间隔step，进行插入排序
时间复杂度为O(nlog2(N))
空间复杂度为O(1)

import java.util.Arrays;

public class shellSort {
    public static void main(String[] args) {
        int[] nums = new int[]{3,4,6,2,3};
        int[] result = shellSort(nums);
        System.out.println(Arrays.toString(result));
    }
    public static int[] shellSort(int[] nums){
        int n = nums.length;
        for(int step = n/2;step>=1;step/=2){
            for(int i = step;i<n;i++){
                int temp = nums[i];
                int j = i-step;
                while(j>=0&&nums[j]>temp){
                    nums[j+step]=nums[j];
                    j-=step;
                }
                nums[j+step] = temp;
            }
        }
        return nums;
    }
}