排序代码总结

最新推荐文章于 2021-08-22 17:18:52 发布
最新推荐文章于 2021-08-22 17:18:52 发布
阅读量98 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37163944/article/details/87865482
版权

冒泡排序：

#include<stdio.h>

void BubbleSort(int arr[],int nLength)
{
    if(arr == NULL || nLength <= 0)return;

    int i;
    int j;
    int nFlag = 0;
    int nCount = 0;
    for(i = 0;i<nLength;i++)
    {
        nFlag = 0;
        for(j = 0;j<nLength-1-i;j++)
        {
            if(arr[j] > arr[j+1])
            {
                //交换
                arr[j] = arr[j]^arr[j+1];
                arr[j+1] = arr[j]^arr[j+1];
                arr[j] = arr[j]^arr[j+1];

                nFlag = j+1;
            }
            nCount++;
        }

        if(nFlag == 0)
        {
            break;
        }

        i = nLength-nFlag-1;
    }
    printf("%d\n",nCount);
}

int main()
{
    int arr[] = {10,28,1,9,8,29,45,58,70,130};
    BubbleSort(arr,sizeof(arr)/sizeof(arr[0]));

    int i;

    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    return 0;
}
2 选择排序

#include<stdio.h>

void SelectSort(int arr[],int nLength)
{
    if(arr == NULL || nLength <= 0)return;
    
    int i;
    int j;
    int nMin ;
    for(i = 0;i<nLength;i++)
    {
        nMin = i;
        for(j = i+1;j<nLength;j++)
        {
            if(arr[j] < arr[nMin])
            {
                nMin = j;
            }
        }

        //将最小值放入对应位置
        if(nMin != i)
        {
            arr[i] = arr[nMin]^arr[i];
            arr[nMin] = arr[nMin]^arr[i];
            arr[i] = arr[nMin]^arr[i];
        }
    }
}

int main()
{
    int arr[] = {10,28,1,9,8,29,45,58,70,130};
    SelectSort(arr,sizeof(arr)/sizeof(arr[0]));

    int i;

    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    return 0;
}

3 插入排序

#include<stdio.h>

void InsertSort(int arr[],int nLength)
{
    if(arr == NULL || nLength <= 0)return;
    
    int i; //无序的第一个
    int j; //有序的最后一个
    int temp;

    for(i = 1;i<nLength;i++)
    {
        temp = arr[i];

        j = i-1; //有序是无序的前一个

        while(temp < arr[j] && j >= 0)
        {
            arr[j+1] = arr[j];
            j--;
        }

        //元素放入
        arr[j+1] = temp;
    }
}

int main()
{
    int arr[] = {10,28,1,9,8,29,45,58,70,130};
    InsertSort(arr,sizeof(arr)/sizeof(arr[0]));

    int i;

    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    return 0;
}
4 计数排序

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

void CountSort(int arr[],int nLength)
{
    if(arr == NULL || nLength <= 0)return;
    
    //找最大值 最小值
    int nMax;
    int nMin;
    nMin = arr[0];
    nMax = arr[0];

    int i;
    for(i = 1;i<nLength;i++)
    {
        if(arr[i] < nMin)
        {
            nMin = arr[i];
        }
        if(arr[i] > nMax)
        {
            nMax = arr[i];
        }
    }

    //申请计数数组
    int *pCount = NULL;
    pCount = (int*)malloc(sizeof(int)*(nMax-nMin+1));
    memset(pCount,0,sizeof(int)*(nMax-nMin+1));

    //计数
    for(i = 0;i<nLength;i++)
    {
        pCount[arr[i]-nMin]++;
    }

    //排序
    int j = 0;
    for(i = 0;i<nMax-nMin+1;i++)
    {
        while(pCount[i] != 0)
        {
            arr[j] = i+nMin;
            j++;
            pCount[i]--;
        }
    }

    //释放
    free(pCount);
    pCount = NULL;
}

int main()
{
    int arr[] = {10,28,10,9,8,9,4,28,7,10};
    CountSort(arr,sizeof(arr)/sizeof(arr[0]));

    int i;

    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    return 0;
}
5 快排

#include<stdio.h>

