算法分析之排序（C语言）

最新推荐文章于 2022-08-21 19:39:41 发布
最新推荐文章于 2022-08-21 19:39:41 发布
阅读量245 收藏 3
点赞数 2
分类专栏： 算法 文章标签： 算法 排序算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45824303/article/details/105595127
版权

算法分析之排序--C语言

排序函数具体操作

下面是函数具体操作：(文件名称：sort.c)

//FILE: sort.c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>

//函数声明
void bubbleSort(int *a, int n); //冒泡排序
void selectSort(int *a, int n); //选择排序
void insertSort(int *a, int n); //插入排序
void MergeArray(int *a, int begin, int mid, int end, int *temp); //归并排序(合并数组)
void MergeSort(int *a, int begin, int end, int *temp); //归并排序
void QuickSort_Recursion(int *a, int begin, int end); //快速排序(递归)
void PartitionQuickSort(int *a, int begin, int end); //快速排序(枢轴存放)
int NumberOfThree(int *a, int begin, int end);//枢轴为三数取中
void Swap(int *x, int *y); //数据交换
void CountSort(int *a, int size , int max); //计数排序
void RadixCountSort(int *a, int size); //基数排序
int arrayMax(int *arr, int size); //数组中的最大值
int getDigitNum(int x); //得到数据的位数

//函数具体操作
//冒泡排序
void bubbleSort(int *a, int n)
{
    int i, j, temp;

    for (i = 0; i < n - 1; i++)
    {
        for (j = 0; j < n - i; j++)
        {
            if (a[j] > a[j+1])
            {
                temp = a[j];
                a[j] = a[j + 1];
                a[j+1] = temp;
            }
        }
    }
}

//选择排序
void selectSort(int *a, int n)
{
    int i, j, min, temp;

    for (i = 0; i < n - 1; i++)
    {
        min = i;
        for (j = i + 1; j < n; j++)
        {
            if (a[min] > a[j])
            {
                min = j;
            }
        }
        temp = a[min];
        a[min] = a[i];
        a[i] = temp;
    }
}

//插入排序
void insertSort(int *a,int n)
{
    int i, j, temp;
    for(i = 1; i < n; i++)
    {
        temp = a[i];
        for(j = i - 1; j >= 0 && a[j] > temp; j--)
        {
            a[j + 1] = a[j];
        }
        a[j + 1] = temp;
    }
}

//归并排序(合并数组)
void MergeArray(int *a,int begin,int mid,int end,int *temp)
{
    int k = begin;
    int left_begin = begin, left_end = mid;
    int right_begin = mid + 1, right_end = end;

    while(left_begin <= left_end && right_begin <= right_end)
    {
        if(a[left_begin] < a[right_begin])
        {
            temp[k++] = a[left_begin++];
        }
        else
        {
            temp[k++] = a[right_begin++];
        }
    }

    while(left_begin <= left_end)
    {
        temp[k++] = a[left_begin++];
    }
    while(right_begin <= right_end)
    {
        temp[k++] = a[right_begin++];
    }

    for(k = begin; k <= end; k++)
    {
        a[k] = temp[k];
    }
}

//归并排序
void MergeSort(int *a,int begin,int end,int *temp)
{
    if(begin >= end)
    {
        return;
    }
    else
    {
        int mid = (begin + end) / 2;
        MergeSort(a, begin, mid, temp);
        MergeSort(a, mid + 1, end, temp);
        MergeArray(a, begin, mid, end, temp);
    }
}

//快速排序(递归)
void QuickSort_Recursion(int *a, int begin, int end)
{
    int i = begin, j = end;
    int temp;
    int pivot = a[begin]; //选取第一个元素为基准点
    
    while(i <= j)
    {
        //找到左边大于基准点的元素
        while(a[i] < pivot)
        {
            i++;
        }
        //找到右边小于基准点的元素
        while(a[j] > pivot)
        {
            j--;
        }

        //当左边下标小于右边时，互换元素
        if(i <= j)
        {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
            //互换后i, j继续靠近
            i++;
            j--;
        }
    }

    //左边进行递归
    if(i < end)
    {
        QuickSort_Recursion(a, i, end);
    }
    //右边进行递归
    if(begin < j)
    {
        QuickSort_Recursion(a, begin, j);
    }
}

