工作多年之后回顾经典排序算法

最新推荐文章于 2024-02-23 08:01:22 发布
最新推荐文章于 2024-02-23 08:01:22 发布
阅读量53 收藏
点赞数
文章标签： 游戏开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guku001/article/details/127681042
版权

原文链接

排序都要做的事情是比较和交换

稳定排序：排序前后，两个相等的元素在其序列中的前后位置顺序相同

这里只有插入排序和归并排序是稳定排序

以下示例均假设我们要从小到大进行排序

选择排序

非稳定排序

排序效率和输入无关

选择排序的基本步骤：先找出最小元素放到0号位置，再找出次小元素放到1号位置，再找出次次小元素放到2号位置，以此类推

排序过程中的数据变化

排序过程图形化

代码实现

#ifndef __SELECTIONSORT_H__
#define __SELECTIONSORT_H__

class Selection
{
public:
    //选择排序
  void Sort(char *a, int length)
  {
    for (int index = 0; index < length - 1; ++index)
    {
      //找出从当前位置index开始到后面所有元素中最小元素的下标
      int indexOfCurMin = index;
      for (int i = index + 1; i < length; ++i)
      {
        if (a[i] < a[indexOfCurMin])
        indexOfCurMin = i;
      }

      //将找到的最小元素和index位置上的元素进行交换
      int temp = a[index];
      a[index] = a[indexOfCurMin];
      a[indexOfCurMin] = temp;
    }
  }
};

#endif

特性

该算法的优点是对输入数据的移动次数最少。缺点是运行效率低，无法处理大规模的数据

性能分析

使用该算法对n个元素进行排序时

时间复杂度为O(n^2)，需要对元素进行n(n-1)/2次比较以及n-1次交换。值得注意的是，元素交换次数与元素个数成线性关系，这是其它排序算法都没有的

空间复杂度为0

插入排序

稳定排序

排序效率和输入有关，当待排序的元素越有序（倒置很少）时，该算法可能比其它任何算法都要快

插入排序的基本步骤：每一次都将一个未排序的元素插入到已经排好序的数组中

排序过程中的数据变化

排序过程图形化

代码实现

#ifndef __INSERTIONSOER_H__
#define __INSERTIONSOER_H__

//插入排序
class Insertion
{
public:
  void Sort1_0(char *a, int length)
  {
    for (int index = 1; index < length; ++index)
    {
      for (int i = index; i > 0; --i)
      {
        if (a[i] < a[i - 1])
        {
          char temp = a[i];
          a[i] = a[i - 1];
          a[i - 1] = temp;
        }
        //else
        //  break;
      }
    }
  }

  //优化版本
  void Sort2_0(char *a, int length)
  {
    for (int index = 1; index < length; ++index)
    {
      char needToInsert = a[index];

      int i;
      for (i = index - 1; i >= 0 && needToInsert < a[i]; --i)
        a[i + 1] = a[i];  //右移

      a[i + 1] = needToInsert;
    }
  }
};

#endif

特性

这里需要补充两个概念

倒置：两个待排序元素的排列顺序与目标顺序相反

部分有序：如果元素倒置的数量小于元素个数的某个倍数时，那么就说这些待排序元素是部分有序的

该算法缺点是运行效率低，无法处理大规模的数据

插入排序和冒泡排序很像，冒泡排序的算法如下：从未排序元素的第一对直到最后一对，如果第一个元素比第二个元素大就交换，重复这个步骤直到所有元素都排序完成

性能分析

使用该算法对n个元素进行排序时

时间复杂度在最坏的情况下为O(n^2)，最好的情况为O(n)，所以平均为O(n^2)。元素间的比较次数大于等于倒置数，小于等于倒置数+数组大小-1，在最坏的情况下为n(n-1)/2次，最好的情况下为n-1次。元素间进行交换的次数等于倒置数，在最坏的情况下为n(n-1)/2次，最好的情况下为0次

空间复杂度为0

希尔排序

非稳定排序

排序效率是否输入有关取决于第二步使用的排序算法是否输入有关

希尔排序的基本步骤：

  1. 确定h的初值
  2. 每次循环都使数组中任意间隔为h的元素都是有序的（这样的数组称为h有序数组）
  3. 每次循环结束，h都要递减一次，直到h等于1

