数据结构 排序算法

最新推荐文章于 2024-07-25 19:28:17 发布
最新推荐文章于 2024-07-25 19:28:17 发布
阅读量114 收藏
点赞数
文章标签： 数据结构 排序算法 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HSYDHASGD/article/details/130461928
版权

数据结构 排序算法C代码实现


对应视频 数据结构与算法基础（青岛大学-王卓）,P160-P173

插入排序

直接插入排序

有序插入，在有序序列中，插入一个元素，保持序列有序，有序长度不断增加。
算法流程示意图：
==算法流程示意图==
i指向当前需要进行插入排序的元素，i前绿色序列为有序序列，通过j的移动进行大小比较，从而寻找i插入的位置。数组0位置作为哨兵，保存i指向的元素。

代码实现：

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 20          //最大记录个数
typedef int KeyType;        //设关键字为整形量(int)

typedef struct 
{
    KeyType KeyVal;                 // 关键字
    //infotype otherinfo; //其他数据项
}RedType;                   //Record Type

typedef struct              //定义顺序表的结构
{
    RedType L[MAXSIZE+1];   //存储顺序表的向量
                            //r[0]一般用作哨兵或缓冲区
    int length;             //顺序表的长度

}SqList;

void sort(SqList * List)            //升序排列（前i-1列一定为有序序列）
{
    int i, j;
    for(int i=2;i<(List->length+1);i++)
    {    
        if(List->L[i].KeyVal < List->L[i-1].KeyVal)    //当第i个数小于第i-1个数时再进行比较
        {    
            List->L[0] = List->L[i];                   //将待检测数据保存至哨兵内
            for(j=(i-1); List->L[0].KeyVal < List->L[j].KeyVal; --j)      //倒序搜索
            {
                List->L[j+1] = List->L[j];
            }
            List->L[j+1].KeyVal = List->L[0].KeyVal;    //这里必须为j+1，应为当j不满足for循环跳出后会再执行一次--
                                                        //这里--需要补上
        }      
    }
    
}

SqList * List_input(void)
{
    SqList * List;
    List = (SqList *)malloc(sizeof(SqList));
    printf("MAXnum:");
    scanf("%d", &List->length);
    for(int i=1;i<List->length+1;i++)
    {
        printf("the %d number is: ", i);
        scanf("%d", &List->L[i].KeyVal); 
    }
    return List;
}

void Traverse_list(SqList * List)
{
    int i;
    printf("Traverse result:");
    for(i=1;i<List->length+1;i++)
    {
        printf("%d ", List->L[i].KeyVal);
    }
    printf("\n");
}

int main()
{
    SqList * list;
    list = List_input();
    Traverse_list(list);
    sort(list);
    Traverse_list(list);
    system("pause");
    return 0;
}

折半插入排序

在查找插入位置时采用折半查找法。
算法示意图：
在这里插入图片描述
代码实现：

#include <stdio.h>
#include <stdlib.h>

#define MAXSIZE 20          //最大记录个数
typedef int KeyType;        //设关键字为整形量(int)

typedef struct 
{
    KeyType KeyVal;                 // 关键字
    //infotype otherinfo; //其他数据项
}RedType;                   //Record Type

typedef struct              //定义顺序表的结构
{
    RedType L[MAXSIZE+1];   //存储顺序表的向量
                            //r[0]一般用作哨兵或缓冲区
    int length;             //顺序表的长度

}SqList;



SqList * List_input(void)
{
    SqList * List;
    List = (SqList *)malloc(sizeof(SqList));
    printf("MAXnum:");
    scanf("%d", &List->length);
    for(int i=1;i<List->length+1;i++)
    {
        printf("the %d number is: ", i);
        scanf("%d", &List->L[i].KeyVal); 
    }
    return List;
}

void Traverse_list(SqList * List)
{
    int i;
    printf("Traverse result:");
    for(i=1;i<List->length+1;i++)
    {
        printf("%d ", List->L[i].KeyVal);
    }
    printf("\n");
}