//快速排序(枢轴存放)
void PartitionQuickSort(int *a, int begin, int end)
{
    int i = begin, j = end;
    int temp;
    int pivot = NumberOfThree(a, begin, end); //三数取中作为基准元素
    
    while(i <= j)
    {
        //找到左边大于基准点的元素
        while(a[i] < pivot)
        {
            i++;
        }
        //找到右边小于基准点的元素
        while(a[j] > pivot)
        {
            j--;
        }

        //当左边下标小于右边时，互换元素
        if(i <= j)
        {
            temp = a[i];
            a[i] = a[j];
            a[j] = temp;
            //互换后i, j继续靠近
            i++;
            j--;
        }
    }

    //左边进行递归
    if(i < end)
    {
        QuickSort_Recursion(a, i, end);
    }
    //右边进行递归
    if(begin < j)
    {
        QuickSort_Recursion(a, begin, j);
    }
}

//枢轴为三数取中
int NumberOfThree(int *a,int begin,int end)
{
	int mid = (begin + end) / 2 + begin;
 
	if (a[mid] > a[end])
	{
		Swap(&a[mid], &a[end]);
	}
	if (a[begin] > a[end])
	{
		Swap(&a[begin], &a[end]);
	}
	if (a[mid] > a[begin]) 
	{
		Swap(&a[mid], &a[begin]);
	}
	//此时a[mid] <= a[begin] <= a[end]
	return a[begin];
}

//数据交换
void Swap(int *x, int *y)
{
    int temp;
    temp = *x;
    *x = *y;
    *y = temp;
}

//计数排序
void CountSort(int *a, int size , int max)
{
    int i;
    int *count, *sorted;
    
    //给计数器和已排序数组分配空间
    count = (int *)malloc(sizeof(int) * (max + 1));
    sorted = (int *)malloc(sizeof(int) * size);
    if(count == NULL || sorted == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        exit(0);
    }
    
    //计数数组初始化为0
    for(i = 0; i < max + 1; i++)
    {
        count[i] = 0;
    }
    //收集原数组中每种值的个数
    for(i = 0; i < size; i++)
    {
        count[a[i]]++;
    }
    //统计所有小于等于该值的元素个数
    for(i = 1; i < max + 1; i++)
    {
        count[i] += count[i - 1];
    }
    //将所有元素按收集表分配到对应位置，反向填充目标数组
    for(i = size - 1; i >= 0; i--)
    {
        //先将计数数组中对应值-1
        count[a[i]]--;
        sorted[count[a[i]]] = a[i];
    }
    //已排序数组替代原数组
    for(i = 0; i < size; i++)
    {
        a[i] = sorted[i];
    }

    //释放内存
    free(count);
    free(sorted);
}

/* 下面是基数排序，第二个在第一个的基础上进行了优化，
改变了循环位数的方法，在20万个范围为0-999的随机数的排序测试下，
第一个基数排序耗时十几分钟，第二个基数排序耗时十几毫秒(质的飞跃) */