ps：h的递减方式是多种多样的，不同的递减方式决定了希尔排序算法的效率，目前还没有研究出最好的递减序列

递减序列的一个例子

排序过程图形化

代码实现

//基于插入排序的希尔排序算法
#ifndef __SHELLSORT_H__
#define __SHELLSORT_H__

//希尔排序
class Shell
{
public:
  //1.0版本
  void Sort1_0(char *a, int length)
  {
    //确定h的最大值
    int h = 1;
    while (h < length / 3)
      h = 3 * h + 1;    //1,4,13,40,121,364,1093，...

    while (h >= 1)  //间隔控制
    {
      for (int i = 0; i < h; ++i)  //每个子数组的头
      {
        //对每个子数组进行插入排序
        for (int j = i + h; j < length; j += h)
        {
          char needToInsert = a[j];
          int k;
          for (k = j - h; j >= i&&needToInsert < a[k]; k -= h)
            a[k + h] = a[k];

          a[k + h] = needToInsert;
        }
      }

      h /= 3;
    }
  }

  //2.0版本
  void Sort2_0(char *a, int length)
  {
    //确定h的最大值
    int h = 1;
    while (h < length / 3)
      h = 3 * h + 1;    //1,4,13,40,121,364,1093，...

    while (h >= 1)
    {
      for (int i = h; i < length; ++i)    //从所有子数组的第二元素开始到最后的元素，妙
      {
        //在i元素所属的子数组内对i元素进行插入排序
        char needToInsert = a[i];
        int j;
        for (j = i - h; j >= 0 && needToInsert < a[j]; j -= h)
          a[j + h] = a[j];

        a[j + h] = needToInsert;
      }

      h /= 3;
    }
  }
};

#endif

特性

该算法的优点是可以处理大规模的数据，适用于大部分场合，其它更复杂优秀的排序算法最多比该算法快2倍。缺点是无法处理超大规模的数据

性能分析

使用该算法对n个元素进行排序时

时间复杂度目前在数学上是未知的

空间复杂度为0

归并排序

稳定排序

排序效率与输入无关

归并效果

归并过程中的数据变化

自顶向下的排序过程中的数据变化

自顶向下的排序过程图形化

自底向上的排序过程中的数据变化

自底向上的排序过程图形化

代码实现

#ifndef __MERGESORT_H__
#define __MERGESORT_H__

#include <iostream>  /* NULL */
#include <algorithm>  /* min */

using namespace std;

class Merge
{
private:
  //原数组的副本,辅助空间
  char *aux;
public:
  Merge(){ aux = NULL; }

  //单次归并，将a数组的两部分已排好的子数组合并起来
  //mid代表左边子数组的最后一个元素下标
  void merge(char *a, int left, int mid, int right)
  {
    for (int i = left; i <= right; ++i)
      aux[i] = a[i];

    int idxOfLeft = left;
    int idxOfRight = mid + 1;
    //开始归并
    for (int i = left; i <= right; ++i)
    {
      if (idxOfLeft > mid&&idxOfRight <= right)
        a[i] = aux[idxOfRight++];
      else if (idxOfLeft <= mid&&idxOfRight > right)
        a[i] = aux[idxOfLeft++];
      else if (aux[idxOfLeft] < aux[idxOfRight])
        a[i] = aux[idxOfLeft++];
      else
        a[i] = aux[idxOfRight++];
    }
  }

  //自顶向下的递归归并排序
  //这个函数还可以优化，如果left和right之间的插值小到一定的程度，就不用再递归了；直接用插入排序、希尔排序或者选择排序，速度可以提升；其中插入排序可以缩短10%~15%
  void SortCore(char *a, int left, int right)
  {
    if (left >= right)        //可以改成==
      return;
    else
    {
      int mid = (left + right) / 2;
      SortCore(a, left, mid);
      SortCore(a, mid + 1, right);
      merge(a, left, mid, right);    //这条语句在执行前还可以做一个判断：如果a[mid]<=a[mid+1]，这条语句可以不执行；
    }
  }