void sort(SqList * List)            //升序排列（前i-1列一定为有序序列）
{
    int i, j;
    int high, low, mid;
    for(i=2;i<List->length+1;i++)
    {
        if(List->L[i].KeyVal < List->L[i-1].KeyVal)
        {
            List->L[0] = List->L[i]; 
            high = i;
            low = 1;
            while(low <= high)          //二分查找，更新low,mid,high，确定插入位置
            {
                mid = (low + high)/2;
                if(List->L[0].KeyVal > List->L[mid].KeyVal)
                {
                    low = mid+1;        //需要+1，-1否则无法跳出while循环
                }
                else
                {
                    high = mid-1;
                }
            }
            for(j=i-1;j>high;j--)
            {
                List->L[j+1] = List->L[j];
            }
            List->L[low] = List->L[0];
        }
    }
  
}

int main()
{
    SqList * list;
    list = List_input();
    Traverse_list(list);
    sort(list);
    Traverse_list(list);
    system("pause");
    return 0;
}

希尔排序

基本思想：先将整个待排记录序列分割成若干子序列，分别进行直接插入排序，待整个序列中的记录“基本有序时”，在对全体记录进行一次直接插入排序。
注意定义的增量序列Dk，为递减序列，且最后一项必须为1.增量序列的元素还需互质。
算法示意图：
在这里插入图片描述
代码实现：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAXSIZE 20          //最大记录个数
typedef int KeyType;        //设关键字为整形量(int)

typedef struct 
{
    KeyType KeyVal;                 // 关键字
    //infotype otherinfo; //其他数据项
}RedType;                   //Record Type

typedef struct              //定义顺序表的结构
{
    RedType L[MAXSIZE+1];   //存储顺序表的向量
                            //r[0]一般用作哨兵或缓冲区
    int length;             //顺序表的长度

}SqList;



SqList * List_input(void)
{
    SqList * List;
    List = (SqList *)malloc(sizeof(SqList));
    printf("MAXnum:");
    scanf("%d", &List->length);
    for(int i=1;i<List->length+1;i++)
    {
        printf("the %d number is: ", i);
        scanf("%d", &List->L[i].KeyVal); 
    }
    return List;
}

void Traverse_list(SqList * List)
{
    int i;
    printf("Traverse result:");
    for(i=1;i<List->length+1;i++)
    {
        printf("%d ", List->L[i].KeyVal);
    }
    printf("\n");
}

// D(i)=2^i−1,i>0
void getHibbardStepArr(int n, int * HibbardStepArr)
{
    int i = 1;
    while(1)
    {
        if(i > n)
            break;
        else
            HibbardStepArr[i-1] = pow(2,i)-1;
        i++;
    }
}

void sort(SqList * List, int dk)            //升序排列（前i-1列一定为有序序列）
{
    int i, j;
    for(i=1+dk;i<List->length+1;i++)
    {   
        if(List->L[i].KeyVal < List->L[i-dk].KeyVal)
        {   
            List->L[0] = List->L[i];
            for(j=i-dk;j>0&&(List->L[0].KeyVal < List->L[j].KeyVal); j=j-dk)
            {
                List->L[j+dk] = List->L[j];
            }
            List->L[j+dk] = List->L[0];
        }
    }
  
}

void ShellSort(SqList * List, int * data, int t)
{  
    for(int k =0; k<t; k++)
        sort(List, data[k]);
}

int main()
{
    SqList * list;
    int dk[3]={1,3,5};
    //int dk2[3];
    //getHibbardStepArr(5, dk2);
    list = List_input();
    Traverse_list(list);
    ShellSort(list, dk, 3);
    Traverse_list(list);
    system("pause");
    return 0;
}

交换排序

基本思想：两两比较，如果发生逆序则交换，直到所有记录都排好序为止。

冒泡排序

基于简单的交换思想，每趟不断将记录两两比较，并按“前小后大”规则（前大后小也行）交换。
算法流程示意图：

规律总结：
n个记录，总共需要n-1趟循环。
第i次循环，需要进行n-i次两两比较。
代码实现：

头文件My_sort.c：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "My_sort.h"