/* //基数排序
void RadixCountSort(int *a,int size)
{
    int base = 10; //基数设为10
    int i, n, index, max, maxnum, pval;
    int *count, *sorted;
    
    //计算数组中的最大值
    max = arrayMax(a, size);
    //计算数据最高位
    maxnum = getDigitNum(max);
    
    //给计数器和已排序数组分配空间
    count = (int *)malloc(sizeof(int) * base); 
    sorted = (int *)malloc(sizeof(int) * size);
    if(count == NULL || sorted == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        exit(0);
    }

    for(n = 0; n < maxnum; n++)
    {
        //计数数组初始化为0
        for(i = 0; i < base; i++)
        {
            count[i] = 0;
        }
        //计算位置值
        pval = pow(base, n);
        //统计当前位上每个数值出现的次数
        for(i = 0; i < size; i++)
        {
            index = a[i] / pval % base;
            count[index]++;
        }
        //统计所有小于等于该值的元素个数
        for(i = 1; i < base; i++)
        {
            count[i] += count[i - 1];
        }
        //将所有元素按收集表分配到对应位置
        for(i = size - 1; i >= 0; i--)
        {
            index = a[i] / pval % base;
            count[index]--;
            sorted[count[index]] = a[i];
        }
        //已排序数组替代原数组
        memcpy(a, sorted, sizeof(int) * size);
    }

    //释放内存
    free(count);
    free(sorted);
} */

//优化后的基数排序
void RadixCountSort(int *a,int size)
{
    int i, index, max;
    int rad = 1; //从个位开始
    int *count, *sorted;
    
    //计算数组中的最大值
    max = arrayMax(a, size);
    
    //给计数器和已排序数组分配空间
    count = (int *)malloc(sizeof(int) * 10); 
    sorted = (int *)malloc(sizeof(int) * size);
    if(count == NULL || sorted == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        exit(0);
    }

    while(max / rad > 0)
    {
        //计数数组初始化为0
        for(i = 0; i < 10; i++)
        {
            count[i] = 0;
        }
        //统计当前位上每个数值出现的次数
        for(i = 0; i < size; i++)
        {
            index = a[i] / rad % 10;
            count[index]++;
        }
        //统计所有小于等于该值的元素个数
        for(i = 1; i < 10; i++)
        {
            count[i] += count[i - 1];
        }
        //将所有元素按收集表分配到对应位置
        for(i = size - 1; i >= 0; i--)
        {
            index = a[i] / rad % 10;
            count[index]--;
            sorted[count[index]] = a[i];
        }
        //已排序数组替代原数组
        for(i = 0; i < size; i++)
        {
            a[i] = sorted[i];
        }
        rad *= 10; //位数乘10
    }

    //释放内存
    free(count);
    free(sorted);
}

//求数组最大值
int arrayMax(int *arr, int size)
{
    int i, max = arr[0];
    for(i = 0; i < size; i++)
    {
        if(arr[i] > max)
        {
            max = arr[i];
        }
    }
    return max;
}

//得到数据的位数
int getDigitNum(int x)
{
    if(x == 0)
    {
        return 1;
    }
    else
    {
        int res;//数据最高位
        while(x != 0)
        {
            x /= 10;
            res++;
        }
        return res;
    }
}

main函数

下面是调用排序函数(文件名称：sort_main.c)

//FILE: sort_main.c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<windows.h>
#include "sort.c"

