# Leetcode sorting classic

## 215: Kth Element

Before solving the problem, review the Eight classic methods
Direct insert sort This link The content is easy to understand
Count sort not understood
Sorting: time complexity O(NlogN), space complexity O(1)

```public int findKthLargest(int[] nums, int k) {
Arrays.sort(nums);
return nums[nums.length - k];
}```

Heap: time complexity O(NlogK), space complexity O(K).

```public int findKthLargest(int[] nums, int k) {
PriorityQueue<Integer> pq = new PriorityQueue<>(); // Small top pile
for (int val : nums) {
if (pq.size() > k)  // Maintenance heap size is K
pq.poll();
}
return pq.peek();
}```

Fast selection: time complexity O(N), space complexity O(1)

```public int findKthLargest(int[] nums, int k) {
k = nums.length - k;
int l = 0, h = nums.length - 1;
while (l < h) {
int j = partition(nums, l, h);
if (j == k) {
break;
} else if (j < k) {
l = j + 1;
} else {
h = j - 1;
}
}
return nums[k];
}

private int partition(int[] a, int l, int h) {
int i = l, j = h + 1;
while (true) {
while (a[++i] < a[l] && i < h) ;
while (a[--j] > a[l] && j > l) ;
if (i >= j) {
break;
}
swap(a, i, j);
}
swap(a, l, j);
return j;
}

private void swap(int[] a, int i, int j) {
int t = a[i];
a[i] = a[j];
a[j] = t;
}```

# Bucket sorting

## 347: the most frequent k elements

Set up several buckets, each bucket stores the same number of occurrences. The subscript of the bucket indicates the frequency of the number occurrence, that is, the frequency of the number stored in the ith bucket is i. After putting all the numbers into the bucket, traverse the bucket from the back to the front, and the first k numbers obtained are the K numbers with the most frequency.

map is used to record the frequency of number occurrence; linked list array is used as bucket structure to record each number with the same frequency.
Some basic operations are not clear.

```public List<Integer> topKFrequent(int[] nums, int k) {
Map<Integer, Integer> frequencyForNum = new HashMap<>();
for (int num : nums) {
frequencyForNum.put(num, frequencyForNum.getOrDefault(num, 0) + 1);
}
List<Integer>[] buckets = new ArrayList[nums.length + 1];
for (int key : frequencyForNum.keySet()) {
int frequency = frequencyForNum.get(key);
if (buckets[frequency] == null) {
buckets[frequency] = new ArrayList<>();
}
}
List<Integer> topK = new ArrayList<>();
for (int i = buckets.length - 1; i >= 0 && topK.size() < k; i--) {
if (buckets[i] == null) {
continue;
}
if (buckets[i].size() <= (k - topK.size())) {
} else {
}
}
}```

## 451: sort strings by number of character occurrences

```public String frequencySort(String s) {
Map<Character, Integer> frequencyForNum = new HashMap<>();
for (char c : s.toCharArray())
frequencyForNum.put(c, frequencyForNum.getOrDefault(c, 0) + 1);

List<Character>[] frequencyBucket = new ArrayList[s.length() + 1];
for (char c : frequencyForNum.keySet()) {
int f = frequencyForNum.get(c);
if (frequencyBucket[f] == null) {
frequencyBucket[f] = new ArrayList<>();
}
}
StringBuilder str = new StringBuilder();
for (int i = frequencyBucket.length - 1; i >= 0; i--) {
if (frequencyBucket[i] == null) {
continue;
}
for (char c : frequencyBucket[i]) {
for (int j = 0; j < i; j++) {
str.append(c);
}
}
}
return str.toString();
}```

Learn the operation of the data structure used.

# The issue of Dutch flag

## 75: sort by color

Fast sorting of three-way segmentation

```public void sortColors(int[] nums) {
int zero = -1, one = 0, two = nums.length;
while (one < two) {
if (nums[one] == 0) {
swap(nums, ++zero, one++);
} else if (nums[one] == 2) {
swap(nums, --two, one);
} else {
++one;
}
}
}

private void swap(int[] nums, int i, int j) {
int t = nums[i];
nums[i] = nums[j];
nums[j] = t;
}```

Reference: https://github.com/CyC2018/CS-Notes/blob/master/notes/Leetcode%20%E9%A2%98%E8%A7%A3%20-%20%E6%8E%92%E5%BA%8F.md

Published 5 original articles, won praise 0, visited 46

Tags: github

Posted on Wed, 12 Feb 2020 01:03:00 -0500 by Jason28