算法-排序

最新推荐文章于 2021-12-09 16:29:50 发布
最新推荐文章于 2021-12-09 16:29:50 发布
阅读量424 收藏
点赞数
分类专栏： 算法 文章标签： 算法 札记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hjq300/article/details/44567761
版权
排序算法

  • 内部与外部排序

    • 内部排序 -> 所有记录都加载到内存中
    • 外部排序 -> 把数据分块排序（数据量比较大）

    一般对大数据量排序时，可以把数据加载进b树

几种排序方法
  • 冒泡排序
   /*

相邻数字之间两两比较，第一轮把最大的数选出来放到最右边，第二轮把剩下的最大的数选出来放到最右边（除开第一轮的那个数）……最后把最左边的两个数比较完，较大的数放右边。

如果中途已经全部排好序，则停止排序。

*/
#include <iostream>
#include <cstdlib>

using namespace std;

int N = 17;

void PRINT(float data[])
{
   float t, *p;
   p = data;
   for (int i=0; i<N; i++) cout << p[i] << " ";
   cout << "\n";
}

void SORT(float data[])
{
   float t, *p;
   int n;
   bool stopFlag;

   p = data;

   // Bubble
   stopFlag = false; 
   n = N;
   while (n > 0){
      stopFlag = true;
      for (int i=0; i+1<n; i++){
         if (p[i]>p[i+1]) {t=p[i];p[i]=p[i+1];p[i+1]=t;stopFlag=false;} //swap
      }
      if (true == stopFlag) break;
      n--;
      PRINT(p);
   }

}

int main()
{
   float data[N];
   FILE *fp;
   fp = fopen("data","r");
   for(int i=0; i<N; i++){
      fscanf(fp, "%f", data+i);
   }
   PRINT(data);
   SORT(data);
   fclose(fp);
   return 0;
}
OUTPUT：
0.38 0.16 0.53 0.24 0.18 0.38 0.51 0.21 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.16 0.38 0.24 0.18 0.38 0.51 0.21 0.08 0.34 0.51 0.53 0.71 0.95 0.62 0.88 0.56 0.98 
0.16 0.24 0.18 0.38 0.38 0.21 0.08 0.34 0.51 0.51 0.53 0.71 0.62 0.88 0.56 0.95 0.98 
0.16 0.18 0.24 0.38 0.21 0.08 0.34 0.38 0.51 0.51 0.53 0.62 0.71 0.56 0.88 0.95 0.98 
0.16 0.18 0.24 0.21 0.08 0.34 0.38 0.38 0.51 0.51 0.53 0.62 0.56 0.71 0.88 0.95 0.98 
0.16 0.18 0.21 0.08 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.56 0.62 0.71 0.88 0.95 0.98 
0.16 0.18 0.08 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.56 0.62 0.71 0.88 0.95 0.98 
0.16 0.08 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.56 0.62 0.71 0.88 0.95 0.98 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.56 0.62 0.71 0.88 0.95 0.98

Bubble

  • 插入排序
  /*
  原理：从左往右依次对每个元素进行以下操作
  1.如果元素大于等于左边元素，则不操作，转到下一个。
  2.如果元素小于左边元素，将其从左开始依次与其左边的元素进行比较，如果找到一个位置，元素恰好大于左边元素，小于右边元素（这里的“等于”情况单独考虑进去），则将元素插入这里。
  3.继续从已经操作完的元素位置往后操作。
  插入排序由于在将数据插入两个数据之间时要移动后续全部的数据，采用链表来操作会提高效率。
*/
#include <iostream>
#include <cstdlib>

using namespace std;

int N = 17;
struct DATA{
   float data;
   DATA *link;
};
DATA *array = NULL;

void PRINT(DATA *ptr)
{
   float t;
   DATA *p;
   p = ptr;
   while(1){
      cout << (p->data) << " ";
      if (NULL == (p->link)) break;
      else p = p->link;
   }
   cout << "\n";
}