  //启动函数
  void Sort(char *a, int length)
  {
    //防止内存泄漏
    if (aux != NULL)
    {
      delete[] aux;
      aux = NULL;
    }

    aux = new char[length];
    SortCore(a, 0, length - 1);
  }

};

class MergeBu
{
private:
  //a数组的副本,辅助空间
  char *aux;

public:
  MergeBu(){ aux = NULL; }

  //单次归并，将a数组的两部分已排好的子数组合并起来
  //mid代表左边子数组的最后一个元素下标
  void merge(char *a, int left, int mid, int right)
  {
    for (int i = left; i <= right; ++i)
      aux[i] = a[i];

    int idxOfLeft = left;
    int idxOfRight = mid + 1;
    //开始归并
    for (int i = left; i <= right; ++i)
    {
      if (idxOfLeft > mid&&idxOfRight <= right)
        a[i] = aux[idxOfRight++];
      else if (idxOfLeft <= mid&&idxOfRight > right)
        a[i] = aux[idxOfLeft++];
      else if (aux[idxOfLeft] < aux[idxOfRight])
        a[i] = aux[idxOfLeft++];
      else
        a[i] = aux[idxOfRight++];
    }
  }

  //自底向上的归并排序
  //可以给链表进行排序，而不用辅助数组
  void Sort(char *a, int length)
  {
    //保险
    if (aux)
    {
      delete[] aux;
      aux = NULL;
    }

    aux = new char[length];

    for (int subArraySize = 1; subArraySize < length; subArraySize <<= 1)
    {
      for (int left = 0; left + subArraySize < length; left += (subArraySize << 1))    //注意这里的终止条件
        merge(a, left, left + subArraySize - 1, min(left + (subArraySize << 1) - 1, length - 1));
    }
  }
};

#endif

特性

该算法的优点是能够处理超大规模的数据，缺点是需要O(n)大小的辅助空间

性能分析

使用该算法对n个元素进行排序时

时间复杂度为O(nlgn)，元素间的比较次数在最坏的情况下为nlgn次，在最好的情况下为(nlgn/2)次，平均为(nlgn)(3/4)次。

空间复杂度为O(n)+递归辅助栈大小

快速排序

非稳定排序

在介绍算法之前需要先了解一个操作--切分

切分的目标是通过调整数组将首元素(或尾元素)放到正确的位置。该位置左边的元素都小于该位置的元素，右边的元素都大于该位置的元素。切分的一个经典应用是查找数组中第k大的元素。需要注意的是，切分要在一个数组上进行各种交换操作，如果不想改变原数组的话，则需要多创建一个数组来进行辅助

快速排序函数的基本步骤：对数组进行切分，再对经过切分得到的两个子数组分别调用快速排序函数

切分效果

切分过程中的数据变化

排序过程中的数据变化

排序过程图形化（每次都用当前数组中的最后一个元素进行切分）

代码实现

#ifndef __QUICKSORT_H__
#define __QUICKSORT_H__

class Quick
{
public:
  void Sort(char *a, int length)
  {
    //在开始递归排序前最好先打乱一下数组，防止不合理的切分；这样就不容易出现O(N^2)这种情况
    SortCore(a, 0, length - 1);
  }

  //可以优化：在数组被分割得小于某个数值的时候，改用插入排序
  void SortCore(char *a, int left, int right)
  {
    if (left >= right)
    {
      return;
    }
    else
    {
      int j = Partition(a, left, right);
      SortCore(a, left, j - 1);
      SortCore(a, j + 1, right);
    }
  }

  //可以优化：选取部分元素来找出这部分元素的中位数当作基准
  //可以优化（代码看quick3way）  
  int Partition(char *a, int left, int right)
  {
    //分割标准，取了首元素来当标准
    char standard = a[left];

    int i = left+1;
    int j = right;
    while(true)
    {
      //特别注意 ++i 和 --j 的位置
      //注意a[i] <= standard和standard <= a[j]的等于号
      while (i <= right && a[i] <= standard){ ++i; }      //i <= right可以改成i < right
      while (j >= left + 1 && standard <= a[j]){ --j; }    //j >= left+1不可以更改j > left+1

      if (i < j)
      {
        char temp = a[i];
        a[i] = a[j];
        a[j] = temp;
      }
      else
        break;

    }

    a[left] = a[j];
    a[j] = standard;

    return j;
  }
};