//main函数
int main(void)
{
    int len, max, i; //数组长度，数组最大值，计数器
    int *data; //存入原始数据
    int *arr1, *arr2, *arr3, *arr4, *arr5, *arr6, *arr7, *arr8; //进行各种排序的数组
    int *temp = NULL;

    printf("没有写防脸滚键盘的功能，测试的时候请按要求输入！\n");
    //录入数据
    printf("请输入数组长度：");
    scanf("%d", &len);
    data = (int *)malloc(sizeof(int) * len);
    if(data == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        return -1;
    }
    printf("请录入整型数据(以回车间隔)：\n");
    for(i = 0; i < len; i++)
    {
        scanf("%d", data + i);
    }
    //打印原始数据
    printf("数据录入完毕\n录入的数据为：\n");
    for(i = 0; i < len; i++)
    {
        printf("%d\t", *(data + i));
    }
    printf("\n");

    //进行冒泡排序
    arr1 = (int *)malloc(sizeof(int) * len);
    if(arr1 == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        return -1;
    }
    memcpy(arr1, data, sizeof(int) * len);
    bubbleSort(arr1, len);
    printf("冒泡排序后结果：\n");
    for(i = 0; i < len; i++)
    {
        printf("%d\t", *(arr1 + i));
    }
    printf("\n");

    //进行选择排序
    arr2 = (int *)malloc(sizeof(int) * len);
    if(arr2 == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        return -1;
    }
    memcpy(arr2, data, sizeof(int) * len);
    selectSort(arr2, len);
    printf("选择排序后结果：\n");
    for(i = 0; i < len; i++)
    {
        printf("%d\t", *(arr2 + i));
    }
    printf("\n");

    //进行插入排序
    arr3 = (int *)malloc(sizeof(int) * len);
    if(arr3 == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        return -1;
    }
    memcpy(arr3, data, sizeof(int) * len);
    insertSort(arr3, len);
    printf("插入排序后结果：\n");
    for(i = 0; i < len; i++)
    {
        printf("%d\t", *(arr3 + i));
    }
    printf("\n");

    //进行归并排序
    arr4 = (int *)malloc(sizeof(int) * len);
    if(arr4 == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        return -1;
    }
    temp = (int *)malloc(sizeof(int) * len);
    if(temp == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        return -1;
    }
    memcpy(arr4, data, sizeof(int) * len);
    MergeSort(arr4, 0, len - 1, temp);
    printf("归并排序后结果：\n");
    for(i = 0; i < len; i++)
    {
        printf("%d\t", *(arr4 + i));
    }
    free(temp);
    printf("\n");

    //进行快速排序(递归)
    arr5 = (int *)malloc(sizeof(int) * len);
    if(arr5 == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        return -1;
    }
    memcpy(arr5, data, sizeof(int) * len);
    QuickSort_Recursion(arr5, 0, len - 1);
    printf("快速排序(递归)后结果：\n");
    for(i = 0; i < len; i++)
    {
        printf("%d\t", *(arr5 + i));
    }
    printf("\n");

    //进行快速排序(枢轴存放)
    arr6 = (int *)malloc(sizeof(int) * len);
    if(arr6 == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        return -1;
    }
    memcpy(arr6, data, sizeof(int) * len);
    PartitionQuickSort(arr6, 0, len - 1);
    printf("快速排序(枢轴存放)后结果：\n");
    for(i = 0; i < len; i++)
    {
        printf("%d\t", *(arr6 + i));
    }
    printf("\n");

    //进行计数排序
    arr7 = (int *)malloc(sizeof(int) * len);
    if(arr7 == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        return -1;
    }
    memcpy(arr7, data, sizeof(int) * len);
    //找到数组中的最大值
    max = arrayMax(arr7, len);
    CountSort(arr7, len, max);
    printf("计数排序后结果：\n");
    for(i = 0; i < len; i++)
    {
        printf("%d\t", *(arr7 + i));
    }
    printf("\n");

    //进行基数排序
    arr8 = (int *)malloc(sizeof(int) * len);
    if(arr8 == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        return -1;
    }
    memcpy(arr8, data, sizeof(int) * len);
    RadixCountSort(arr8, len);
    printf("基数排序后结果：\n");
    for(i = 0; i < len; i++)
    {
        printf("%d\t", *(arr8 + i));
    }
    printf("\n");

    //释放内存
    free(data);
    free(arr1);
    free(arr2);
    free(arr3);
    free(arr4);
    free(arr5);
    free(arr6);
    free(arr7);
    free(arr8);

    system("pause");
    return 0;
}

测试程序

下面是对排序算法的测试
PS：快排会压栈，测试快排请注释掉其他排序

//FILE: sort_test.c
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<time.h>
#include<windows.h>
#include "sort.c"

//宏定义常量
#define LEN 10000 //测试大数据下排序的数组长度
#define N 100000 //执行次数
#define M 100 //每个数组的长度
#define RANGE 1000 //随机数范围