void SORT(DATA *ptr)
{
   float t;
   int n;
   DATA *p, *temp, *head, *cache;
   head = p = temp = ptr;

   // Insertion
   while (NULL != (p->link)){
      if ((p->data) > ((p->link)->data)){
         t = (p->link)->data;
         temp = head;
         //if ((t > (head->data)) && (t <= ((head->link)->data))){
         if (t <= (head->data)){
            cache = p->link;
            p->link = (p->link)->link;
            free(cache);
            cache = (DATA *)malloc(sizeof(DATA));
            cache -> data = t;
            cache -> link = head;
            head = cache;
         }
         else{
            while (t > ((temp->link)->data)) {temp = temp->link;}
            cache = p->link;
            p->link = (p->link)->link;
            free(cache);
            cache = (DATA *)malloc(sizeof(DATA));
            cache -> data = t;
            cache -> link = temp -> link;
            temp -> link = cache;
         }
      }
      else
         p = p->link;
      PRINT(head);
   }
}

int main()
{
   float data = 0.0;
   DATA *ptr, *head;
   FILE *fp;
   fp = fopen("data","r");
   for(int i=0; i<N; i++){
      fscanf(fp, "%f", &data);
      ptr = (DATA *)malloc(sizeof(DATA));
      ptr -> data = data;
      ptr -> link = NULL;
      if (NULL == array){
         head = ptr;
         array = ptr;
      }
      else{
         array -> link = ptr;
         array = ptr;
      }
   }
   PRINT(head);
   SORT(head);
   fclose(fp);
   return 0;
}

OUTPUT:
0.38 0.16 0.53 0.24 0.18 0.38 0.51 0.21 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.16 0.38 0.53 0.24 0.18 0.38 0.51 0.21 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.16 0.38 0.53 0.24 0.18 0.38 0.51 0.21 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.16 0.24 0.38 0.53 0.18 0.38 0.51 0.21 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.16 0.18 0.24 0.38 0.53 0.38 0.51 0.21 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.16 0.18 0.24 0.38 0.38 0.53 0.51 0.21 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.16 0.18 0.24 0.38 0.38 0.51 0.53 0.21 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.16 0.18 0.21 0.24 0.38 0.38 0.51 0.53 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.08 0.16 0.18 0.21 0.24 0.38 0.38 0.51 0.53 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.53 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.95 0.71 0.98 0.62 0.88 0.56 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.95 0.71 0.98 0.62 0.88 0.56 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.71 0.95 0.98 0.62 0.88 0.56 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.71 0.95 0.98 0.62 0.88 0.56 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.62 0.71 0.95 0.98 0.88 0.56 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.62 0.71 0.88 0.95 0.98 0.56 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.56 0.62 0.71 0.88 0.95 0.98

Insertion

用数组也可以顺利地进行插入排序，而且可以方便地从后往前比较，直到找到“谷地”：

#include <iostream>
#include <cstdlib>

using namespace std;

int N = 17;

void PRINT(float *data)
{
   float *p;
   p = data;
   for (int i=0; i<N; i++){
      cout << p[i] << " ";
   }
   cout << "\n";
}

void SORT(float *data)
{
   float t, *p;
   int n;
   p = data;
   // Insertion
   for (int i=1; i<N; i++){
      if (p[i] < p[i-1]){
         for (int j=i; j>0; j--){
            if (p[j-1] > p[j]){
               t = p[j];
               p[j] = p[j-1];
               p[j-1] = t;
            }
            else
               break;
         }
      }
      PRINT(p);
   }
}

int main()
{
   float data[N];
   FILE *fp;
   fp = fopen("data","r");
   for(int i=0; i<N; i++){
      fscanf(fp, "%f", data+i);
   }
   PRINT(data);
   SORT(data);
   fclose(fp);
   return 0;
}

