力扣刷题之排序算法篇

力扣刷题之排序算法篇

为了提高自我对各种算法了理解，和提高解决实际问题的能力，在力扣网进行刷题，由于我熟练掌握两种语言，即每道题提供java，和Python的解题通过代码！如果内容有类似的可以联系我进行删除。

---

题目来源和相关知识请查看：力扣

---

1. 冒泡排序

冒泡排序：依存比较第i个关键字和第i+1个关键字，大的网排后，一趟得到最大值

先看力扣：剑指 Offer 45. 把数组排成最小的数，了解一下

练习题1:输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。

示例 1:

输入: [10,2]
输出: "102"

示例 2:

输入: [3,30,34,5,9]
输出: "3033459"

1. 用冒泡排序手工排序一下3,30,34,5,9 有

次序	3	30	34	5	9
第一次	3	30	5	9	34
第二次	3	5	9	30	34
第三次	3	5	9	30	34
第四次	3	5	9	30	34
第五次	3	5	9	30	34

2. 学会了手动排序接下来就是通过代码实现了

public class BubbleSort {
    public static void main(String[] args) {
        int sortList[] = {3, 30, 34, 5, 35};
        for (int i = 0; i < sortList.length; i++) {
            for (int j = 0; j < sortList.length - (i+1); j++) {
                if (sortList[j]>sortList[j+1]){
                    int l1=sortList[j];
                    sortList[j]=sortList[j+1];
                    sortList[j+1]=l1;
                }
            }
        }
        for (int s:sortList) System.out.println(s);
    }
}

Python

def bubbleSort(sortList):
    for i in range(len(sortList)):
        for j in range(len(sortList) - (i + 1)):
            if sortList[j] > sortList[j + 1]:
                tem = sortList[j]
                sortList[j] = sortList[j + 1]
                sortList[j + 1] = tem

最后在此基础上解出这道题目

class Solution {
        public String minNumber(int[] nums) {
            StringBuilder ls= new StringBuilder();
            for (int i = 0; i < nums.length; i++) {
                for (int j = 0; j < nums.length - (i+1); j++) {
                    if ((nums[j]+""+nums[j+1]).compareTo(nums[j+1]+""+nums[j])>0){
                        int l1=nums[j];
                        nums[j]=nums[j+1];
                        nums[j+1]=l1;
                    }
                }
                ls.insert(0, nums[nums.length - (i + 1)]+"");
            }
            return ls.toString();
        }
    }
   // 通过	27 ms	38.7 MB	Java	2021/05/13 20:47

通过冒泡排序写出来不过在消耗时间和内存上还是蛮高的

2.选择排序

选择排序：两重循环遍历数组，经过每一轮的比较，找到最小元素的下标，然后将最少元素放到首位；感觉和冒泡排序差不多

public class SelectionSort {
    public static void main(String[] args) {
        int nums[]={2,6,9,1,3,7};
        int minx=0;
        for (int i=0;i<nums.length;i++) {
            minx=i;
            for (int j = i; j < nums.length; j++) {
                if (nums[minx]>nums[j]) minx=j;
            }
            int tem=nums[i];
            nums[i]=nums[minx];
            nums[minx]=tem;
        }
        for (int n :nums) System.out.println(n);
    }
}

排序的稳定性：排序的如果有多个数字相同，如nums=【1，5,2,6,2】此时nums[2]=nums[4]=2; 排序后 之前的nums[2]还在nums[4]前边的则这个算法是稳定的；
其和冒泡排序对比，都是两层循环；冒泡排序时稳定的，选择排序时不稳定的

215. 数组中的第K个最大元素
     在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
     示例 1:

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5