冒泡排序、快速排序等常用排序算法

最新推荐文章于 2024-02-03 18:51:33 发布
最新推荐文章于 2024-02-03 18:51:33 发布
阅读量771 收藏 3
点赞数
分类专栏： C++ 算法 文章标签： 排序算法 冒泡排序 归并排序 插入排序 快速排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lining0420/article/details/71598713
版权
C++ 同时被 2 个专栏收录
18 篇文章 0 订阅
订阅专栏
算法
2 篇文章 0 订阅
订阅专栏

常用排序算法
排序算法大体可分为两种：
第一种：比较排序
主要有冒泡排序、选择排序、插入排序、归并排序、堆排序、快速排序等。
第二种：非比较排序
主要有计数排序、基数排序、桶排序等。

常见排序算法的性能如下：
这里写图片描述

1：冒泡排序
通过与相邻元素的比较和交换来把小的数交换到最前面。一次遍历把最小(或最大)的数放到最顶端，再对剩下的序列依次冒泡得到一个有序序列。
冒泡排序的时间复杂度是O(n^2)，所需辅助空间0(1);
对数量比较多的元素进行排序时，效率低下。

代码如下：
BubbleSort.cpp文件

#include <stdio.h>

class CBubbleSort{
public:
    void Swap(int* pArr, int i, int j)
    {
        int temp = pArr[i];
        pArr[i] = pArr[j];
        pArr[j] = temp;

    }
    void Sort(int* pArr, int length)
    {
        if (pArr == NULL || length == 0)
            return;

        int nIndex = 0;
        for (int i = 0; i < length; i++)
        {
            for (int j = 0; j < length - i - 1; j ++)
            {
                if (pArr[j] > pArr[j + 1])
                    Swap(pArr, j, j+1);
            }

        }
        return;
    }
};

main.cpp文件

#include <iostream>
#include <stdio.h>
#include "BubbleSort.cpp"
using namespace std;


void main()
{

    int test[]={5,6,8,3,6,11,33,7};
    int count = sizeof(test) / sizeof(int);
    CBubbleSort*  pSort = new CBubbleSort();
    if (pSort == NULL)
        return;
    pSort->Sort(&test[0], count);
    delete pSort;
    pSort = NULL;

    cout << "After sort :" << endl;
    for (int i = 0; i < count; i++)
    {
        cout << test[i] << "  "; 
    }
    cout << endl;
    system("pause");
}

运行结果如下：
这里写图片描述

2：改进的冒泡排序
比冒泡排序的改进之处是，从低到高排序，然后从高到底排序。
改进的冒泡排序的时间复杂度是O(n^2)，所需辅助空间0(1);
比冒泡排序效率稍微高点。
代码如下：
BubbleSort2.cpp文件

#include <stdio.h>

class CBubbleSort_new{
public:
    void Swap(int* pArr, int i, int j)
    {
        int temp = pArr[i];
        pArr[i] = pArr[j];
        pArr[j] = temp;
    }

    void Sort(int* pArr, int length)
    {
        if (pArr == NULL || length == 0)
            return;

        int begin = 0;
        int end = length - 1;

        while(begin < end)
        {
            //  将最大的元素放到后面
            for (int i = begin; i < end; i++)
            {
                if (pArr[i] > pArr[i + 1])
                    Swap(pArr, i, i + 1);
            }
            end--;

            //  将最小的元素放到前面
            for (int i = end; i > begin; i--)
            {
                if (pArr[i] < pArr[i - 1])
                    Swap(pArr, i, i - 1);
            }
            begin++;
        }
    }
};

main.cpp文件

#include <iostream>
#include <stdio.h>
#include "BubbleSort2.cpp"
using namespace std;

void main()
{

    int test[]={5,6,8,3,6,11,33,7};
    int count = sizeof(test) / sizeof(int);
    CBubbleSort_new*  pSort = new CBubbleSort_new();
    if (pSort == NULL)
        return;
    pSort->Sort(&test[0], count);
    delete pSort;
    pSort = NULL;

    cout << "After sort :" << endl;
    for (int i = 0; i < count; i++)
    {
        cout << test[i] << "  "; 
    }
    cout << endl;
    system("pause");
}

