排序算法的简单学习笔记
1、算法解释
对数据按照从小到大或从大到小的顺序，重新排列顺序
- 比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。
- 非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序
2、常用的排序算法
1）快速排序
- 在数组中随机选一个数（默认数组首个元素），数组中小于等于此数的放在左边，大于此数的放在右边，再对数组两边递归调用快速排序，重复这个过程
- 通俗地讲：以某个元素为基准，遍历其后面的所有元素比大小，小的放左边，大的放右边
核心代码
void quickSort(int[] nums. int left, int right) {
if(left + 1 >= right) return;
int first = left, last = right - 1, key = nums[first];
while(first < last) {
while(first < last && nums[last] >= key) {
last--;
}
nums[first] = nums[last];
while(first < last && nums[first] <= key) {
first++;
}
nums[last] = nums[first];
}
nums[first] = key;
quickSort(nums, left, first);
quickSort(nums, first + 1, right);
}
2）归并排序
- 首先让数组中的每一个数单独成为长度为1的区间，然后两两一组有序合并，得到长度为2的有序区间，依次进行，直到合成整个区间
- 通俗地讲：将数组一直对半切分，直至长度为2，对2个数进行排序；以此扩展4、8、16等
核心代码
void mergeSort(int[] nums, int left, int right, int[] temp){
if(left + 1 > right) return;
int mid = (left + right) / 2;
mergeSort(nums, left, mid, temp); // 这两行，是为了将长数组切分为两两比较的长度
mergeSort(nums, mid, right, temp);
int p = left, q = mid, i = left;
while(p < mid || q < right) {
if( q > right || (p < mid && nums[p] <= nums[q])) {
temp[i++] = nums[p++];
} else {
temp[i++] = nums[q++];
}
}
for(i = left; i < right; i++) {
nums[i] = temp[i];
}
}
3）插入排序
- 从第一个值开始，某一个值与其前面的所有值比大小，根据大小插入前面的顺序中
- 通俗地讲：以某个值为基准，与其前面所有元素比大小，放在第一个比它小的元素后面
核心代码
void insertionSort(int[] nums, int n) {
for(int i = 0; i < n; i++) {
for(int j = 0; j > 0 && nums[j] < nums[j-1]; j--) {
int temp = nums[j];
nums[j] = nums[j-1];
nums[j-1] = temp;
}
}
}
4）冒泡排序
- 一开始交换的区间为0~N-1，将第1个数和第2个数进行比较，前面大于后面，交换两个数，否则不交换
- 通俗地讲：从头到尾遍历一次，两两元素比较，将最大的值挪到最后；重复N次
核心代码
void bubbleSort(int nums, int n) {
boolean flag;
for(int i = 1; i < n; i++) {
flag = false;
for(int j = 1; j < n-i+1; j++) {
if(nums[j-1] > nums[j]) {
int temp = nums[j];
nums[j] = nums[j-1];
nums[j-1] = temp;
flag = true;
}
}
}
}
5）选择排序
- 一开始从0 ~ n-1区间上选择一个最小值，将其放在位置0上，然后在1~n-1范围上选取最小值放在位置1上
- 通俗地讲：以当前数组第一个元素为基准，找到数组最小的元素，交换位置，数组长度减1；重复操作
核心代码
void selectionSort(int[] nums, int n) {
int mid;
for(int i = 0; i < n - 1; i++) {
mid = i;
for(int j = i + 1; j < n; j++) {
if(nums[j] < nums[mid]) {
mid = j;
}
}
int temp = nums[mid];
nums[mid] = nums[i];
nums[i] = temp;
}
}
2、快速选择问题
快速排序一般用于求解TopK元素问题，可以在O(n)时间复杂度，O(1)空间复杂度完成
- 与快速排序一样，快速选择一般需要先打乱数组，否则最坏情况时间复杂度为O(n^2)
解题思路
- 与快速排序一样，以某元素为基准，将比其大的放右边，小的放左边，只是不用全部排序
Java解答
class Solution {
public int findKthLargest(int[] nums, int k) {
quickSort(nums,0,nums.length-1);
return nums[nums.length-k];
}//main
public void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
public int partition(int[] arr, int left, int right) {
// 采用三数中值分割法
int mid = left + (right - left) / 2;
// 保证左端较小
if (arr[left] > arr[right])
swap(arr, left, right);
// 保证中间较小
if (arr[mid] > arr[right])
swap(arr, mid, right);
swap(arr, left, mid);
// 保证中间最小，左右最大
int pivot = arr[left];
while (right > left) {
// 先判断基准数和后面的数依次比较
while (pivot <= arr[right] && left < right) {
--right;
}
// 当基准数大于了 arr[right]，则填坑
if (left < right) {
arr[left] = arr[right];
++left;
}
// 现在是 arr[right] 需要填坑了
while (pivot >= arr[left] && left < right) {
++left;
}
if (left < right) {
arr[right] = arr[left];
--right;
}
}
arr[right] = pivot;
return left;
}
public void quickSort(int[] arr, int left, int right) {
if (arr == null || left >= right || arr.length <= 1)
return;
int mid = partition(arr, left, right);
quickSort(arr, left, mid-1);
quickSort(arr, mid + 1, right);
}
}
3、桶排序问题
解题思路
- 为每种元素设立一个桶，桶内记录该元素的个数，然后对桶进行排序
- 使用哈希表统计频率，统计完成后，创建一个数组，将频率作为数组下标
- 对于出现频率不同的数字集合，存入对应的数组下标即可
Java解答
class Solution {
public int[] topKFrequent(int[] nums, int k) {
List<Integer> res = new ArrayList<>();
HashMap<Integer, Integer> numsMap = new HashMap<>();
for (int num : nums) {
if (numsMap.containsKey(num)) {
numsMap.put(num, numsMap.get(num) + 1);
} else {
numsMap.put(num, 1);
}
}
List<Integer>[] list = new List[nums.length + 1];
for (int key : numsMap.keySet()) {
int i = numsMap.get(key);
if(list[i] == null) {
list[i] = new ArrayList<>();
}
list[i].add(key);
}
for (int i = list.length - 1; i >= 0 && res.size() < k ; i--) {
if(list[i] == null) continue;
res.addAll(list[i]);
}
int[] arr = new int[k];
for (int j = 0; j < k; j++) {
arr[j] = res.get(j);
}
return arr;
}
}
4、练习
解题思路
- 使用字符数组，记录各字符出现的频次
- 遍历一次字符数组，找到频次最高的字符及其频次，添加为字符后，重复遍历字符数组
Java解答
class Solution {
public String frequencySort(String s) {
int[] chars = new int[128];
for (int i = 0; i < s.length(); i++) {
chars[s.charAt(i)]++;
}
StringBuilder builder = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
int max = 0, maxChar = 0;
for (int j = 0; j < chars.length; j++) {
if(chars[j] > max) {
max = chars[j];
maxChar = j;
}
}
chars[maxChar] = 0;
for (int k = 0; k < max; k++) {
builder.append((char) maxChar);
}
i = i + max - 1;
}
return builder.toString();
}
}
解题思想
- 根据快速排序方法，以1为基准，比较当前元素与1的大小
- 如果是0，则移动到表头，如果是2，则移动到表尾，不用考虑1
Java解答
class Solution {
public void sortColors(int[] nums) {
if (nums == null || nums.length == 0) {
return;
}
int x = -1, y = nums.length, i = 0;
while (i < y) {
if (nums[i] == 1) {
i++;
} else if (nums[i] < 1) {
x++;
int temp = nums[x];
nums[x] = nums[i];
nums[i] = temp;
i++;
} else {
y--;
int temp = nums[y];
nums[y] = nums[i];
nums[i] = temp;
}
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