//三向切分的快速排序：在一个数组中，不会多次选择主键值同样的元素作为基准；可以改成三向切分，就是比基准值小的元素放在左边，与基准值相等的元素放在中间，比基准值大的元素放在右边；对于包含大量重复元素的数组，可以将时间复杂度有NlgN降到N
class Quick3way
{
public:
  void Sort(char *a, int length)
  {
    //在开始递归排序前最好先打乱一下数组，防止不合理的切分；这样就不容易出现O(N^2)这种情况
    SortCore(a, 0, length - 1);
  }

  void SortCore(char *a, int left, int right)
  {
    if (left >= right)
    {
      return;
    }
    else
    {
      //三向切分
#if 0
      //第一次切分
      char standard = a[left];
      int i = left+1;
      int j = right;
      while(true)
      {
        while (a[i] < standard && i <= right){ ++i; }
        while (standard <= a[j] && j >= left+1){ --j; }

        if (i < j)
        {
          char temp = a[i];
          a[i] = a[j];
          a[j] = temp;
        }
        else
          break;
      }
      a[left] = a[j];
      a[j] = standard;

      int lessRight = j - 1;

      //第二次切分
      j = right;
      while(true)
      {
        while (a[i] == standard && i <= right){ ++i; }
        while (standard < a[j] && j >= lessRight + 2){ --j; }

        if (i < j)
        {
          char temp = a[i];
          a[i] = a[j];
          a[j] = temp;
        }
        else
          break;
      }

      int equelRight = j;

      SortCore(a, left, lessRight);
      SortCore(a, equelRight + 1, right);
#endif
#if 1  
      //如果无法理解这段代码，请使用样例：6、2、3、7、6、6、9、1，来模拟一下
      char standard = a[left];
      //[left,lt-1]中的元素都小于基准值
      //[lt,i-1]中的元素都等于基准值
      //[gt+1,right]中的元素都大于基准值
      int lt = left;
      int i = left + 1;
      int gt = right;
      while (i <= gt)
      {
        if (a[i] < standard)
        {
          char temp = a[i];
          a[i] = a[lt];
          a[lt] = temp;

          ++i;
          ++lt;
        }
        else if (a[i] == standard)
        {
          ++i;
        }
        else if (a[i] > standard)
        {
          char temp = a[i];
          a[i] = a[gt];
          a[gt] = temp;

          --gt;
        }
      }

      SortCore(a, left, lt - 1);
      SortCore(a, i, right); 
#endif
    }
  }
};

#endif

特性

该算法的优点是可优化的空间大，经过精心调优的快速排序在大多数情况下都会比其他基于比较的排序算法更快，缺点是如果每次切分选择的元素都不正确，算法运行效率就会大幅度降低。例如第一次选了最小元素，第二次选择了次小元素作基准...，这种情况下时间复杂度就会变成O(n^2)，但是这种情况出现的概率比你电脑被雷劈中的概率还要小

性能分析

使用该算法对n个元素进行排序时

时间复杂度为O(nlgn)，虽然和归并排序一样，但是比归并要快

空间复杂度为递归辅助栈的大小

优先队列

在讲解堆排序之前需要先介绍一个数据结构--优先队列。该数据结构每一次取元素都只能获取最大（或最小）的元素

实现优先队列的方式有很多种

可以通过数组来实现无序或有序的优先队列

还可以通过二叉堆来实现。二叉堆是一棵父节点总是大于（或小于）等于两个子节点的二叉树，这样一棵二叉树又可以说是堆有序的。二叉堆可以使用数组形式的完全二叉树来存储

树包括堆，堆包括二叉堆。因为一般使用的堆都是二叉堆，所以通常将二叉堆称为堆

为堆添加或移除元素都会先破坏堆的有序状态，然后再遍历堆来恢复有序状态（这个过程称为堆的有序化）

基于二叉堆实现的优先队列

以下二叉堆都是最大堆

上浮过程（插入操作的基础）

下沉过程（删除操作的基础）

插入元素（左）、删除元素（右）的过程

代码实现