int Sort(int arr[],int nLow,int nHigh)
{
    int temp ;
    temp = arr[nLow];
    
    while(nLow < nHigh)
    {

        //从后向前找比标准值小的
        while(nHigh > nLow)
        {
            if(arr[nHigh] < temp)
            {
                //放前面
                arr[nLow] = arr[nHigh];
                nLow++;
                break;
            }

            nHigh--;
        }

        //从前向后找比标准值大的
        while(nLow < nHigh)
        {
            if(arr[nLow] > temp)
            {
                //放后面
                arr[nHigh] = arr[nLow];
                nHigh--;
                break;
            }
            nLow++;
        }
    }

    //标准值放入
    arr[nLow] = temp;
    return nLow;
}

int Sort2(int arr[],int nLow,int nHigh)
{
    int nSmall;
    nSmall = nLow-1;

    for(nLow;nLow<nHigh;nLow++)
    {
        if(arr[nLow] < arr[nHigh])
        {
            //小区间扩张
            if(++nSmall != nLow)
            {
                arr[nSmall] = arr[nSmall]^arr[nLow];
                arr[nLow] = arr[nSmall]^arr[nLow];
                arr[nSmall] = arr[nSmall]^arr[nLow];
            }
        }
    }

    //标准值放入
    if(++nSmall != nHigh)
    {
        arr[nSmall] = arr[nSmall]^arr[nHigh];
        arr[nHigh] = arr[nSmall]^arr[nHigh];
        arr[nSmall] = arr[nSmall]^arr[nHigh];
    }

    return nSmall;
}
void QuickSort(int arr[],int nLow,int nHigh)
{
    if(arr == NULL || nLow >= nHigh)return;

    int nStandard;

    //找到标准值位置
    nStandard = Sort2(arr,nLow,nHigh);

    //根据标准值将数组分两部分
    //两部分分别执行以上操作
    QuickSort(arr,nLow,nStandard-1);
    QuickSort(arr,nStandard+1,nHigh);
}

int main()
{
    int arr[] = {10,28,1,9,8,29,45,58,70,130};
    QuickSort(arr,0,sizeof(arr)/sizeof(arr[0])-1);

    int i;

    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    return 0;
}

6 希尔排序

#include<stdio.h>

void ShellSort(int arr[],int nLength)
{
    if(arr == NULL || nLength <= 0)return;
    
    int nGap;
    int i; //组
    int j;
    int k;
    int temp;

    //间隔
    for(nGap = nLength/2;nGap>=1;nGap/=2)
    {
        //组
        for(i = 0;i<nGap;i++)
        {
            //各组之内插入排序
            for(j = i+nGap;j<nLength;j+=nGap)
            {
                k = j-nGap;//有序的最后一个
                temp = arr[j]; //无序的第一个
                while(temp < arr[k] && k >= i)
                {
                    arr[k+nGap] = arr[k];
                    k-=nGap;
                }

                arr[nGap+k] = temp;
            }
        }
    }
}

int main()
{
    int arr[] = {10,28,1,9,8,29,45,58,70,130};
    ShellSort(arr,sizeof(arr)/sizeof(arr[0]));

    int i;

    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    return 0;
}

7 归并排序

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

void Merge(int arr[],int nLow,int nHigh)
{
    int nBegin1;
    int nBegin2;
    int nEnd1;
    int nEnd2;


    nBegin1 = nLow;
    nEnd1 = nLow+(nHigh-nLow)/2;
    nBegin2 = nEnd1+1;
    nEnd2 = nHigh;

    int *pTemp = NULL;
    pTemp = (int*)malloc(sizeof(int)*(nHigh-nLow+1));

    int i = 0;

    while(nBegin1 <= nEnd1 && nBegin2 <= nEnd2)
    {
        if(arr[nBegin1] < arr[nBegin2])
        {
            pTemp[i] = arr[nBegin1];
            i++;
            nBegin1++;
        }
        else
        {
            pTemp[i] = arr[nBegin2];
            i++;
            nBegin2++;
        }
    }

    //有剩余的数组元素放入辅助空间
    while(nBegin2 <= nEnd2)
    {
        pTemp[i] = arr[nBegin2];
        i++;
        nBegin2++;
    }

    while(nBegin1 <= nEnd1)
    {
        pTemp[i] = arr[nBegin1];
        i++;
        nBegin1++;
    }

    //元素放回原数组
    for(i = 0;i<nHigh-nLow+1;i++)
    {
        arr[nLow+i] = pTemp[i];
    }

    //释放
    free(pTemp);
    pTemp = NULL;
}