运行结果如下：
这里写图片描述

3：选择排序
在未排序序列中找到最小（大）的元素，存放到有序序列的末尾；再从剩余未排序的元素中继续寻找最小（大）的元素，存放到有序序列的末尾；依次类推，直到所有的元素均排序完毕。
时间复杂度o(n^2)，空间复杂度o(1)。

代码如下：
SelectSort.cpp文件

#include <stdio.h>

class CSelectSort{
public:
    void Swap(int* pArr, int i, int j)
    {
        int temp = pArr[i];
        pArr[i] = pArr[j];
        pArr[j] = temp;

    }

    void Sort(int* pArr, int length)
    {
        if (pArr == NULL || length == 0)
            return;

        for (int i = 0; i < length; i++)
        {
            int nMinIdx = i;
            for (int j = i + 1; j < length; j++)
            {
                if (pArr[j] < pArr[nMinIdx])
                    nMinIdx = j;
            }
            if (nMinIdx != i)
                Swap(pArr, nMinIdx, i );

        }

    }

};

main.cpp文件

#include <iostream>
#include <stdio.h>"
#include "SelectSort.cpp"
using namespace std;

void main()
{

    int test[]={5,6,8,3,6,11,33,7};
    int count = sizeof(test) / sizeof(int);
    CSelectSort*  pSort = new CSelectSort();
    if (pSort == NULL)
        return;
    pSort->Sort(&test[0], count);
    delete pSort;
    pSort = NULL;

    cout << "After sort :" << endl;
    for (int i = 0; i < count; i++)
    {
        cout << test[i] << "  "; 
    }
    cout << endl;
    system("pause");
}

运行结果如下：
**这里写图片描述**

4：插入排序
从未排序的序列中选择一个新元素，在已排序的序列中从后向前扫描，知道找到比小于或等于新元素的元素，并将新元素插入到找到的元素的后面，对其后面的元素依次后移。
时间复杂度 o(n^2)，空间复杂度o(1)；

代码如下：
InsertSort.cpp文件

#include <stdio.h>

class CInsertSort{
public:
    void Sort(int* pArr, int length)
    {
        if (pArr == NULL || length == 0)
            return;

        for (int i = 1; i < length; i++)
        {
            int temp = pArr[i];
            int j = i;
            while(j >= 1 && pArr[j - 1] > temp)
            {
                pArr[j] = pArr[j - 1];
                j--;
            }
            pArr[j] = temp;
        }
    }
};

main.cpp文件

#include <iostream>
#include <stdio.h>
#include "InsertSort.cpp"
using namespace std;

void main()
{

    int test[]={5,6,8,3,6,11,33,7};
    int count = sizeof(test) / sizeof(int);
    CInsertSort*  pSort = new CInsertSort();
    if (pSort == NULL)
        return;
    pSort->Sort(&test[0], count);
    delete pSort;
    pSort = NULL;

    cout << "After sort :" << endl;
    for (int i = 0; i < count; i++)
    {
        cout << test[i] << "  "; 
    }
    cout << endl;
    system("pause");
}

运行结果如下：
**这里写图片描述**

5：二分插入排序
是插入排序的改进。可以减少比较操作的次数。
时间复杂度o(n^2)，空间复杂度o(1)。

代码如下：
BinInsertSort.cpp文件

#include <stdio.h>

class CBinInsertSort{
public:
    void Sort(int* pArr, int length)
    {
        if (pArr == NULL || length == 0)
            return;

        for (int i = 1; i < length; i++)
        {
            int nTemp = pArr[i];
            int nLeft = 0;
            int nRight = i - 1;

            while (nLeft <= nRight)
            {
                int nMiddle = (nLeft + nRight) / 2;
                if (pArr[nMiddle] > nTemp)
                    nRight = nMiddle - 1;
                else
                    nLeft = nMiddle + 1;
            }

            for (int j = i; j > nLeft; j--)
                pArr[j] = pArr[j - 1];

            if (nLeft != i)
                pArr[nLeft] = nTemp;
        }
    }

};