//优先队列的一种实现方式：二叉堆
//二叉堆：用这个数据结构可以很容易进行排序，但是直接用这个数据结构来排序效率并不高，因为我们只用很小一部分代码就够了
class MaxPQ
{
private:
  char *pq;    //节点为k，父节点为(k-1)/2，左孩子为2*k+1，右孩子为2*k+2
  int count;   //记录堆中元素的个数
public:
  MaxPQ(int maxN)
  {
    pq = new char[maxN];
    count = 0;
  }
  ~MaxPQ()
  {
    delete[] pq;
  }
  bool isEmpty()
  {
    return count == 0;
  }
  int size()
  {
    return count;
  }
  void insert(char v)
  {
    pq[count] = v;
    swim(count);

    ++count;
  }
  char delMax()
  {
    char max = pq[0];

    char temp = pq[0];
    pq[0] = pq[count - 1];
    pq[count - 1] = temp;

    --count;

    sink(0);

    return max;
  }
  //核心
  void swim(int k)
  {
    while (k > 0 && pq[k] > pq[(k - 1) / 2])
    {
      char temp = pq[k];
      pq[k] = pq[(k - 1) / 2];
      pq[(k - 1) / 2] = temp;

      k = (k - 1) / 2;
    }
  }
  //核心
  void sink(int k)
  {
    while (2 * k + 1 < count)
    {
      int maxChild = 2 * k + 1;
      if (maxChild + 1 < count && pq[maxChild + 1] > pq[maxChild])
        ++maxChild;

      if (pq[k] >= pq[maxChild])
        break;
      else
      {
        char temp = pq[k];
        pq[k] = pq[maxChild];
        pq[maxChild] = temp;

        k = maxChild;
      }

    }
  }
};

性能分析

数据结构插入第一个元素删除最大元素
基于有序数组的优先队列N1
基于无序数组的优先队列1N
基于二叉堆的优先队列lgNlgN
某种理想的优先队列11

从N个元素中找到最大的M个元素所需的成本：

某种理想的优先队列时间复杂度空间复杂度（用于存储N个输入）
其他最快的排序算法NlgNN
数组实现的优先队列NMM
二叉堆实现的优先队列NlgMM

堆排序

非稳定排序

堆排序的基本步骤：

  1. 将一个数组建成堆，建堆的方法有两种：
    1. 层序遍历二叉树（从左到右遍历数组），每个节点都进行上浮操作
    2. 从非叶子节点开始反向层序遍历二叉树（从右到左遍历数组），每个节点都进行下沉操作。这种方式的效率更高，只需要少于2N次比较以及少于N次交换
  2. 不断删除堆顶元素

排序过程中的数据变化

排序过程中的数据变化

排序过程图形化

代码实现

#ifndef __HEAPSORT_H__
#define __HEAPSORT_H__

class Heap
{
public:
  //注意：count是待排序数组的长度
  void sink(char *a, int k, int count)
  {
    while (2 * k + 1 < count)
    {
      int maxChild = 2 * k + 1;
      if (maxChild + 1 < count && a[maxChild + 1] > a[maxChild])
        ++maxChild;

      if (a[k] >= a[maxChild])
        break;
      else
      {
        char temp = a[k];
        a[k] = a[maxChild];
        a[maxChild] = temp;

        k = maxChild;
      }
    }
  }
  //可以优化：先下沉后上浮，可将比较次数减少一半；这个方法需要额外的空间来辅助，只有当比较需要很高的代价时才采用
  void sort(char *a,int count)
  {
    for (int i = (count - 1) / 2; i >= 0; --i)
      sink(a, i, count);

    for (int i = count - 1; i > 0; --i)
    {
      char temp = a[i];
      a[i] = a[0];
      a[0] = temp;

      sink(a, 0, i);
    }
  }
};

#endif

由于还要搬砖，没有办法一一回复私信把学习资料发给大家。我直接整理出来放在下面，觉得有帮助的话可以下载下来用于学习 在这里插入图片描述

链接：https://pan.baidu.com/s/1C-9TE9ES9xrySqW7PfpjyQ 提取码：cqmd

小弟才浅，如果本篇文章有任何错误和建议，欢迎大家留言 感谢各位人才的点赞、收藏、关注