int main(void)
{
    int i, j, max;
    int test1[LEN], test2[M];
    int *temp;
    clock_t start, end;
    //生成大数据
    for(i = 0; i < LEN; i++) //生成LEN个随机数
    {
        test1[i] = rand() % RANGE; //生成0~999的数据(range - 1)
    }

    //大数据测试
    printf("下面是%d个数据的排序情况：\n", LEN);
    
    //插入排序
    start = clock();
    insertSort(test1, LEN);
    end = clock();
    printf("插入排序：%d ms\n", end - start);
    
    //归并排序
    temp = (int *)malloc(sizeof(int) * LEN);
    if(temp == NULL)
    {
        printf("内存分配失败\n");
        system("pause");
        exit(0);
    }
    start = clock();
    MergeSort(test1, 0, LEN - 1, temp);
    end = clock();
    printf("归并排序：%d ms\n", end - start);
    free(temp);
    
    //快速排序(递归)
    start = clock();
    QuickSort_Recursion(test1, 0, LEN - 1);
    end = clock();
    printf("快速排序(递归)：%d ms\n", end - start);
    
    //快速排序(枢轴存放)
    start = clock();
    PartitionQuickSort(test1, 0, LEN - 1);
    end = clock();
    printf("快速排序(枢轴存放)：%d ms\n", end - start);
    
    //计数排序
    start = clock();
    max = arrayMax(test1, LEN);
    CountSort(test1, LEN, max);
    end = clock();
    printf("计数排序：%d ms\n", end - start);
    
    //基数排序
    start = clock();
    RadixCountSort(test1, LEN);
    end = clock();
    printf("基数排序：%d ms\n", end - start);

    //测试大量小数组
    //进行100k次排序，每次对大小为100的数组进行排序
    printf("下面测试大量小数组\n");

    //插入排序
    start = clock();
    for(i = 0; i < N; i++)
    {
        for(j = 0; j < M; j++)
        {
            test2[j] = rand() % RANGE;
        }
        insertSort(test2, M);
    }
    end = clock();
    printf("插入排序：%d ms\n", end - start);

    //归并排序
    start = clock();
    for(i = 0; i < N; i++)
    {
        temp = (int *)malloc(sizeof(int) * M);
        if(temp == NULL)
        {
            printf("内存分配失败\n");
            system("pause");
            exit(0);
        }
        for(j = 0; j < M; j++)
        {
            test2[j] = rand() % RANGE;
        }
        MergeSort(test2, 0, M - 1, temp);
        free(temp);
    }
    end = clock();
    printf("归并排序：%d ms\n", end - start);

    //快速排序(递归)
    start = clock();
    for(i = 0; i < N; i++)
    {
        for(j = 0; j < M; j++)
        {
            test2[j] = rand() % RANGE;
        }
        QuickSort_Recursion(test2, 0, M - 1);
    }
    end = clock();
    printf("快速排序(递归)：%d ms\n", end - start);

    //快速排序(枢轴存放)
    start = clock();
    for(i = 0; i < N; i++)
    {
        for(j = 0; j < M; j++)
        {
            test2[j] = rand() % RANGE;
        }
        PartitionQuickSort(test2, 0, M - 1);
    }
    end = clock();
    printf("快速排序(枢轴存放)：%d ms\n", end - start);

    //计数排序
    start = clock();
    for(i = 0; i < N; i++)
    {
        for(j = 0; j < M; j++)
        {
            test2[j] = rand() % RANGE;
        }
        max = arrayMax(test2, M);
        CountSort(test2, M, max);
    }
    end = clock();
    printf("计数排序：%d ms\n", end - start);

    //基数排序
    start = clock();
    for(i = 0; i < N; i++)
    {
        for(j = 0; j < M; j++)
        {
            test2[j] = rand() % RANGE;
        }
        RadixCountSort(test2, M);
    }
    end = clock();
    printf("基数排序：%d ms\n", end - start);

    system("pause");
    return 0;
}

以上就是全部内容，有错误还请在评论中指出来，一起学习，一起进步。还有很多的排序方法，有时间学习后再进行补充。