main.cpp文件

#include <iostream>
#include <stdio.h>
#include "BinInsertSort.cpp"
using namespace std;

void main()
{

    int test[]={5,6,8,3,6,11,33,7};
    int count = sizeof(test) / sizeof(int);
    CBinInsertSort*  pSort = new CBinInsertSort();
    if (pSort == NULL)
        return;
    pSort->Sort(&test[0], count);
    delete pSort;
    pSort = NULL;

    cout << "After sort :" << endl;
    for (int i = 0; i < count; i++)
    {
        cout << test[i] << "  "; 
    }
    cout << endl;
    system("pause");
}

运行结果如下：
**这里写图片描述**

6：希尔排序
也叫递减增量排序。插入排序的更高效的改进。
希尔排序是基于插入排序的以下两点性质而提出改进方法的：
插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位
希尔排序通过将比较的全部元素分为几个区域来提升插入排序的性能。这样可以让一个元素可以一次性地朝最终位置前进一大步。然后算法再取越来越小的步长进行排序，算法的最后一步就是普通的插入排序，但是到了这步，需排序的数据几乎是已排好的了（此时插入排序较快）。
　最优时间复杂度是o(n)，平均时间复杂度根据步长序列的不同而不同，空间复杂度是o(1)。

代码如下：
ShellSort.cpp文件

#include <stdio.h>

class CShellSort{
public:
    void Sort(int* pArr, int length)
    {
        if (pArr == NULL || length == 0)
            return;

        int nInterval = 0;
        while (nInterval < length)
        {
            nInterval = nInterval * 3 + 1;
        }

        while (nInterval >= 1)
        {
            for (int i = 0; i < length; i++)
            {
                int j = i - nInterval;
                int nTemp = pArr[i];
                while ( j >= 0 && pArr[j] > nTemp)
                {
                    pArr[j + nInterval] = pArr[j];
                    j = j - nInterval;
                }
                pArr[j + nInterval] = nTemp;
            }
            nInterval = (nInterval - 1) / 3;
        }

    }
};

main.cpp文件

#include <iostream>
#include <stdio.h>
#include "ShellSort.cpp"
using namespace std;

void main()
{

    int test[]={5,6,8,3,6,11,33,7,24,66,9,35,85,11,22};
    int count = sizeof(test) / sizeof(int);
    CShellSort*  pSort = new CShellSort();
    if (pSort == NULL)
        return;
    pSort->Sort(&test[0], count);
    delete pSort;
    pSort = NULL;

    cout << "After sort :" << endl;
    for (int i = 0; i < count; i++)
    {
        cout << test[i] << "  "; 
    }
    cout << endl;
    system("pause");
}

运行结果如下：
这里写图片描述

7：归并排序
归并排序是建立在归并操作上的一种有效的排序算法，该算法采用分治法的经典应用。
将已有序的子序列合并，得到完全有序的序列，即先使每个子序列有序，再使子序列段间有序。
基本思路：
1：“分解”—将序列每次折半划分。
2：“合并”—将划分后的序列段两两合并后排序。

基本步骤：

1：将数组平分为两个子数组。
2：递归调用划分数组函数，最后每个数组只有一个元素，即为有序的数组。
3：调用排序函数，把两个有序的数组合并成一个有序的数组。

时间复杂度是o(nlogn)，空间复杂度是o(n)
代码如下：
MergeSort.cpp文件

#include <stdio.h>

class CMergerSort{
public:
    void Sort(int* pArr, int length)
    {
        if (pArr == NULL || length == 0)
            return;

        int* pTemp = new int[length];
        if (pTemp == NULL)
            return;
        MergeSort(pArr, 0, length - 1, pTemp);
        delete[] pTemp;
        pTemp = NULL;
    }

