选择排序
直接选择排序
时间复杂度O(n^2)
空间复杂度O(1)
稳定
final static class selectSort{
public selectSort(int[] arr){
Sort(arr, arr.length);
}
private void Sort(int[] arr, int n) {
for (int i = 0; i < n; i++) {
int min = i;
for (int j = i; j < n; j++) {
if(arr[min] > arr[j]){
min = j;
}
}
swap(arr, i, min);
}
}
}
堆排序
时间复杂度不太好算啊，看看这个：https://blog.csdn.net/YuZhiHui_No1/article/details/44258297
建堆时间复杂度O(n)
堆排序时间复杂度O(nlogn)
空间复杂度O(1)
final static class heapSort{
//堆排序用new PriorityQueue<Integer>((o1, o2)->(o1 - o2));
//https://www.runoob.com/w3cnote/heap-sort.html
//https://zhuanlan.zhihu.com/p/45725214
public heapSort(int[] arr){
if(arr.length < 2) return;
int len = arr.length;
BuildMaxHeap(arr, len);
for(int i=len-1; i>0; i--){
swap(arr, 0, i);
len--;
heapify(arr, 0, len);
}
}
public void BuildMaxHeap(int[] arr, int len){
for(int i=(int) Math.floor(len / 2); i>=0; i--){
heapify(arr, i, len);
}
}
public void heapify(int[] arr, int i, int len){
int left = i * 2 + 1;
int right = i * 2 + 2;
int larger = i;
if(left < len && arr[left] > arr[larger]){
larger = left;
}
if(right < len && arr[right] > arr[larger]){
larger = right;
}
if(larger != i){
swap(arr, i, larger);
//交换之后larger位置为较小的值，继续向下调整
heapify(arr, larger, len);
}
}
}
插入排序
直接插入排序
时间复杂度O(n^2)
空间复杂度O(1)
稳定
final static class insertSort{
public insertSort(int[] arr){
Sort(arr, arr.length);
}
private void Sort(int[] arr, int n) {
for (int i = 1; i < n; i++) {
int tmp = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > tmp) {
arr[j+1] = arr[j];
j--;
}
arr[j+1] = tmp;
}
}
}
希尔排序
插入排序的改良，增加了步长
时间复杂度O(nlogn)
空间复杂度O(1)
final static class shellSort{
shellSort(int[] arr){
Sort(arr, arr.length);
}
private void Sort(int[] arr, int n) {
int gap = n;
do{
gap = gap / 3 + 1;
for (int i = gap; i < n; i++) {
int tmp = arr[i];
int j = i - gap;
while (j >= 0 && arr[j] > tmp) {
arr[j + gap] = arr[j];
j -= gap;
}
arr[j + gap] = tmp;
}
}while (gap > 1);
}
}
交换排序
冒泡排序
时间复杂度O(n^2)
空间复杂度O(1)
稳定
final static class BubbleSort{
public BubbleSort(int[] arr){
Sort(arr, arr.length);
}
private void Sort(int[] arr, int n) {
for (int i = 0; i < n; i++) {
for (int j = 1; j < n - i; j++) {
if(arr[j-1] > arr[j]){
swap(arr, j-1, j);
}
}
}
}
}
快速排序
时间复杂度O(nlogn)
最坏时间复杂度O(n^2) 当划分产生的两个子问题分别包含 n-1 和 0 个元素时，最坏情况发生。
空间复杂度O(logn) 其中sort递归调用生成partitionIndex
final static class quickSort{
public quickSort(int[] arr){
Sort(arr, 0, arr.length-1);
}
public void Sort(int[] arr, int l, int r){
if(l < r){
int partitionIndex = partition(arr, l, r);
Sort(arr, l, partitionIndex-1);
Sort(arr, partitionIndex+1, r);
}
}
public int partition(int[] arr, int l, int r){
int pivot = l;
int index = pivot + 1;
for(int i=index; i<=r; i++){
if(arr[i] < arr[pivot]){
swap(arr, i, index++);
}
}
swap(arr, pivot, index-1);
return index-1;
}
}
归并排序
时间复杂度O(nlogn)
空间复杂度O(n)
这个稍微想一下就行了，不是特别难
final static class mergeSort{
public mergeSort(int[] arr) {
Sort(arr, 0, arr.length - 1);
}
public void Sort(int[] arr, int l, int r){
if(l < r){
int mid = (l + r)/2;
Sort(arr, l, mid);
Sort(arr, mid+1, r);
merge(arr, l, mid, r);
}
}
public void merge(int[] arr, int l, int mid, int r){
int[] help = new int[r-l+1];
int count = 0;
int p = l, q = mid + 1;
while(p <= mid && q <= r){
help[count++] = arr[p] < arr[q] ? arr[p++] : arr[q++];
}
while(p <= mid){
help[count++] = arr[p++];
}
while(q <= r){
help[count++] = arr[q++];
}
for(int i = 0; i < help.length; i++){
arr[l + i] = help[i];
}
}
}
桶排序
计数排序
计数排序有点坑啊
他先找到数组中最大和最小值，然后用这个二者的差值作为计数数组的长度
如果我数组中就三个元素[1, 2, 100]就不合适了
时间复杂度O(n + k)
空间复杂度O(n + k)
final static class countSort{
countSort(int[] arr){
Sort(arr, arr.length);
}
private void Sort(int[] arr, int n) {
int max = arr[0];
int min = arr[0];
for (int i = 0; i < n; i++) {
if (max < arr[i]) {
max = arr[i];
}
if (min > arr[i]) {
min = arr[i];
}
}
// 最大最小元素之间范围[min, max]的长度
int offset = max - min + 1;
// 1. 计算频率，在需要的数组长度上额外加1
int[] count = new int[offset + 1];
for (int i = 0; i < n; i++) {
// 使用加1后的索引，有重复的该位置就自增
count[arr[i] - min + 1]++;
}
// 2. 频率 -> 元素的开始索引
for (int i = 0; i < offset; i++) {
count[i + 1] += count[i];
}
// 3. 元素按照开始索引分类，用到一个和待排数组一样大临时数组存放数据
int[] aux = new int[n];
for (int i = 0; i < n; i++) {
// 填充一个数据后，自增，以便相同的数据可以填到下一个空位
aux[count[arr[i] - min]++] = arr[i];
}
// 4. 数据回写
for (int i = 0; i < n; i++) {
arr[i] = aux[i];
}
}
}
基数排序
我复制粘贴的，不太想看了
时间复杂度O(n * m)
空间复杂度O(m)
final static class RadixSort{
public RadixSort(int[] arr) {
// 对 arr 进行拷贝，不改变参数内容
int[] array = Arrays.copyOf(arr, arr.length);
int maxDigit = getMaxDigit(array);
Sort(arr, maxDigit);
}
/**
* 获取最高位数
*/
private int getMaxDigit(int[] arr) {
int maxValue = getMaxValue(arr);
return getNumLenght(maxValue);
}
private int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
protected int getNumLenght(long num) {
if (num == 0) {
return 1;
}
int lenght = 0;
for (long temp = num; temp != 0; temp /= 10) {
lenght++;
}
return lenght;
}
private int[] Sort(int[] arr, int maxDigit) {
int mod = 10;
int dev = 1;
for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
// 考虑负数的情况，这里扩展一倍队列数，其中 [0-9]对应负数，[10-19]对应正数 (bucket + 10)
int[][] counter = new int[mod * 2][0];
for (int j = 0; j < arr.length; j++) {
int bucket = ((arr[j] % mod) / dev) + mod;
counter[bucket] = arrayAppend(counter[bucket], arr[j]);
}
int pos = 0;
for (int[] bucket : counter) {
for (int value : bucket) {
arr[pos++] = value;
}
}
}
return arr;
}
/**
* 自动扩容，并保存数据
*
* @param arr
* @param value
*/
private int[] arrayAppend(int[] arr, int value) {
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = value;
return arr;
}
}
final static class mergeSort{
public mergeSort(int[] arr) {
Sort(arr, 0, arr.length - 1);
}
public void Sort(int[] arr, int l, int r){
if(l < r){
int mid = (l + r)/2;
Sort(arr, l, mid);
Sort(arr, mid+1, r);
merge(arr, l, mid, r);
}
}
public void merge(int[] arr, int l, int mid, int r){
int []help = new int[r-l+1];
int count = 0;
int p = l, q = mid + 1;
while(p<=mid && q<=r){
help[count++] = arr[p] < arr[q] ? arr[p++] : arr[q++];
}
while(p<=mid){
help[count++] = arr[p++];
}
while(q<=r){
help[count++] = arr[q++];
}
for(int i=0; i<help.length; i++){
arr[l+i] = help[i];
}
}
}