SqList * List_input(void)
{
    SqList * List;
    List = (SqList *)malloc(sizeof(SqList));
    printf("MAXnum:");
    scanf("%d", &List->length);
    for(int i=1;i<List->length+1;i++)
    {
        printf("the %d number is: ", i);
        scanf("%d", &List->L[i].KeyVal); 
    }
    return List;
}

void Traverse_list(SqList * List)
{
    int i;
    printf("Traverse result:");
    for(i=1;i<List->length+1;i++)
    {
        printf("%d ", List->L[i].KeyVal);
    }
    printf("\n");
}

头文件My_sort.h:

#ifndef     _MY_SORT_H
#define     _MY_SORT_H

#define MAXSIZE 20          //最大记录个数
typedef int KeyType;        //设关键字为整形量(int)

typedef struct 
{
    KeyType KeyVal;                 // 关键字
    //infotype otherinfo; //其他数据项
}RedType;                   //Record Type

typedef struct              //定义顺序表的结构
{
    RedType L[MAXSIZE+1];   //存储顺序表的向量
                            //r[0]一般用作哨兵或缓冲区
    int length;             //顺序表的长度

}SqList;

void Traverse_list(SqList * List);
SqList * List_input(void);


#endif

#include <stdio.h>
#include <stdlib.h>
#include "My_sort.h"

void bubble_sort(SqList * List)         //升序排序 （不需要哨兵，从0开始排序）
{
    int i, j;
    KeyType temp;
    for(i=0;i<List->length-1;i++)       //n个元素需要对比n-1趟
    {
        for(j=0;j<List->length-i;j++)   //第i趟需要进行n-i词两两比较
        {
            if(List->L[j].KeyVal > List->L[j+1].KeyVal)
            {
                temp = List->L[j+1].KeyVal;
                List->L[j+1].KeyVal = List->L[j].KeyVal;
                List->L[j].KeyVal = temp;
            }
        }                
    }

}

int main()
{
    SqList * list;
    list = List_input();
    Traverse_list(list);
    bubble_sort(list);
    Traverse_list(list);
    system("pause");
    return 0;

}

快速排序

基本思想：
任取一个元素（如：第一个）为中心（pivot）。所有比它小的元素一律前放，比它大的元素一律后放，形成左右两个字表。
对各子表重新选择中心元素并依此规则调整，直到每个子表的元素只剩一个。
算法实现示意图：

在这里插入图片描述
实现方式：将首元素作为中心，放到哨兵位置，通过low，high指针进行排序判断，若high指向元素比界点小，则将high当前指向元素放置到low所指位置，low指针前移。再判断low指针所指元素是否比界点大，若大，则放置在high指针所指位置，若不大，则low++，当high和low相等时，该循环结束。

程序实现：（使用递归实现）

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "My_sort.h"


/*
    快速排序 （升序） 需要使用哨兵，用于保存选择的pivot
    采用递归实现
    以每一组数据的首项作为pivot
*/

void Quick_sort(SqList * List, int high, int low) 
{
    //int pivotloc;
    if(low < high)                          //递归停止条件！！！
    {
        int high_save = high;
        int low_save = low;
        List->L[0] = List->L[low];
        while (low != high)
        {
            while(List->L[high].KeyVal >= List->L[0].KeyVal && high>low) 
            {
                high--;
            }
            List->L[low] = List->L[high];
            //low++;
            while(List->L[low].KeyVal < List->L[0].KeyVal && low<high)
            {
                low++;
            }
            List->L[high] = List->L[low];
            //high--;
        }
        List->L[high] = List->L[0];
        // pivotloc = Partition(List, high, low);
        /*
            这里注意，用来确定排序的数组区间的两个端点随递归的调用也同时在变换
            之前的写法
            Quick_sort(List, low-1, 1);                      //左列
            Quick_sort(List, list->length, high+1);          //右列
            左列和的low和又列的high为定值，导致在子区间的子区间进行排序时
            low和high的指向错误，产生死循环。所以这里需要特别注意。
        */
        Quick_sort(List, low-1, low_save);                     //左列
        Quick_sort(List, high_save, high+1);                   //右列
        
    }
}