由于希尔排序要把局部的数据排成正序，所以用数组来进行从后往前的插入排序更为有效。

  • 希尔排序
  /*
  将一组数据按间隔h提取出来进行排序称为"h排序"，构建一个收敛到1的h序列，依次进行h排序，最终可以得到一个有序数列。希尔排序就是依据于此。那么，提高排序效率的关键就成为：找到一个较好的h序列。一般地用以下法则就可以：
  1. h1=1
  2. h_{s+1} = 3*h_{s} + 1，最大的h<=N/9(N是整个数组长度)
  分好块之后，调用普通的插入排序就可以了，注意把插入排序的元素间隔调整为h(只要把原来的"1"改为"h"就可以了，没有想像的那么复杂～)
*/

#include <iostream>
#include <cstdlib>

using namespace std;

int N = 17;

void PRINT(float *data)
{
   float *p;
   p = data;
   for (int i=0; i<N; i++){
      cout << p[i] << " ";
   }
   cout << "\n";
}

void SORT(float *data)
{
   float t, *p;
   int n, h;
   p = data;
   for (h=1; h<=N/9; h=3*h+1);

   for (; h>0; h/=3){
      for (int start=0; start<h; start++){
         // Insertion
         for (int i=start+h; i<N; i+=h){
            if (p[i] < p[i-h]){
               for (int j=i; j>0; j-=h){
                  if (p[j-h] > p[j]){
                     t = p[j];
                     p[j] = p[j-h];
                     p[j-h] = t;
                  }
                  else
                     break;
               }
            }
            PRINT(p);
         }
      }
   }
}

int main()
{
   float data[N];
   FILE *fp;
   fp = fopen("data","r");
   for(int i=0; i<N; i++){
      fscanf(fp, "%f", data+i);
   }
   PRINT(data);
   SORT(data);
   fclose(fp);
   return 0;
}

OUTPUT:
0.38 0.16 0.53 0.24 0.18 0.38 0.51 0.21 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.18 0.16 0.53 0.24 0.38 0.38 0.51 0.21 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.08 0.16 0.53 0.24 0.18 0.38 0.51 0.21 0.38 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.08 0.16 0.53 0.24 0.18 0.38 0.51 0.21 0.38 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56 
0.08 0.16 0.53 0.24 0.18 0.38 0.51 0.21 0.38 0.34 0.51 0.95 0.56 0.98 0.62 0.88 0.71 
0.08 0.16 0.53 0.24 0.18 0.38 0.51 0.21 0.38 0.34 0.51 0.95 0.56 0.98 0.62 0.88 0.71 
0.08 0.16 0.53 0.24 0.18 0.34 0.51 0.21 0.38 0.38 0.51 0.95 0.56 0.98 0.62 0.88 0.71 
0.08 0.16 0.53 0.24 0.18 0.34 0.51 0.21 0.38 0.38 0.51 0.95 0.56 0.98 0.62 0.88 0.71 
0.08 0.16 0.51 0.24 0.18 0.34 0.53 0.21 0.38 0.38 0.51 0.95 0.56 0.98 0.62 0.88 0.71 
0.08 0.16 0.51 0.24 0.18 0.34 0.51 0.21 0.38 0.38 0.53 0.95 0.56 0.98 0.62 0.88 0.71 
0.08 0.16 0.51 0.24 0.18 0.34 0.51 0.21 0.38 0.38 0.53 0.95 0.56 0.98 0.62 0.88 0.71 
0.08 0.16 0.51 0.21 0.18 0.34 0.51 0.24 0.38 0.38 0.53 0.95 0.56 0.98 0.62 0.88 0.71 
0.08 0.16 0.51 0.21 0.18 0.34 0.51 0.24 0.38 0.38 0.53 0.95 0.56 0.98 0.62 0.88 0.71 
0.08 0.16 0.51 0.21 0.18 0.34 0.51 0.24 0.38 0.38 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.51 0.21 0.18 0.34 0.51 0.24 0.38 0.38 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.51 0.21 0.18 0.34 0.51 0.24 0.38 0.38 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.21 0.51 0.18 0.34 0.51 0.24 0.38 0.38 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.18 0.21 0.51 0.34 0.51 0.24 0.38 0.38 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.18 0.21 0.34 0.51 0.51 0.24 0.38 0.38 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.18 0.21 0.34 0.51 0.51 0.24 0.38 0.38 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.18 0.21 0.24 0.34 0.51 0.51 0.38 0.38 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.51 0.51 0.38 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.88 0.56 0.98 0.62 0.95 0.71 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.56 0.88 0.98 0.62 0.95 0.71 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.56 0.88 0.98 0.62 0.95 0.71 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.56 0.62 0.88 0.98 0.95 0.71 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.56 0.62 0.88 0.95 0.98 0.71 
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.56 0.62 0.71 0.88 0.95 0.98