不要做码农呀
关注
专栏目录
算法设计与分析——插入排序
karin_0的博客
09-19 889
算法的定义 有穷性（finite）：每条指令执行次数有穷性 确定性（define）：每条指令的意思明确，无二义性 可行性（effictive）：每条指令可执行，即人们用笔和纸做有限次运算也可完成 输入（input）：0/1个输入 输出（output）：1/n个输出，与输入量存在某种特定关系 算法复杂性分析 时间复杂度 T(n) 时间复杂度即...
插入排序_算法设计与分析_C语言_Java_python
zhangkai9895的博客
03-15 284
插入排序 伪代码描述 动图演示 #include<stdio.h> #include<stdlib.h> void insertSort(int*, int); int main() { int num[10]; for (int i = 0; i < 10; i++) { scanf("%d", num + i); } insertSort(nu...
C语言排序详解
weixin_46383092的博客
11-20 1581
排序 插入排序 把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为 止，得到一个新的有序序列 。 插入排序对于接近有序的数据进行排序时，效率很高。 void InsertSort(int* number, int size) { for (int i = 0; i < size - 1; i++) { int tmp = number[i + 1]; int end = i; while (end >= 0) { if (nu
算法分析-数组6种排序(少桶排序)
Mrchenyulei的博客
02-16 465
参考书目《数据结构与算法分析(C语言描述)》 快速排序参考实验楼快速排序 //排序函数接口 #ifndef _ALLSORT_H #define _ALLSORT_H void BubbleSort(int A[],int N); void InsertSort(int A[],int N); void ShellSort(int A[],int N); void HeapSort(
快排算法分析及图解
qq_41654777的博客
12-14 1082
分析 快排相当于在数组最左边和数组最右边定义两个指针，将数组第一个元素定义为key。 左指针负责将定位到的<key的元素全部丢到右边，右指针负责将定位到的<=key的元素全部丢到左边。 这样一来，当循环结束后，将key值和两个指针重叠的数值进行交换后，所有左边的元素都<=key，而所有右边的元素都>key。然后再重复以上做法，将key左边的数组进行同样的算法排序，...
数据结构与算法分析--C语言描述_数据结构与算法_
10-01
本资源"数据结构与算法分析--C语言描述"是针对数据结构初学者的一个优秀教材，旨在帮助读者快速掌握这一领域。 首先，数据结构是组织和存储数据的方式，它决定了数据的访问效率和处理速度。常见的数据结构包括数组...
【排序算法】希尔排序（C语言）
热门推荐
weixin_52811588的博客
08-21 5万+
希尔排序也叫缩小增量排序，这里详述了希尔排序的步骤和过程，并用C语言实现了希尔排序，提供给大家参考
C语言排序算法之冒泡排序
最新发布
12-25
冒泡排序是一种基础且经典的排序算法，主要应用于C语言编程中。它的工作原理是通过不断地交换相邻两个元素的位置，使得较大的元素逐渐“浮”到数组的一端，就像水中的气泡逐渐上升到水面一样，因此得名“冒泡排序”...
数据结构与算法分析（C语言描述）习题答案
08-01
《数据结构与算法分析（C语言描述）》是一本深入探讨数据结构和算法的经典教材，主要面向使用C语言编程的学习者。这本书详细介绍了各种数据结构的实现方式以及对应的算法分析，帮助读者理解如何有效地存储和处理数据...
C语言排序算法之冒泡排序实现方法【改进版】
08-29
本文主要介绍了C语言排序算法之冒泡排序实现方法，结合具体实例形式分析了C语言实现的基本冒泡排序实现方法及增设flag标志位的改进型算法。 一、冒泡排序算法的基本概念 冒泡排序是一种简单的排序算法，通过反复...
递归分治策略排序C语言实现
梦醒时分
11-15 490
#include &lt;iostream&gt; #include &lt;stdio.h&gt; using namespace std; #include&lt;stdio.h&gt; #include&lt;string.h&gt; void quickSort(int a[], int i, int j) { if(i&lt;j) { int l=i,...
算法分析-C语言描述
m0_63260509的博客
08-08 996
这个系列争取在12天以内完结本教程默认您熟悉递归的运用，以及高中基本数学知识。递归不仅简化了算法设计，也有助于写出更简洁的代码。但递归的效率并不是很理想，不合理的递归程序在内存开销方面也是很占空间的（虽然现在计算机的内存比较大，但数据量变的特别庞大以后就也难说了）。 递归函数再结束之前会一直在栈区开辟空间，一直到基准条件（如果没有基准条件会一直执行）斐波那契数的计算： 递归调用是恐怖的指数级增长O（2的n次方），而for循环仅仅是常数级O（N）；大可输入48试一试。3，一般法则附上一般教科书都会有的几个
c语言指针算法分析怎么写,什么叫指针算法啊？？
weixin_39559277的博客
05-23 108
该楼层疑似违规已被系统折叠隐藏此楼查看此楼Pointer arithmetic should not be used.This rule refers to explicitly calculating pointer values. Any such pointer value then has thepotential to access unintended or invalid memo...
c语言算法说明怎么写,C语言的几个算法排序说明.doc
weixin_33477210的博客
05-24 467
算法排序/xiajun0座机电话号码/article/details/座机电话号码下面简要总结了常用的一些排序算法。如有错误，还请大家指正、见谅~~谢谢~~【1】插入排序：是一个对少量元素进行排序的有效算法。实现比较简单。时间复杂度：O n^2 ，空间复杂度：O 1 。是稳定的排序方法。代码：view plaincopy to clipboardprint?//insertion?sort #in...
算法分析与设计 第六周 两个排序数组的中位数
Yanzu_Wu的博客
10-13 437
算法设计与分析 第六周两个排序数组的中位数1.题目描述2.选题原因3.题目分析及算法3.1分析3.2算法4.核心代码4.1出口4.2比较过程5.结果6.源代码 1.题目描述 2.选题原因 本周为两节习题课，在习题课的最后，讨论到了这一题，没有讨论出结果。本来有一些思路，恰好看到了这一题，于是将其解决。 3.题目分析及算法 3.1分析 这道题本来解法不难，正常思路有两种，一种是直接讲两...
c语言排序算法的分析和总结,C语言排序算法的分析和总结.doc
weixin_29023079的博客
05-24 297
C语言排序算法的分析和总结摘要:本文具体介绍了C语言当中几种常用的排序方法,并对这些排序方法的基本思想、算法代码、执行过程进行了分析和总结。力求使初学者对于C语言当中遇到的排序问题有个比较清晰的了解。关键词:冒泡排序;选择排序;直接插入排序;shell排序;快速排序;堆排序中图分类号: TP312文献标识码:A文章编号:1009-3044(2010)18-5041-03Summarization ...
（算法设计技巧与分析）MergeSort
lonely_Quan的专栏
03-10 718
#include #include using namespace std; void merge(int a[],int first,int mid,int end); void mergeSort(int a[],int low,int high); int main() { int a[11]; srand((unsigned int(time(NULL))));//导入时间种子加每次运
【面向过程语言系列】算法分析（C语言描述）
Allen-Moore的博客
10-27 296
如何进行算法分析
数据结构1
weixin_44900096的博客
09-02 317
数据结构1（简介）1.什么是数据结构？1.1 数据结构的定义1.2 逻辑结构类型1.3 存储结构类型2.算法2.1 什么是算法？2.2 算法的五个基本特征2.3 算法设计的要求 1.什么是数据结构？ 数据结构主要学习用计算机实现数据组织和数据处理的方法；随着计算机应用领域的不断扩大，无论设计系统软件还是应用软件都会用到各种复杂的数据结构。 1.1 数据结构的定义 数据结构： 是指数据以及相互之间的联系，可以看做是相互之间存在某种特定关系的数据元素的集合，因此可以把数据结构看成是带结构的数据元素的集合。 1.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不要做码农呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值