int main()
{
    SqList * list;
    list = List_input();
    Traverse_list(list);
    Quick_sort(list,list->length,1);
    Traverse_list(list);
    system("pause");
    return 0;

}

选择排序

简单选择排序

基本思想：在待排序的数据中选出最大（小）的元素放在其最终的位置。
基本操作：首先通过n-1次关键字比较，从n个记录中找出关键字最小的记录，将它与第一个记录交换。
在通过n-2次比价，从剩余的n-1个记录中找出关键字次小的记录，将它与第二个记录交换。
重复上述操作，共进行n-1趟排序后，排序结束。
实现示意图：
在这里插入图片描述
程序实现：

在这里插入代码片

堆排序

在这里插入图片描述
堆的实质是满足如下性质的完全二叉树：二叉树中，任一非叶子结点均小于（大于）他的孩子结点。

堆排序的实现方式：若输出堆顶的最小值（最大值）后，使得剩余n-1个元素的序列重新又建成一个堆，则得到n个元素的次小值（次大值）…如此反复，便能得到一个有序序列，这个过程称为堆排序。

该排序主要分为2个步骤：

  1. 将无序序列建成一个堆；
  2. 在输出堆顶元素后，调整剩余元素成为一个新的堆。

算法实现：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "My_sort.h"

/*
    完全二叉树，根节点和字节点的关系
                i
            2i     2i+1
    以知顺便表L[s...m]中除了L[s]之外堆均满足定义，本函数调整
    L[s]的关键字，使L[s...m]成为一个大根堆
*/

void Heap_adjust(RedType * L, int s, int m)             // 线性表大堆构造
{
    int rc;
    rc = L[s].KeyVal;
    for(int j=2*s;j<=m;j*=2)
    {
        if(j<m && (L[j].KeyVal < L[j+1].KeyVal))        // 保证j记录的是子节点中最大节点的序号
            j++;                                        // 
        if(rc >= L[j].KeyVal)                           // 根节点比子节点大
            break;
        L[s].KeyVal = L[j].KeyVal;                      // 否则根节点和右节点交换
        s = j;                                          // 交换后若子节点还有子子节点 需要继续检查是否满足大堆条件
    }
    L[s].KeyVal = rc;
}

void Heap_sort(SqList * List)                           //升序
{
    int i;
    RedType temp;
    for(i=(List->length)/2; i>=1; i--)                  // 构造大根堆
    {
        Heap_adjust(List->L, i, List->length);
    }
    for(i = List->length; i>1; i--)                     // 将堆顶最大元素放置顺序表末尾，末尾元素放置堆顶，重新进行大堆排序
    {
        temp = List->L[1];
        List->L[1] = List->L[i]; 
        List->L[i] = temp;
        Heap_adjust(List->L, 1, i-1);
    }

}

int main()
{
    SqList * list;
    list = List_input();
    Traverse_list(list);
    Heap_sort(list);
    Traverse_list(list);
    system("pause");
    return 0;
}

归并排序

基本思想：将两个或两个以上的有序子序列“归并”为一个有序序列。
在内部排序中，通常采用的是2-路归并排序。即：将两个位置相邻的有序子序列R[l…m]和R[m+1,…,n]归并为一个有序序列R[l…m]

算法图释;
在这里插入图片描述
算法实现：（通过递归实现）

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "My_sort.h"

/*
    将两个位置相邻的有序子序列R[low...mid]和R[mid+1,...,high]归并为一个有序序列R[low...high]
*/
void Merge(SqList * List, int low, int mid, int high)       
{
    RedType * temp = (RedType *) malloc((MAXSIZE+1) * sizeof(RedType));
    int i, j, k;
    for(i=low;i<=high;i++)
    {
        temp[i] = List->L[i];                   //将原顺序表全部复制到temp中
    }
    for(i=low,j=mid+1,k=low; i<=mid && j<=high;k++) //比较temp中左右两段的元素
    {
        if(temp[i].KeyVal < temp[j].KeyVal)
        {
            List->L[k] = temp[i++];              //小的放在List的前面
            //i++;
        }
        else
        {   
            List->L[k] = temp[j++];
            //j++;
        }
    }
    while(i<= mid)                             //若左列没检测完，复制
    {
        List->L[k++] = temp[i++]; 
    }
    while(j<= high)                             //若右列没检测完，复制
    {
        List->L[k++] = temp[j++]; 
    }
}