void MergeSort(int arr[],int nLow,int nHigh)
{
    if(arr == NULL || nLow >= nHigh)return;
    
    int nMid;
    nMid = nLow+(nHigh-nLow)/2;

    //拆分
    MergeSort(arr,nLow,nMid);
    MergeSort(arr,nMid+1,nHigh);

    //合并
    Merge(arr,nLow,nHigh);

}

int main()
{
    int arr[] = {10,28,1,9,8,29,45,58,70,130};
    MergeSort(arr,0,sizeof(arr)/sizeof(arr[0])-1);

    int i;

    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    return 0;
}

8 堆排序

#include<stdio.h>

#define LEFT 2*nRootID+1
#define RIGHT 2*nRootID+2

void Adjust(int arr[],int nLength,int nRootID)
{
    while(1)
    {
        //两个孩子
        if(RIGHT < nLength)
        {
            //两个里找大的
            if(arr[LEFT]>arr[RIGHT])
            {
                //大的和父亲比
                if(arr[LEFT] > arr[nRootID])
                {
                    arr[LEFT] = arr[LEFT]^arr[nRootID];
                    arr[nRootID] = arr[LEFT]^arr[nRootID];
                    arr[LEFT] = arr[LEFT]^arr[nRootID];

                    nRootID = LEFT;
                    continue;
                }
                else
                {
                    break;
                }
            }
            else
            {
                //大的和父亲比
                if(arr[RIGHT] > arr[nRootID])
                {
                    arr[RIGHT] = arr[RIGHT]^arr[nRootID];
                    arr[nRootID] = arr[RIGHT]^arr[nRootID];
                    arr[RIGHT] = arr[RIGHT]^arr[nRootID];

                    nRootID = RIGHT;
                    continue;
                }
                else
                {
                    break;
                }
            }
        }
        //一个孩子
        else if(LEFT < nLength)
        {
            //大的和父亲比
            if(arr[LEFT] > arr[nRootID])
            {
                arr[LEFT] = arr[LEFT]^arr[nRootID];
                arr[nRootID] = arr[LEFT]^arr[nRootID];
                arr[LEFT] = arr[LEFT]^arr[nRootID];

                nRootID = LEFT;
                continue;
            }
            else
            {
                break;
            }
        }
        //没有孩子
        else
        {
            break;
        }
    }
}


void Adjust2(int arr[],int nLength,int nRootID)
{
    int MAX;

    for(MAX = LEFT;MAX < nLength; MAX = LEFT)
    {
        //两个孩子
        if(RIGHT < nLength)
        {
            if(arr[MAX] < arr[RIGHT])
            {
                MAX = RIGHT;
            }
        }

        //大的和父亲比
        if(arr[MAX] > arr[nRootID])
        {
            arr[MAX] = arr[nRootID]^arr[MAX];
            arr[nRootID] = arr[nRootID]^arr[MAX];
            arr[MAX] = arr[nRootID]^arr[MAX];

            nRootID = MAX;
        }
        else
        {
            break;
        }
    }
}

void HeapSort(int arr[],int nLength)
{
    if(arr == NULL || nLength <= 0)return;

    //建堆
    int i;
    for(i = nLength/2-1;i>=0;i--)
    {
        //调整父亲节点
        Adjust2(arr,nLength,i);
    }

    //排序
    for(i = nLength-1;i>0;i--)
    {
        arr[0] = arr[0]^arr[i];
        arr[i] = arr[0]^arr[i];
        arr[0] = arr[0]^arr[i];
        
        Adjust2(arr,i,0);
    }
}
int main()
{
    int arr[] = {10,28,98,27,19,30,66,0,27,1,8};
    HeapSort(arr,sizeof(arr)/sizeof(arr[0]));

    int i;
    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    return 0;
}

9  桶排

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

typedef struct node
{
    int nValue;
    struct node *pNext;
    struct node *pPre;
}Bucket;