    void MergeSort(int* pArr, int nStart, int nEnd, int* pTemp)
    {
        if (nStart >= nEnd)
            return;
        int nMiddle = (nStart + nEnd) / 2;

        MergeSort(pArr, nStart, nMiddle, pTemp);        //  递归划分左边的数组
        MergeSort(pArr, nMiddle + 1, nEnd, pTemp);      //  递归划分右边的数组
        Merge(pArr, nStart, nMiddle, nEnd, pTemp);      //  将有序的两个序列合并成一个
    }

    void Merge(int* pArr, int nStart, int nMiddle, int nEnd, int* pTemp)
    {
        int nFirst = nStart;
        int nSecond = nMiddle + 1;
        int nIndex = nStart;    

        if (nFirst <= nMiddle && nSecond <= nEnd)
        {
            if (pArr[nFirst] >= pArr[nSecond])
                pTemp[nIndex++] = pArr[nSecond++];
            else
                pTemp[nIndex++] = pArr[nFirst++];
        }

        while (nFirst <= nMiddle) pTemp[nIndex++] = pArr[nFirst++];
        while (nSecond <= nEnd) pTemp[nIndex++] = pArr[nSecond++];

        for (int i = nStart; i <= nEnd; i++)
            pArr[i] = pTemp[i];
    }
};

main.cpp文件

#include <iostream>
#include <stdio.h>
#include "MergeSort.cpp"
using namespace std;

void main()
{

    int test[]={5,6,8,3,6,11,33,7,24,66,9,35,85,11,22};
    int count = sizeof(test) / sizeof(int);
    CMergerSort*  pSort = new CMergerSort();
    if (pSort == NULL)
        return;
    pSort->Sort(&test[0], count);
    delete pSort;
    pSort = NULL;

    cout << "After sort :" << endl;
    for (int i = 0; i < count; i++)
    {
        cout << test[i] << "  "; 
    }
    cout << endl;
    system("pause");
}

运行结果如下：
这里写图片描述

9：快速排序
基本思路是使用分治法策略，确定一个基准元素，把一个序列分为两个子序列，小于基准的元素放在前面的序列，大于基准的元素放在后面的序列，递归进行此操作直到序列的大小是0或1。
时间复杂度是o(nlogn)，空间复杂度一般是o(logn)。

代码如下：
QuickSort.cpp文件

//  使用分治法实现快速排序
#include <stdio.h>

class CQuickSort{
public:
    void Swap(int* pArr, int i, int j)
    {
        int temp = pArr[i];
        pArr[i] = pArr[j];
        pArr[j] = temp;

    }
    void Sort(int* pArr, int length)
    {
        if (pArr == NULL || length == 0)
            return;

        QuickSort(pArr, 0, length - 1);
    }

    void QuickSort(int* pArr, int left, int right)
    {
        int nIdx;
        if (left < right)
        {
            nIdx = Partition(pArr, left, right);
            QuickSort(pArr, left, nIdx - 1);
            QuickSort(pArr, nIdx + 1, right);
        }

    }

    int Partition(int* pArr, int left, int right)   //  划分函数
    {
        int nIdx = left - 1;
        int nTemp = pArr[right];            //  选择最后一个元素作为基准

        for (int i = left; i < right; i++)
        {
            if (pArr[i] <= nTemp)           //  把小于基准的元素放在前面子数组
            {
                nIdx++;
                Swap(pArr, nIdx, i);
            }
        }

        int nFindIdx = nIdx + 1;
        Swap(pArr, nFindIdx, right);        //  将基准放在前面子数组的后面，剩下的就是大于基准的元素
        return nFindIdx;                    //  返回基准的索引
    }
};

main.cpp文件

#include <iostream>
#include <stdio.h>
#include "QuickSort.cpp"
using namespace std;

void main()
{

    int test[]={5,6,8,3,6,11,33,7,24,66,9,35,85,11,22};
    int count = sizeof(test) / sizeof(int);
    CQuickSort*  pSort = new CQuickSort();
    if (pSort == NULL)
        return;
    pSort->Sort(&test[0], count);
    delete pSort;
    pSort = NULL;

    cout << "After sort :" << endl;
    for (int i = 0; i < count; i++)
    {
        cout << test[i] << "  "; 
    }
    cout << endl;
    system("pause");
}