void Merge_sort(SqList * List, int low, int high)
{
    if(low < high)
    {
        int mid = (high+low)/2;
        Merge_sort(List, low, mid);                //左列进行归并排序
        Merge_sort(List, mid+1, high);             //右列进行归并排序
        Merge(List,low, mid, high);                //左右列合并
    }       
}

int main()
{
    SqList * list;
    list = List_input();
    Traverse_list(list);
    Merge_sort(list,1,list->length);
    Traverse_list(list);
    system("pause");
    return 0;
}

基数排序

思想：分配+收集
也叫桶排序或者箱排序：设置若干个箱子，将关键字为K的记录放入第k个箱子，然后按照序号将非空的连接。
要求：待分配的对象的可能性是有限个数的，否则无法设置“箱子”。

代码实现：

在这里插入代码片

各种排序算法比较

一、 时间性能

  1. 时间性能：
  • 按平均的时间性能来分，有三类排序方法：
  • 时间复杂度为O(nlogn)的方法有：
    快速排序，堆排序和归并排序，其中快速排序为最好；
  • 时间复杂度为O(n^2)的有：
    直接插入排序，冒泡排序和简单选择排序，其中以直接插入为最好，特别是那些对关键字近似有序的记录尤为如此；
  • 时间负载度为O(n)的排序方法只有：基数排序。
  1. 当待记录顺序列按关键字顺序有序时，直接插入排序和冒泡排序能达到O(n)的时间复杂度；而对于快速排序而言，这是最不好的情况，此时的时间性能退化为O(n^2)，因此是应该尽量避免的情况。
  2. 简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。

==================================

二、 空间性能
指的是排序过程中所需要的辅助空间大小。

  1. 所有的简单排序方法（包括：直接插入、冒泡和简单选择）和堆排序的空间复杂度为O(1)
  2. 快速排序为O(logn)，为栈所需的辅助空间
  3. 归并排序所需的辅助空间最多，其空间复杂度为O(n)
  4. 链式基数排序需附设队列首位指针，则空间复杂度为O(rd)

==================================

三、排序方式的稳定性

  1. 稳定的排序方式是指，对于两个关键字相同的记录，它们在序列中的相对位置，在排序前后不发生改变；
  2. 当对多关键字的记录序列进行LSD方法排序式时，必须采用稳定的排序方式。
  3. 对于不稳定的排序方法，只要能举出一个实例说明即可。
  4. 快速排序和堆排序是不稳定的排序方法。

==================================

各种排序算法总结：
在这里插入图片描述