void Sort(Bucket *pHead)
{
    if(pHead == NULL  || pHead->pNext == NULL)return;

    //插入
    Bucket *pSort = NULL;
    Bucket *pUnSort = NULL;
    int temp;

    pUnSort = pHead->pNext;

    while(pUnSort != NULL)
    {
        pSort = pUnSort->pPre; //有序的最后一个
        temp = pUnSort->nValue;//无序第一个

        while(pSort != NULL && pSort->nValue > temp)
        {
            pSort->pNext->nValue = pSort->nValue;
            pSort = pSort->pPre;
        }

        //值放入
        if(pSort == NULL)
        {
            pHead->nValue = temp;
        }
        else
        {
            pSort->pNext->nValue = temp;
        }

        pUnSort = pUnSort->pNext;
    }
}

void BucketSort(int arr[],int nLength)
{
    if(arr == NULL || nLength <= 0)return;
    
    //找最大值最小值
    int i;
    int nMin;
    int nMax;
    nMin = arr[0];
    nMax = arr[0];

    for(i = 1;i<nLength;i++)
    {
        if(arr[i] < nMin)
        {
            nMin = arr[i];
        }

        if(arr[i] > nMax)
        {
            nMax = arr[i];
        }
    }

    //拆位
    int nNum = nMin;
    int nCount = 1;

    while(nNum)
    {
        nNum/=10;
        nCount*=10;
    }
    
    nCount/=10;

    int nMinIndex;
    int nMaxIndex;

    nMinIndex = nMin/nCount;
    nMaxIndex = nMax/nCount;

    //申请桶
    Bucket **pBucket = NULL;
    pBucket = (Bucket**)malloc(sizeof(Bucket*)*(nMaxIndex-nMinIndex+1));
    memset(pBucket,0,sizeof(Bucket*)*(nMaxIndex-nMinIndex+1));

    //元素入桶
    Bucket *pTemp = NULL;
    for(i = 0;i<nLength;i++)
    {
        nNum = arr[i]/nCount-nMinIndex;

        pTemp = (Bucket*)malloc(sizeof(Bucket));
        pTemp->nValue = arr[i];

        pTemp->pNext = pBucket[nNum];
        pTemp->pPre = NULL;

        if(pBucket[nNum] != NULL)
        {
            pBucket[nNum]->pPre = pTemp;
        }

        pBucket[nNum] = pTemp;
    }

    //各桶之内排序
    for(i = 0;i<nMaxIndex-nMinIndex+1;i++)
    {
        Sort(pBucket[i]);
    }

    //桶内元素放回原数组
    nNum = 0;
    for(i = 0;i<nMaxIndex-nMinIndex+1;i++)
    {
        pTemp = pBucket[i];

        while(pTemp)
        {
            arr[nNum] = pTemp->nValue;
            nNum++;
            pTemp = pTemp->pNext;
        }
    }

    //释放
    Bucket *pDel = NULL;
    for(i = 0;i<nMaxIndex-nMinIndex+1;i++)
    {
        pTemp = pBucket[i];
        while(pTemp)
        {
            pDel = pTemp;
            pTemp = pTemp->pNext;
            free(pDel);
            pDel = NULL;
        }
    }


    free(pBucket);
    pBucket = NULL;
}

int main()
{
    int arr[] = {1099,2208,1981,2879,3458,5629,1345,8958,2870,4130};
    BucketSort(arr,sizeof(arr)/sizeof(arr[0]));

    int i;

    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    return 0;
}

10  基数排序

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

typedef struct node
{
    int nValue;
    struct node *pNext;
}Radix;