shellSorting

  • 快速排序
#!/usr/bin/env python
'''
本快排的原理：
    把数列的第一个作为pivot，然后从两头往中间比较，如果data[i]>pivot>data[j]，就把data[i]与data[j]交换。最后i、j相遇时，把pivot和i处的值比较交换。
    这样一次处理之后，数列分成了 [A] - pivot - [B] 三部分，A中的元素都小于pivot，B中的元素都大于pivot，然后递归对A和B进行同样的操作。
    用python来写程序可以简化代码
'''
def qsort(DATA):
    data = DATA[:]
    n = len(data)
    if n == 0:
        return []
    elif n == 1:
        print data
        return data
    elif n == 2:
        if data[0] > data[1]:
            print [data[1], data[0]]
            return [data[1], data[0]]
        else:
            print data
            return data
    pivot = data[0]

    i = 1
    j = n - 1
    while (i < j): #完成该循环之后，i == j，而且data[i] > pivot，data[i-1] <= pivot
        while (data[i] <= pivot) and (i < j): i += 1
        while (data[j] > pivot) and (i < j):  j -= 1
        t = data[i]
        data[i] = data[j]
        data[j] = t

    if data[i] < pivot:
        pivot_i = i
    else:
        pivot_i = i - 1
    t = data[pivot_i]
    data[pivot_i] = data[0]
    data[0] = t
    print data[:pivot_i],[pivot],data[pivot_i+1:]
    return qsort(data[:pivot_i]) + [pivot] + qsort(data[pivot_i+1:])

data = []
count = 0
for item in open('data','r').readlines():
    if count == 17:
        break
    item = item.replace('\n','')
    item = eval(item)
    data.append(item)
    count += 1
print data
data = qsort(data)
print data
OUTPUT:
0.38 0.16 0.53 0.24 0.18 0.38 0.51 0.21 0.08 0.34 0.51 0.95 0.71 0.98 0.62 0.88 0.56
0.21 0.16 0.34 0.24 0.18 0.38 0.08 0.38 0.51 0.53 0.51 0.95 0.71 0.98 0.62 0.88 0.56
0.18 0.16 0.08 0.21 0.24 0.38 0.34      0.51 0.51 0.53 0.95 0.71 0.98 0.62 0.88 0.56
0.08 0.16 0.18      0.24 0.38 0.34      0.51      0.53 0.95 0.71 0.98 0.62 0.88 0.56
0.08 0.16                0.34 0.38                     0.88 0.71 0.56 0.62 0.95 0.98
                                                       0.62 0.71 0.56 0.88      0.98
                                                       0.56 0.62 0.71               
                                                       0.56      0.71               
0.08 0.16 0.18 0.21 0.24 0.34 0.38 0.38 0.51 0.51 0.53 0.56 0.62 0.71 0.88 0.95 0.98