HSYDHASGD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构排序算法
The_star_is_at的博客
06-23 1092
#include using namespace std; /* 输入一组关键字序列分别实现下列排序: 1.实现简单选择排序、直接插入排序和冒泡排序。 2.实现希尔排序算法。 3.实现快速排序算法。 4.实现堆排序算法。 */ #define Maxsize 100 using namespace std; typedef int KeyType; type
【数据结构】八大排序(超详解+附动图+源码)
热门推荐
Edward_Asia的博客
11-21 8万+
前言 所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。 生活中各种地方都需要用到排序，所以学好排序算法是非常重要的。 排序分为 内部排序 和 外部排序。 内部排序：数据元素全部放在内存中的排序。外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。 这部分主要是内部排序。排序讲解都以升序为例。 常见的排序算法： // 排序实现的接口 // 插入排序 void InsertSort(int* arr..
数据结构排序算法实验报告c语言
hqm793899006的博客
12-12 4120
题目描述 设计并实现一个管理系统（学生管理、图书管理、产品管理等等），系统中需包含1000条以上的记录，系统至少包含以下功能： (1) 自动生成记录信息（或者从文件中读取）； (2) 逐条显示所有记录信息； (3) 利用时间复杂度O(n2)的排序算法（例如直接插入排序或者折半插入排序）按照关键字进行排序； (4) 利用时间复杂度O(nlogn)的排序算法（例如快速排序）按照关键字进行排序； (5) 程序中统计（3）和（4）的算法在数据正序、逆序、乱序情况下的比较次数与移动次数并输出，在报告中对比较次数与移动
数据结构：十大经典排序算法
这个人很懒，什么都没有留下。
11-25 2784
数据结构：十大经典排序算法
合并排序 数据结构 排序算法
12-22
合并排序 数据结构 排序算法
C++数据结构排序算法
09-13
C++数据结构排序算法总结 在计算机科学中，排序算法是最基本和最重要的算法之一。在实际应用中，排序算法广泛应用于各种领域，如数据分析、机器学习、数据库管理等。C++数据结构排序算法总结将为您提供详细的排序...
数据结构 排序算法 动画演示.ppt
03-19
数据结构 排序算法 动画演示.ppt
学习记录day18——数据结构 算法
weixin_64918301的博客
07-24 608
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
c语言（7.23）
fhgfyrsg的博客
07-23 503
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 787
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构之深入理解简单选择排序：原理、实现与示例（C，C++）
qq_35320456的博客
07-24 738
简单选择排序虽然在大数据量下效率不高，但它易于理解和实现，是理解排序算法基本思想的良好起点。在实际应用中，如果数据量较小或者对排序稳定性要求不高，选择排序可以作为一种简单有效的选择。
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 411
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构——单链表OJ题（下）
最新发布
2301_81888634的博客
07-25 635
链表既然包括单链表，就还有其他种类啦~敬请期待“双向链表”~
数据结构（特殊二叉树-平衡二叉树）
weixin_65029285的博客
07-23 956
待删除节点左右子树非空，则根据左右子树的高度，选择高的一边子树，如果是左子树高，选择左子树中的最大节点赋值给待删除节点，然后再左子树中继续删除该最大节点，相当于继续处理情况1或情况2；由于节点的位置要受到相互之间值的影响，并且在往平衡二叉树中添加节点或者删除节点前，二叉树本身是平衡的，所以只可能在最后操作的节点附近不满足平衡条件，因此需要在该过程中对该节点进行判断并调整。如果一个搜索二叉树呈现或接近单支状，它的查找效率很低，很接近链表，因此如果能让它平衡时，查找效率最高。待删除的节点是叶子节点，直接删除。
【数据结构】顺序表（c语言实现）（附源码）
2301_80955819的博客
07-24 825
顺序表的概念和结构，顺序表的分类，顺序表的功能实现
算法与排序算法
没有百宝袋的哆啦A梦的博客
07-24 925
程序核心代码写注释、程序代码有缩进、程序代码命名规范。对于给定的不合理的输入数据，能够给出相应的处理措施。算法中每一条语句都有确定的含义，不能模棱两可。给定合理的输入数据，能够得到正确的结果。4> 归并排序：二路归并、多路归并。经济可行性、社会可行性、能够运行。O(f(n)):使用O阶记法，记录算法时间复杂度。程序执行一段时间后会自动结束。f(n) :是问题规模与执行次数之间的函数。要求时间复杂度要尽可能低。要求空间复杂度尽可能低。至少有零个或多个输入。T(n):时间复杂度。
数据结构day3（双向链表操作）
weixin_66436813的博客
07-24 348
线性表的链式存储：解决了顺序存储的缺点，插入和删除。注意：用自己结构的指针一般就是 链表。DoubleLInk.h文件。DoubleLInk.c文件。
数据结构排序算法时间性能实验对比研究
本资源是一份关于"数据结构各种排序算法的时间性能"的课程实习报告，旨在通过实际操作来深入理解排序算法的时间复杂性。报告针对快速排序、堆排序、希尔排序、冒泡排序和归并排序等多种常见的排序算法进行性能比较。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值