void Sort(int arr[],int nLength,Radix **pRadix,int nBegin)
{
    //基数
    int nBase = 1;

    while(nBegin > 1)
    {
        nBase*=10;
        nBegin--;
    }

    //入桶
    int nIndex;
    int i;
    Radix *pTemp = NULL;
    Radix *pNode = NULL;
    for(i = 0;i<nLength;i++)
    {
        nIndex = arr[i]/nBase%10;
        
        pTemp = (Radix*)malloc(sizeof(Radix));
        pTemp->nValue = arr[i];
        pTemp->pNext = NULL;
        
        //尾添加
        if(pRadix[nIndex] == NULL)
        {
            pRadix[nIndex] = pTemp;
        }
        else
        {
            pNode = pRadix[nIndex];
            while(pNode->pNext != NULL)
            {
                pNode = pNode->pNext;
            }

            pNode->pNext = pTemp;
        }
    }

    //数据放回原数组
    nBegin = 0;
    for(i = 0;i<10;i++)
    {
        pNode = pRadix[i];
        while(pNode)
        {
            arr[nBegin] = pNode->nValue;
            nBegin++;
            pNode = pNode->pNext;
        }
    }

    //空间释放
    for(i = 0;i<10;i++)
    {
        pTemp = pRadix[i];
        while(pTemp)
        {
            pNode = pTemp;
            pTemp = pTemp->pNext;
            free(pNode);
            pNode = NULL;
        }
    }
    
    //清空表头
    memset(pRadix,0,sizeof(Radix*)*10);
}

void RadixSort(int arr[],int nLength)
{
    if(arr == NULL || nLength <= 0)return;
    
    //找最大值
    int i;
    int nMax;
    nMax = arr[0];

    for(i = 1;i<nLength;i++)
    {
        if(arr[i] > nMax)
        {
            nMax = arr[i];
        }
    }

    //拆位
    int nNum = nMax;
    int nCount = 0;

    while(nNum)
    {
        nNum/=10;
        nCount++;
    }

    //申请桶
    Radix **pRadix = NULL;
    pRadix = (Radix**)malloc(sizeof(Radix*)*10);
    memset(pRadix,0,sizeof(Radix*)*10);

    //按位入桶
    for(i = 1;i<= nCount;i++)
    {
        Sort(arr,nLength,pRadix,i);
    }

    free(pRadix);
    pRadix = NULL;
}

int main()
{
    int arr[] = {19,208,81,9,38,529,145,858,270,30};
    RadixSort(arr,sizeof(arr)/sizeof(arr[0]));

    int i;

    for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
    {
        printf("%d ",arr[i]);
    }
    printf("\n");
    return 0;
}
 

 

 

 

 

 

 

 