Quicksorting

  • 希尔排序与快速排序在性能上的比较

    希尔排序的复杂度设为O(n^1.25)，快排的复杂度设为O(k*n*ln(n))

    下表是不同的k值对应的两种排序在速度上相当的n值。比如：k=2.0时，n=463584，表示n<463584时，希尔排序会比较快，n>463584时，快排比较快。

    由于快排k的典型值为2，从结果来看，当数据量小于50万时，用希尔排序比较好。即小数据量用希尔排序，大数据量用快排。

KT(Shell) ~ T(Quick)
1.05504
1.110963
1.219912
1.333762
1.454257
1.583500
1.6123983
1.7178623
1.8250787
1.9344322
2.0463584
2.1613468
  • 堆排序
# -*- coding: utf-8 -*-
#!/usr/bin/env python
'''
    堆排序是将数据构成一棵二叉树，再通过像比赛一样的方法从下而上地选出各级冠军（较大的数），接着，将最上面的父节点提出（它是最大的），换上数据的最后一个。然后就继续从最上面的父节点出发，利用类似贪心算法的方法将剩下的最大数选出来。循环这个贪心的过程，就可以从大到小把全部的数据都选出来。
'''
import math

def preHeap(DATA):
    data = DATA[:]
    N = len(DATA)
    n = math.log(N) / math.log(2)
    n = (int)(n // 1)
    for k in range(n-1,-1,-1):
        for parent in range(2**k-1, 2**(k+1)-1):
            data = heap(data, parent)
    return data

def heap(DATA, INDEX):
    data = DATA[:]
    N = len(data)
    n = INDEX
    parent = n
    child = 2*n + 1
    while child < N:
        if child + 1 < N:
            if data[child] < data[child+1]:
                child += 1
        if data[parent] >= data[child]:
            break
        else:
            t = data[parent]
            data[parent] = data[child]
            data[child] = t
            parent = child
            child = 2*parent + 1
    return data

if __name__ == '__main__':
    Data = []
    sortedData = []
    count = 0
    for item in open('data', 'r'):
        item = item.replace('\n','')
        Data.append(eval(item))
        count += 1
        if count == 17: break
    print Data

    # 自下而上地“比赛”，把胜者往父节点推选出来
    Data = preHeap(Data)

    n = len(Data)
    while 1:
        if n == 1:
            break
        DataCache = heap(Data[:n], 0)
        t = DataCache[n-1]
        DataCache[n-1] = DataCache[0]
        DataCache[0] = t
        Data = DataCache[:n] + Data[n:]
        print Data
        n -= 1

OUTPUT:
[190, 697, 531, 897, 60, 47, 599, 172, 149, 243, 73, 552, 100, 588, 476, 653, 683]
[172, 697, 599, 683, 243, 552, 588, 653, 149, 60, 73, 47, 100, 531, 476, 190, 897]
[172, 683, 599, 653, 243, 552, 588, 190, 149, 60, 73, 47, 100, 531, 476, 697, 897]
[476, 653, 599, 190, 243, 552, 588, 172, 149, 60, 73, 47, 100, 531, 683, 697, 897]
[531, 476, 599, 190, 243, 552, 588, 172, 149, 60, 73, 47, 100, 653, 683, 697, 897]
[100, 476, 588, 190, 243, 552, 531, 172, 149, 60, 73, 47, 599, 653, 683, 697, 897]
[47, 476, 552, 190, 243, 100, 531, 172, 149, 60, 73, 588, 599, 653, 683, 697, 897]
[73, 476, 531, 190, 243, 100, 47, 172, 149, 60, 552, 588, 599, 653, 683, 697, 897]
[60, 476, 100, 190, 243, 73, 47, 172, 149, 531, 552, 588, 599, 653, 683, 697, 897]
[149, 243, 100, 190, 60, 73, 47, 172, 476, 531, 552, 588, 599, 653, 683, 697, 897]
[149, 190, 100, 172, 60, 73, 47, 243, 476, 531, 552, 588, 599, 653, 683, 697, 897]
[47, 172, 100, 149, 60, 73, 190, 243, 476, 531, 552, 588, 599, 653, 683, 697, 897]
[73, 149, 100, 47, 60, 172, 190, 243, 476, 531, 552, 588, 599, 653, 683, 697, 897]
[60, 73, 100, 47, 149, 172, 190, 243, 476, 531, 552, 588, 599, 653, 683, 697, 897]
[47, 73, 60, 100, 149, 172, 190, 243, 476, 531, 552, 588, 599, 653, 683, 697, 897]
[60, 47, 73, 100, 149, 172, 190, 243, 476, 531, 552, 588, 599, 653, 683, 697, 897]
[47, 60, 73, 100, 149, 172, 190, 243, 476, 531, 552, 588, 599, 653, 683, 697, 897]

原理图：
heapsort

Andrew Binstock, John Rex. 程序员实用算法. 2009.

hjq300
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分块排序实现
桂花載酒
12-10 1959
数据结构
算法-排序-代码.zip
03-01
算法-排序-代码 算法-排序-代码 算法-排序-代码 算法-排序-代码 算法-排序-代码 在我们生活的这个世界中到处都是被排序过的东东。站队的时候会按照身高排序，考试 的名次需要按照分数排序，网上购物的时候会...
算法篇-十大经典排序算法之基数排序
xlecho的博客
11-25 733
echo编辑整理，欢迎转载，转载请声明文章来源。欢迎添加echo微信(微信号：t2421499075) 交流学习。 什么是基数排序 基数排序和计数排序谐音，这里不要搞错了。但是这两种算法都有只能对整数排序的缺点。 基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。 动图演示 声明图片来源：五分钟学算法 Java代码实现 public class Test {
分块算法
yu121380的博客
04-12 427
转载：https://blog.csdn.net/a_forever_dream/article/details/80054800 首先，它会将一个序列分成√n 块，除了最后一块，其他每一块都严格的只有 √n 个元素，然后用一个belong数组记录每一个元素属于哪一块，再用l[i]，r[i]记录每一块的左边界和右边界，然后就是......好像没了额...... 没错，就是这么简单，接下来...
区间求和 （莫队算法 、分块排序）
郭源潮
10-11 1538
链接：https://ac.nowcoder.com/acm/contest/1085/G 来源：牛客网 区间求和 时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32768K，其他语言65536K 64bit IO Format: %lld 题目描述 小sun最近突然对区间来了兴趣，现在他有这样一个问题想问问你： 给你n个数，每个数为aia_iai​，现在有m个询问...
【算法学习】分块算法 莫队
memcpy0的博客
08-24 346
文章目录1. 莫队概述2. 挪动区间3. 某种顺序和离线处理4. 莫队算法框架5. 应用题 今天要学习的算法是莫队算法基础版本。 1. 莫队概述 莫队是一种解决区间问题的离线算法。它的思想很简单，本质上就是通过挪动区间的方式按照某种顺序，离线处理区间查询操作。 它的时间复杂度是 O(nn)\text{O(n}\sqrt{n})O(nn​) ，是一种效率不错的算法，可以解决几乎所有的区间查询问题（需要离线），只要对时间复杂度的要求不是那么苛刻。 2. 挪动区间 假设有这样的一道题：对于一个数列，每次给出一个
算法-基础算法- 排序算法（包含源程序）.rar
09-16
在这个压缩包“算法-基础算法- 排序算法（包含源程序）.rar”中，你将找到关于排序算法的详细讲解以及可能包含的源代码实现。这篇文章将深入探讨排序算法的基本概念、类型以及它们在实际应用中的价值。 排序算法的...
c语言链表的排序算法-排序链表最快的算法是什么？.pdf
04-07
链表排序算法的性能分析和优化 在计算机科学中，链表是一种常用的数据结构，用于存储和管理大量数据。然而，在链表中进行排序操作是一个具有挑战性的任务，因为链表的节点分布在内存中，可能会导致缓存未命中的情况...
数据结构--九种排序算法 --排序001.cpp
11-22
此文件为数据结构中的九种排序算法，包含一些排序方法的过程，其九种排序包括：直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，选择排序，堆排序，归并排序，基数排序！
详解Java常用排序算法-插入排序
08-26
Java排序算法 - 插入排序 插入排序（Insertion Sort）是一种简单的排序算法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增 1 的有序表。该算法的实现非常简单，但其时间复杂度...
详解Java常用排序算法-快速排序
08-26
快速排序（Quick Sort）是一种分治思想的排序算法，它的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，然后再分别对这两部分记录继续进行排序，以达到...
23%-数据结构与算法-排序算法-《二分法与统计问题》.doc
09-30
计算机文档
常见排序算法-C语言
01-10
C语言实现常见排序算法。编译环境：VS2010。 包括： 冒泡排序 快速排序 直接插入排序 Shell排序 直接选择排序 堆排序 归并排序（递归和非递归两种） 桶式排序 基数排序：顺序和静态队列两种方法 索引排序（采用简单...
Java后端算法-冒泡排序和选择排序对比
03-17
在Java后端开发中，掌握各种排序算法是提高程序效率的关键。本文将深入探讨两种基础且常见的排序算法：冒泡排序和选择排序。这两种算法都是简单直观的排序方法，但它们在性能和适用场景上有所不同。 **冒泡排序**：...
java实现的排序算法-8个
07-11
在编程领域，排序算法是计算机科学中的核心概念，特别是在数据处理和分析中起着至关重要的作用。Java作为一种广泛使用的编程语言，提供了丰富的工具和方法来实现各种排序算法。以下是基于给定的Java文件名（8种不同...
Linux 文本块排序
沁舞
01-13 867
解题思路来自与作者：Arnold Robbins & Neson H.F.Beebe 有时，我们需要多行记录进行排序，地址清单就是很好的例子。由于sort没有提供这个一方法，所以需要变通一下。 举例说明： 假如有这样的一个地址清单# SORTKEY:Schlo,Hans Jurgen Hans Jurgen Schol Unter den Linden 78 D-10117 Berlin G
C语言希尔排序（分块排序）
127.0.0.1的博客
12-09 677
C语言希尔排序（分块排序）法
shell中文本块的排序
envy111的专栏
09-02 542
写文章前，说一下自己最近的感悟吧。最近学习到一个概念叫做"持续输出"，第一次看到"持续输出"是在微博上一个人讲如何高效阅读，每读完一定量的文字比如一小节或者一章内容需要写读书笔记，将学习到的东西转化为自己的沉淀和思考，如果只是流水一般看过去，可能很快就会忘记。包括最近我在公司的老司机也会跟我讲需要将学习到的东西持续的输出，写文章，如果你还不能把一个东西讲明白说明你还没有学懂，当你能够真正的输出一些...
Python(5) -- 块排方法进行排序
Edifier12的博客
12-23 362
  快排方法的原理： 1.选取一个数字作为基准，本题中选取首位数字作为基准数（任意位置选取基准数） 2.将数列第一位开始，依次与此数字比较，如果小于此数，将小数交换到左边，最后达到小于基准数的在左边，大于基准数的在右边，分为两个数组 3.需要注意的一点就是要在遍历之前定义好终止条件，否则会一直进行循环，进入递归报错。   # 方法1：基本函数方法 def sort1(ls):  # 取...
数据结构与算法 - 排序
最新发布
09-14
排序算法的目标通常是将元素按照升序或降序排列。 常见的排序算法有很多种，每种算法都有不同的时间复杂度和空间复杂度。以下是几种常见的排序算法： 1. 冒泡排序（Bubble Sort）：比较相邻的两个元素，如果顺序不...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值