运行结果如下：
这里写图片描述

10：计数排序
步骤：
1：统计数组pArr中每个A[i]出现的次数，存入C[pArr[i]]；
2：从前向后，使数组C中的每个值等于其与前一项相加，这样数组C[pArr [i]]就代表了数组pArr中小于等于pArr [i]的元素个数；
3：为了保证稳定性，从后向前反向填充目标数组B，将数组元素pArr [i]放在数组B的第C[pArr [i]]项（即B[C[pArr [i]] - 1]），每放一个元素就将C[pArr [i]]递减；

时间复杂度为o(n + k)，空间复杂度为o(n + k)。
计数排序的时间复杂度和空间复杂度取决于数组A的数据范围(等于A中元素的最大值与最小值的差加上1)，因此对于数据范围很大的数组，计数排序需要大量时间和内存。

代码如下：
CountingSort.cpp文件

#include <string.h>
#include <stdio.h>
const int nMax = 100;


class CCountingSort{
public:
    void Sort(int* pArr, int length)
    {
        int* C = new int[nMax];
        if (C == NULL)
            return;

        memset(C, 0, nMax * sizeof(int));

        for (int i = 0; i < length; i++)
            C[pArr[i]]++;

        for (int i = 1; i< nMax; i++)
            C[i] = C[i] + C[i - 1];


        int* B = new int[length];
        if (B == NULL)
            return;

        for (int i = length - 1; i >= 0; i--)
        {
            int nTemp = pArr[i];
            B[C[nTemp] - 1] = nTemp;
            C[nTemp]--;
        }

        for (int i = 0; i < length; i++)
            pArr[i] = B[i];

        delete C;
        C = NULL;
        delete B;
        B = NULL;
    }

};

main.cpp文件

#include <iostream>
#include <stdio.h>
#include "CountingSort.cpp"
using namespace std;

void main()
{

    int test[]={5,6,8,3,6,11,33,7,24,66,9,35,85,11,22};
    int count = sizeof(test) / sizeof(int);
    CCountingSort*  pSort = new CCountingSort();
    if (pSort == NULL)
        return;
    pSort->Sort(&test[0], count);
    delete pSort;
    pSort = NULL;

    cout << "After sort :" << endl;
    for (int i = 0; i < count; i++)
    {
        cout << test[i] << "  "; 
    }
    cout << endl;
    system("pause");
}

运行结果如下：
这里写图片描述

11：基数排序
基本思路：
将整形10进制按位拆分，然后从低位到高位依次比较各个位。
1：分配，从个位开始，根据位值分别放到0-9号桶中。
2：收集，将10个桶中的数据，按顺序取出到数组中。
3：从个位到高位，依次重复1,2步骤。
时间复杂度为o(n * nMaxPos)，空间复杂度为o(n * nMaxPos)

代码如下：
RadixSort.cpp文件

#include <stdlib.h>

const int nMaxPos = 6;      //  本程序中元素的最大位数


class RadixSort{
public:
    int GetNumIndex(int nNum, int nPos)
    {
        int nTemp = 1;
        for (int nIdx = 1; nIdx < nPos; nIdx++)
            nTemp *= 10;

        return (nNum / nTemp) % 10;
    }

    void Sort(int* pArr, int length)
    {
        int* C[10];
        for (int i = 0; i < 10; i++)
        {
            C[i] = (int*)malloc(sizeof(int) * (length + 1));
            C[i][0] = 0;    //  0为记录这个数组的个数
        }


        for (int nPos = 1; nPos <= nMaxPos; nPos++) //  从第一位到最高位依次处理
        {
            for (int i = 0; i < length; i++)        //  分配到0-9号桶中
            {
                int nNum = GetNumIndex(pArr[i], nPos);
                int nIndex = ++C[nNum][0];
                C[nNum][nIndex] = pArr[i];
            }

            for (int i = 0, j = 0; i < 10; i++)     //  从0-9号桶收集
            {
                for (int k = 1; k <= C[i][0]; k++)
                    pArr[j++] = C[i][k];

                C[i][0] = 0;                        //  个数复位
            }
        }
    }

};