三年游戏人
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
广工 算法设计与分析试卷 有好几年的 难易都有
05-14
这份压缩包包含了广州工业大学（广工）多年的算法设计与分析考试试卷，对于备考的学生来说是一份极有价值的参考资料。 一、算法设计 算法设计是解决特定问题的步骤描述，它需要明确、有效并且可以在有限时间内执行...
CTSC 1998 题面 + 数据 + 标程
09-25
在解题过程中，选手会遇到诸如动态规划、图论、贪心策略、排序与搜索等经典算法问题。这些问题的设计往往巧妙且富有启发性，能锻炼选手的逻辑思维、问题抽象以及优化解决方案的能力。同时，标准程序的存在为选手提供...
排序算法之快速排序详解
横扫天下的博客
05-04 365
排序算法之快速排序简介原理枢纽元的选取分割策略代码实现性能分析 简介 今天介绍排序算法中最重要的快速排序，顾名思义，快速排序之所以能在历史的长河中脱颖而出以“快速”两字命名，就是因为经多年实践证明它是已知最快的泛型排序算法。并且到目前为止还没有哪个算法能撼动其位置。所以它的重要性是不言而喻的，是我们一定要熟悉并掌握的排序算法。 原理 前不久我们刚讲过归并排序（归并排序），快速排序同归并排序一样，也...
算法回顾之 冒泡排序
03-26 99
最简单的算法，今天再写一下 笔者学习算法走了误区，一开始的游戏急于求成，并没有真正理解算法，就网上抄一个，以为自己会了，工作这么多年，发现走了弯路了，算法的学习不能死记硬背，必须根据算法原理，自己脑子思考得出代码，这样才是真正理解了算法，也活学活用 void BubbleSort(int *a,int n){ int t = 0; for(int i=0;i<...
AI技术内参035-机器学习排序算法：配对法排序学习
sucaiwa的博客
04-22 228
周一的文章里我分享了最基本的单点法排序学习（Pointwise Learning to Rank）。这个思路简单实用，是把经典的信息检索问题转化为机器学习问题的第一个关键步骤。简单回顾一下，我们介绍了在测试集里使用NDCG（Normalized Discounted Cumulative Gain），在某个K的位置评价“精度”（Precision）和“召回”（Recall），以这些形式来评估排序算法。你可以看到，单点法排序学习算法的模式和我们最终需要的结果中间还存在明显差距。
这么多年排序白学了，原来每次排序都在使用世界上最快的排序算法 TimSort
dotNET跨平台
02-23 115
在计算机科学的领域，排序算法是每位学生必学的基础，而排序的需求是每位程序员在编程过程中都会遇到的。在你轻松调用 .sort() 方法对数据进行排序时，是否曾好奇过，这个简单的方法背后使用的是哪种排序算法呢？本文将带你走进 TimSort，一个在标准函数库中广泛使用的排序算法。这个算法由工程师 Tim Peters 于 2001 年专为 Python 设计，并自 Python 2.3 版本起成为其默...
排序算法的创造者出生 | 历史上的今天
CSDN资讯
03-01 930
整理 | 王启隆透过「历史上的今天」，从过去看未来，从现在亦可以改变未来。今天是 2023 年 3 月 1 日，在 2015 年的今天，三星发表全新 Samsung Galaxy S6 edge 智能手机，成为全球首部双曲屏手机。在 Galaxy S6 发布一年之后，三星的Galaxy Note 7 “爆炸门”闹得沸沸扬扬，Galaxy S6 也未能幸免，从 2016 年 8 月 2 日起开始被...
诸葛亮vs司马懿，排序算法大战谁能笑到最后？
xuanyuan_fsx的专栏
06-08 2052
阵前对峙 公元234年，蜀汉丞相诸葛孔明再次北伐。 一日，与司马仲达所率魏军两军相峙，二人阵前舌战。 司马曰：“诸葛村夫，吾与汝相斗数年，斗兵斗阵斗谋略，均已疲乏。今日，何不一改陈规，斗点新奇玩意？” 诸葛轻抚羽扇，言道：“仲达今日想比试些什么？” “你我各遣相等数量兵士，立作一排，再互派一人至对方军前，看谁派遣之人先将这一排兵士按身高从低到高排序，谁就取胜，三局两胜制，输者撤军五十里，如何？” 诸葛不答，只是一边微笑，一边慢摇羽扇。 司马问道：“怎么？怕了？” 诸葛笑曰：“为将者，不通天文，不识地理，
『初阶数据结构 • C语言』④ - 冒泡排序
花想云的博客
12-20 1010
大 O记法能客观地衡量各种算法的时间复杂度，是比较算法的利器。我们也试过用它来对比二分查找和线性查找的步数差异，发现二分查找的步数为 O(log N)，比线性查找的 O(N)快得多。然而，写代码的时候并不总有这样明确的二选一，更多时候你可能就直接采用首先想到的那种算法了。不过有了大 O的话，你就可以与其他常用的算法比较，然后问自己：“我的算法跟它们相比，是快还是慢？”如果你通过大 O 发现自己的算法比其他的要慢，你就应该退一步，好好想想怎样优化它，才能使它变成更快的那种大 O。
希尔排序原理图解
weixin_44891285的博客
05-24 485
一/????案例步骤分解 二/????Java代码实现—— 锻炼逻辑思维，代码不是必要还是挺重要的 三/????还有一个问题—GAP怎么界定？ 四/????时间复杂度、空间复杂度及稳定性@TOC 希尔排序是D.L.Shell于1959年提出的因而得名。希尔排序就是插入排序的一种优化升级版，同时它是第一批在时间复杂度上突破O(n^2)的排序算法，所以意义深远。希尔排序会事先规定一个间隔值 gap 。假设有一个长度为n的数组arr，希尔排序会先对arr的子数组{arr[0],arr[gap],arr[gap
快速学习排序算法
爱编程
09-09 151
@IT程序猿 微博网友评论：@lang-friends：为什么bubble最快@twinkle_twinkler：这个排序效率有点乱，选择哪有那么快@黑米包子：为什么一样...
2020美团技术年货-合集.pdf
02-27
根据提供的文件内容，下面是从“2020美团技术年货”这一文件中提炼出的知识点，涵盖前端、后端、算法、数据处理、运维与安全、工程师文化等多个技术领域。 **前端技术领域：** 1. 移动端UI一致性解决方案，涉及跨...
408真题及答案.zip
07-16
对于数据结构部分，考生应掌握线性表、树、图、排序算法等基础知识；在计算机组成原理部分，要理解计算机的基本架构、指令系统、存储系统和I/O系统等；操作系统部分，学习进程管理、内存管理、文件系统等内容；至于...
RK3576-Hardware-Design-Guide
08-21
包含datasheet
273教学质量评价系统.zip
08-21
摘 要 随着科学技术的飞速发展，社会的方方面面、各行各业都在努力与现代的先进技术接轨，通过科技手段来提高自身的优势，教学质量评价系统当然也不能排除在外。教学质量评价系统是以实际运用为开发背景，运用软件工程开发方法，采用jsp技术构建的一个管理系统。整个开发过程首先对软件系统进行需求分析，得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统总体结构设计、系统数据结构设计、系统功能设计和系统安全设计等；详细设计主要包括模块实现的关键代码，系统数据库访问和主要功能模块的具体实现等。最后对系统进行功能测试，并对测试结果进行分析总结，及时改进系统中存在的不足，为以后的系统维护提供了方便，也为今后开发类似系统提供了借鉴和帮助。 本教学质量评价系统采用的数据库是Mysql，使用JSP技术开发。在设计过程中，充分保证了系统代码的良好可读性、实用性、易扩展性、通用性、便于后期维护、操作方便以及页面简洁等特点。
基于Android手机点餐系统APP设计与实现.docx
08-21
基于Android手机点餐系统APP设计与实现
全国自学考试计算机网络管理试题.pdf
最新发布
08-21
浙江省的全国自学考试计算机网络管理试题，总共38道题，包含单选，填空，多选等等。
七大经典排序算法解析：从冒泡到堆排序
"本文档是MoreWindows作者对七大经典排序算法的详解，旨在用通俗易懂的方式介绍冒泡排序、直接插入排序、直接选择排序、希尔排序、归并排序、快速排序和堆排序。这份资料适合准备面试和学习排序算法的读者。" 排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值