啦啦leilei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
冒泡排序总结
qq_41825377的博客
08-05 2085
冒泡排序总结算法思想：图片演示代码冒泡排序常规版：冒泡排序优化第一版冒泡排序优化第二版 算法思想： 冒泡排序是一种交换排序。 交换排序就是通过元素按照要求进行两两比较，判断是否符合要求，假如不符合要求就将两个元素交换位置来达到排序的目的。 冒泡排序名字的由来就是因为在交换过程中，类似水冒泡，小（大）的元素经过不断的比较交换由水底慢慢的浮到水的顶端。 冒泡排序的思想就是利用的比较交换，利用循环将第 i 小或者大的元素归位，归位操作利用的是对 n 个元素中相邻的两个进行比较，如果顺序正确就不交换，如果顺序错误就
伪代码计算机流程图排序数组,排序伪代码总结
weixin_33834241的博客
07-26 3221
目录一.选择排序时间复杂度为Θ(n²)算法输入：n个元素的数组A[1…n]输出：按非降序排列的数组A[1…n]for i←1 to n-1k←i //设立标志位for j←i+1 to n //查找第i小的元素if A[j]end forif k≠i then 交换A[i]与A[k]end for操作方法：首先找到最小元素，将其存放在A[1]中，然后找到剩下的n-1个元...
七种排序总结及代码实现
jackcsdnfghdtrjy的博客
03-19 117
版权声明：本文为博主原创文章，未经博主允许，欢迎随意转载，标好作者+原文地址就可以了！感谢欣赏！觉得好请回个贴！ 笔记： #include <stdio.h> //几种常见的排序与查找算法 // ONE 直接插入排序 //直接插入排序的核心思想就是：将数组中的所有元素依次跟前面已经排好的元素相比较， //如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过。 ...
hongleileilei.github.io
03-17
欢迎来到刘红磊的页面
leeleilei.github.io
02-13
leeleilei.github.io 介绍 这是一个仅包含markdown文件的简单静态站点。 渲染取决于github本身对HTML的减价。 markdown语法遵循Github markdown格式，并且还支持元数据。 每次通过Github Action推送时都会渲染它。 有关详细信息，请参见 。 它不支持文件夹中的嵌套路径。 它是扁平的，可以使用标签来组织您的内容。 要求 Python 3.8 用法 页数 将页面放在./pages中 帖子 将您的帖子放在./posts中 书签 将您的个人书签放在./bookmarks中。 基本上，这是另一个同步的存储库。 “ SAVE”书签API中的特定书签。 将urlitem元数据urlitem元数据”部分中。 关于 将简历和标签放在
【数据结构】排序算法总结及代码实现
如风逝去
07-23 1万+
我们通常说的排序算法指的是内部排序算法，即数据在内存中进行排序。 首先先来看一下我们学过的排序都有什么？ 排序可以大的方面分为比较排序和非比较排序？ 比较排序有： 1、冒泡排序 2、选择排序 3、插入排序 （1）二分插入排序 （2）希尔排序 4、归并排序 5、堆排序 6、快速排序 非比较排序有： 1、计数排序 2、基数排序 3、桶排序 我们先对各种排序进行对比： ...
八大排序算法（C语言实现）
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
10种排序算法总结及c++代码
baicoo的博客
08-22 1844
排序算法总结 1.冒泡排序 冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。 算法描述 比较相邻的元素。如果第一个比第二个大，就交换它们两个； 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数； 针对所有的元素重复以上的步骤，除了最后一个； 重复步骤1~3，直
超详细十大经典排序算法总结（java代码）c或者cpp的也可以明白
热门推荐
Top_Spirit的博客
01-23 22万+
0、排序算法说明 0.1 排序的定义 对一序列对象根据某个关键字进行排序。 0.2 术语说明 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面； 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面； 内排序：所有排序操作都在内存中完成； 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行； 时间复杂度...
排序算法总结
qq_40691562的博客
03-03 2165
排序算法总结 概述： 转眼大三了，总结下排序算法，对以后推免，找工作都十分有益。 先来个排序算法总结，再详细讨论。 一、冒泡排序（Bubble Sort） 第一个就总结学生平时最常用的冒泡排序吧。 1. 基本思想 它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越...
冒泡排序代码总结集合
02-17
以下是一个简单的C语言冒泡排序代码示例： ```c #include void bubbleSort(int arr[], int n) { for (int i = 0; i ; i++) { // 外层循环，遍历n-1次 for (int j = 0; j ; j++) { // 内层循环，每次冒泡过程 ...
bubblesort_冒泡排序matlab代码_
10-03
总结，冒泡排序是一种简单的排序算法，虽然在处理大规模数据时效率较低，但其逻辑清晰，易于理解和实现。在MATLAB中，通过编写`bubblesort.m`这样的函数，我们可以轻松实现对任意数组的冒泡排序。配合可视化工具，...
经典排序总结（附代码）
04-16
经典排序总结（附代码），包含开发过程中遇到的各种常见的排序算法，比较简单，比较适合初学者理解。
js代码-常用排序方法总结
07-15
本资料集“js代码-常用排序方法总结”旨在全面介绍JavaScript中的各种排序算法，帮助开发者更好地理解和运用这些方法。 首先，最基本的排序方法是`Array.prototype.sort()`。这个内置函数可以接受一个比较函数作为...
数据结构与算法：12种排序全代码
qq_42667970的博客
12-13 2601
排序 文章目录排序1.冒泡排序思路：优化：交换过程：C语言代码：优化后：2.直接插入排序思路：过程：代码：3.折半插入排序折半查找代码4.希尔插入排序思路：排序过程：代码5.选择排序思路:排序过程：代码6.鸡尾酒排序法思路:代码7.堆排序思路：代码8.归并排序思路：代码9.快速排序思路：代码10.计数排序思想：代码11.桶排序思路：代码12.基数排序思路过程：代码代码 各种排序算法的时间复杂度和空...
汇编排序算法代码总结
bcbobo21cn的专栏
06-07 6592
1 冒泡排序 http://blog.csdn.net/a123443/article/details/6779137 ;冒泡排序 ;author JRH ;2011.7.10 assume ds:data data segment a dw 1,4,2,5,7,9,6,3 data ends code segment start: mov ax,data mov
基于ssm和vue的 校园短期闲置资源置换平台源码 校园短期闲置资源置换平台代码（高分毕设项目源码）
08-23
1. 校园短期闲置资源置换平台代码说明：经导师指导并认可通过的98分毕设项目代码。 2.适用对象：本代码学习资料适用于计算机、电子信息工程、数学等专业正在做毕设的学生，需要项目实战练习的学习者，也适用于课程设计、期末大作业。 3.技术栈：前端是vue，后端是ssm，项目代码都经过严格调试，代码没有任何bug！ 4. 作者介绍：大厂码农，java领域创作者，阿里云开发社区乘风者计划专家博主，专注于大学生项目实战开发，文章底部有博主联系方式，更多优质系统、项目定制请私信。 5. 最新计算机软件毕业设计选题大全: https://blog.csdn.net/weixin_45630258/article/details/135901374
4S店客户管理小程序-毕业设计，基于微信小程序+SSM+MySql开发，源码+数据库+论文答辩+毕业论文+视频演示
08-23
4S店客户管理小程序-毕业设计，基于微信小程序+SSM+MySql开发，源码+数据库+论文答辩+毕业论文+视频演示 社会的发展和科学技术的进步，互联网技术越来越受欢迎。手机也逐渐受到广大人民群众的喜爱，也逐渐进入了每个用户的使用。手机具有便利性，速度快，效率高，成本低等优点。 因此，构建符合自己要求的操作系统是非常有意义的。 本文从管理员、用户的功能要求出发，4S店客户管理系统中的功能模块主要是实现管理员服务端；首页、个人中心、用户管理、门店管理、车展管理、汽车品牌管理、新闻头条管理、预约试驾管理、我的收藏管理、系统管理，用户客户端：首页、车展、新闻头条、我的。门店客户端：首页、车展、新闻头条、我的经过认真细致的研究，精心准备和规划，最后测试成功，系统可以正常使用。分析功能调整与4S店客户管理系统实现的实际需求相结合，讨论了微信开发者技术与后台结合java语言和MySQL数据库开发4S店客户管理系统的使用。 关键字：4S店客户管理系统小程序 微信开发者 Java技术 MySQL数据库 软件的功能： 1、开发实现4S店客户管理系统的整个系统程序； 2、管理员服务端；首页、个人中心、用户管理、门店管理、车展管理、汽车品牌管理、新闻头条管理、预约试驾管理、我的收藏管理、系统管理等。 3、用户客户端：首页、车展、新闻头条、我的 4、门店客户端：首页、车展、新闻头条、我的等相应操作； 5、基础数据管理：实现系统基本信息的添加、修改及删除等操作，并且根据需求进行交流信息的查看及回复相应操作。
Java项目：基于SSM框架+mysql个性化美食推荐系统含源码和毕业论文
最新发布
08-23
一、项目简介 本项目是一套基于SSM框架+mysql个性化美食推荐系统含源码和毕业论文 包含：项目源码、数据库脚本等，该项目附带全部源码可作为毕设使用。 项目都经过严格调试，eclipse或者idea 确保可以运行！ 该系统功能完善、界面美观、操作简单、功能齐全、管理便捷，具有很高的实际应用价值 二、技术实现 jdk版本：1.8 及以上 ide工具：IDEA或者eclipse 数据库: mysql5.5及以上 后端：spring+springmvc+mybatis+maven+mysql 前端：jsp，css，js 三、系统功能 1、系统角色主要包括：管理员、用户 2、系统功能 主要功能包括： 用户登录 用户注册 首页 个人中心 修改密码 管理员信息 用户管理 美食信息管理 美食信息留言管理 美食信息收藏管理 美食订单管理 博主推荐管理 店址管理 口味管理 轮播图管理 前台主要功能包括： 用户登录 用户注册 首页 个性美食展示 热门美食推荐 美食详情 点我收藏 立即预订 个人中心 美食收藏 美食订单 余额充值 发表留言 博主推荐 跳转到后台等功能
C语言实现查找与排序算法总结
实验步骤涉及了定义数据结构、编写实现这些算法的C语言代码，并通过实际运行来验证算法的正确性和效率。实验结果部分可能包括运行时间、比较次数等指标，帮助学生理解算法的实际表现。 这篇文档不仅提供了理论知识...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值