main.cpp文件

#include <iostream>
#include <stdio.h>
#include "RadixSort.cpp"
using namespace std;

void main()
{

    int test[]={99999, 65, 24, 47, 13, 878, 321, 5, 82222, 66, 33, 22445, 10001, 624159, 624158, 6251};
    int count = sizeof(test) / sizeof(int);
    RadixSort*  pSort = new RadixSort();
    if (pSort == NULL)
        return;
    pSort->Sort(&test[0], count);
    delete pSort;
    pSort = NULL;

    cout << "After sort :" << endl;
    for (int i = 0; i < count; i++)
    {
        cout << test[i] << "  "; 
    }
    cout << endl;
    system("pause");
}

运行结果
这里写图片描述

快速排序算法和冒泡排序效率对比
12-29
一个简单的算法效率对比，实验证明，快速排序的效率比冒泡的效率高出很多啊！
二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip
最新发布
07-01
二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip 二叉树建立遍历冒泡排序快速排序算法：C语言编程实现10个数据结构课程设计实例.zip 二叉树建立遍历冒泡排序快速排序算法：C语言...
数组中涉及的常见算法
Superluckhu的博客
03-18 206
数组中涉及的常见算法 数组元素的赋值 例：杨辉三角、回形数 求数值型数组中元素的最大值、最小值、平均数、总和等 例题请点击 数组的复制、反转、查找(线性查找、二分法查找) 例题请点击 数组元素的排序算法 ...
冒泡排序等各种排序方法，Java基础
weixin_42568647的博客
05-28 170
排序方法，指路链接 https://blog.csdn.net/Java_3y/article/details/104897426?utm_medium=distribute.pc_feed.none-task-blog-alirecmd-18.nonecase&depth_1-utm_source=distribute.pc_feed.none-task-blog-alirecmd-18.nonecase&request_id= Java基础，指路链接 https://github.
比冒泡算法还简单的排序算法：看起来满是bug的程序，居然是对的
量子位
10-06 301
明敏 晓查 发自 凹非寺量子位 报道 | 公众号 QbitAI程序bug也能负负得正吗？还真可以。比如程序员们再熟悉不过的排序算法，通过两个“bug”居然能歪打正着，实在令人匪夷所思。请看...
实现冒泡排序、希尔排序等多种算法示例
huihui_IT的博客
06-03 575
实现以下排序 插入排序O(n^2) 冒泡排序 O(n^2) 选择排序 O(n^2) 快速排序 O(n log n) 堆排序 O(n log n) 归并排序 O(n log n) 希尔排序 O(n^1.25) 1.插入排序 O(n^2) 一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下： ⒈ 从第一个元素开始，该元素可以认为已经被排序 ⒉ 取出下一个元
python冒泡排序 快速排序算法.zip
03-28
冒泡排序和快速排序是两种在计算机科学中广泛使用的排序算法，它们都在Python编程语言中有具体的应用实现。这里我们将深入探讨这两种排序算法的工作原理、优缺点以及如何在Python中实现它们。 **冒泡排序（Bubble ...
Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨Java实现的八个经典排序算法，包括它们的工作原理、时间复杂度以及如何用Java代码实现。...在实际编程中，可以根据数据规模、是否要求稳定性以及内存限制等因素来选择合适的排序算法。
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
php排序算法(冒泡排序,快速排序)
10-27
冒泡排序和快速排序是两种常见的排序算法，在编程中广泛应用于数据的排序处理。在PHP中实现这两种算法同样是非常实用的技能。下面我将详细介绍这两种排序算法的实现原理以及PHP中的代码实现。 首先我们来看冒泡排序...
九大常见算法（一）—— 冒泡排序 及其优化
weixin_43544711的博客
07-05 457
一、什么是冒泡排序？ 冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。 它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。 这个算法的名字由来是因为越大的元素会经由...
【十大排序算法】（一）冒泡排序算法
riemann_的博客
11-16 8593
一、基本思想 在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。 二、算法分析 首先我们给定一个数组 int[] arr = {1,28,3,21,11,7,6,18}; 下面我们来直观的描述下冒泡排序算法的过程： 1、检查是否 1 > 28;...
十大排序算法：冒泡排序算法
A315776的博客
07-30 288
通过不断地交换操作，将符合要求的元素不断向后移动，达到排序的效果
冒泡排序，快速排序，选择排序（java）
心藏_的博客
09-15 175
七大排序 排序方法 平均复杂度 最坏复杂度 最好复杂度 辅助空间 稳定性 选择排序 O(n^2) O(n^2) O(n^2) O(1) 稳定 冒泡排序 O(n^2) O(n^2) O(n^2) O(1) 稳定 插入排序 O(n^2) O(n^2) O(n^2) O(1) 稳定 归并排序 O(nlogn) O(nlogn) O(nlogn) O(n) 稳定 快速排序 O(nlogn) O(n^2) O(nlogn) O(1) 不稳定 希尔排序 O(nlogn)~O(n^2)
排序方法：冒泡排序
XY_CXY0702的博客
05-02 592
@[TOC]冒泡排序 一、排序：将一组数据按照固定的规则进行排列 二、冒泡排序：一种排序方式，对要进行排序的数据进行两两比较，将较大的数据放在后面，依次对所用的数据进行操作，直到所有数据按要求完成排序 三、冒泡排序的特点： 若有n个数据进行排序，总共需要排序n-1次 每一次比较完毕后，下一次的比较就会少一个数据参与 四、下面讲解代码，此处使用的时候java ①代码如下： public class ArrayDemo { public static void main(String[] args)
＜＜数据结构中最全的8种排序算法总结＞＞
weixin_47758784的博客
10-23 745
冒泡排序、选择排序、插入排序 一、冒泡排序1.冒泡排序思想2.冒泡排序步骤3.冒泡排序代码二、选择排序1.选择排序思想2.选择排序代码三、插入排序1.插入排序思想2.插入排序代码 一、冒泡排序 1.冒泡排序思想 交换排序基本思想是：两两比较待排序列中的元素，并交换不满足顺序要求的各队元素，直到全部满足顺序要求为止。而最简单的交换排序就是冒泡排序。 2.冒泡排序步骤 （1）对具有n个元素的序列按升序进行冒泡排序，首先将第一个元素与第二个元素进行比较，若为逆序，则将两元素交换。然后比较第二、第三个元素，以此类推
比较快速排序，冒泡排序，双向冒泡排序的执行效率
weixin_34072637的博客
01-06 399
快速排序 原理是找出一个元素（理论上可以随便找一个）作为基准(pivot),然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n-1个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正 确位置，排序完成。所以快速排序算法的核心算法是分区操作，即如何调整基准的位置以及调整返回基准的最终位...
冒泡排序，选择排序，插入排序的比较
肘子的博客
05-12 528
冒泡排序与选择排序相比，一个从局部入手减少逆序元素，一个放眼大局逐个选择最小值，二者思路大不相同。但是，它们又都有着“通过i次外层循环，从数据中顺次求出i个最小值”的相同特征。相对的，插入排序法是通过i次外层循环，直接将原数组的i个元素重新排列，另外，不含flag的简单冒泡排序法和选择排序法不依赖数据，即比较运算的次数（算法复杂度）不受数据影响，而插入排序在执行效率时却依赖数据，处理某些数据时具有...
【八大排序】冒泡排序 | 快速排序 + 图文详解！！
深入解析C/C++编程技巧，带你探索高效开发之路
02-03 2700
快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
冒泡与快速排序算法性能对比分析
冒泡排序和快速排序是两种常见的排序算法，各有优缺点。冒泡排序是一种简单的排序方法，它通过不断交换相邻的逆序元素来逐步达到排序目的。而快速排序则是一种基于分治策略的高效排序算法，由C.A.R. Hoare在1960年...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值