排序算法

最新推荐文章于 2022-10-15 22:33:32 发布
最新推荐文章于 2022-10-15 22:33:32 发布
阅读量200 收藏
点赞数
分类专栏： 解题报告
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tilmant/article/details/100893886
版权

插入排序

//1:insertsort
template <typename T>
void InsertSort(T a[], int n)
{
    for (int i = 1; i < n; i++)
    {
        T t = a[i];
        int j = i - 1;
        while (j >= 0 && t < a[j])
        {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = t;
    }
}

折半插入排序

//2:BinaryInsertSort
template <typename T>
void BinaryInsertSort(T a[], int n)
{
    //l:low h:high m:mid
    int l, h;
    for (int i = 0; i < n; i++)
    {
        T t = a[i], l = 0, h = i - 1;
        while (l <= h)
        {
            int m = (l + h) >> 1;
            t < a[m] ? h = m - 1 : l = m + 1;
        }
        for (int j = i - 1; j >= h + 1; j--)
            a[j + 1] = a[j];
        a[h + 1] = t;
        //a[l-1] = t;
    }
}

希尔排序

//3:ShellSort
template <typename T>
void ShellSort(T a[], int n)
{
    int k = n / 2;
    while (k > 0)
    {
        //g: gap
        for (int g = 0; g < n; g++)
        {
            for (int i = g + k; i < n; i += k)
            {
                T t = a[i];
                int j = i - k;
                while (j >= 0 && t < a[j])
                {
                    a[j + k] = a[j];
                    j -= k;
                }
                a[j + k] = t;
            }
        }
        k /= 2;
    }
}

冒泡排序

//4:BubbleSort
template <typename T>
void BubbleSort(T a[], int n)
{
    for (int i = n - 1; i > 0; i--)
    {
        int swaped = 1;
        for (int j = 0; j < i; j++)
        {
            if (a[j] > a[j + 1])
            {
                swap(a[j], a[j + 1]);
                swaped = 0;
            }
        }
        if (swaped)
            break;
    }
}

快速排序

//5:QuickSort
template <typename T>
int Partition(T a[], int l, int r)
{
    T t = a[l];
    while (l < r)
    {
        while (l < r && a[r] >= t)
            r--;
        a[l] = a[r];
        while (l < r && a[l] < t)
            l++;
        a[r] = a[l];
    }
    a[l] = t;
    return l;
}

template <typename T>
void QuickSort(T a[], int l, int r)
{
    if (l >= r)
        return;
    int pivotloc = Partition(a, l, r);
    QuickSort(a, l, pivotloc - 1);
    QuickSort(a, pivotloc + 1, r);
}

选择排序

//6:SelectSort
template <typename T>
// void SelectSort(T a[], int n)
// {
//     for (int i = 0; i < n - 1; i++)
//         for (int j = i + 1; j < n; j++)
//             if (a[i] > a[j])
//                 swap(a[i], a[j]);
// }
void SelectSort(T a[], int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        int idx = i;
        for (int j = i + 1; j < n; j++)
            if (a[j] < a[idx])
                idx = j;
        if (i != idx)
            swap(a[i], a[idx]);
    }
}

堆排序

//7:HeapSort
template <typename T>
void heapify(T a[], int i, int n)
{
    //c: child
    if (i >= n)
        return;
    int c = 2 * i + 1;
    int largest = i;
    if (c + 1 < n && a[c] < a[c + 1])
        c++;
    if (c < n && a[largest] < a[c])
        largest = c;
    if (largest != i)
    {
        swap(a[i], a[largest]);
        heapify(a, largest, n);
    }
}
template <typename T>
void HeapSort(T a[], int n)
{
    //build heap
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(a, i, n);
    //arranging array
    for (int i = n - 1; i >= 0; i--)
    {
        swap(a[0], a[i]);
        heapify(a, 0, i);
    }
}

归并排序

//8:MergeSort
template <typename T>
void Merge(T a[], int l, int m, int r)
{
    //l: left r: right m: mid
    //n1: length of left array
    //n2: length of right array
    int n1 = m - l + 1, n2 = r - m;
    int L[n1], R[n2];
    for (int i = 0; i < n1; i++)
        L[i] = a[i + l];
    for (int i = 0; i < n2; i++)
        R[i] = a[i + m + 1];
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2)
    {
        if (L[i] <= R[j])
        {
            a[k] = L[i];
            i++;
        }
        else
        {
            a[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1)
    {
        a[k] = L[i];
        i++;
        k++;
    }
    while (j < n1)
    {
        a[k] = R[j];
        j++;
        k++;
    }
}
template <typename T>
void MergeSort(T a[], int l, int r)
{
    if (l >= r)
        return;
    int m = (l + r - 1) >> 1;
    MergeSort(a, 0, m);
    MergeSort(a, m + 1, r);
    Merge(a, l, m, r);
}

基数排序

//9:RadixSort
template <typename T>
void CountSort(T a[], int e, int n)
{
    int o[n + 1], cnt[10] = {0};
    for (int i = 0; i < n; i++)
        cnt[(a[i] / e) % 10]++;
    for (int i = 1; i < 10; i++)
        cnt[i] += cnt[i - 1];
    for (int i = n - 1; i >= 0; i--)
    {
        o[cnt[(a[i] / e) % 10]] = a[i];
        cnt[(a[i] / e) % 10]--;
    }
    for (int i = 1; i <= n; i++)
        a[i - 1] = o[i];
}
template <typename T>
void RadixSort(T a[], int n)
{
    int m = *max_element(a, a + n);
    for (int e = 1; m / e > 0; e *= 10)
        CountSort(a, e, n);
}

睡眠排序

:)

完整代码

#include <stdio.h>
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

//1:insertsort
template <typename T>
void InsertSort(T a[], int n)
{
    for (int i = 1; i < n; i++)
    {
        T t = a[i];
        int j = i - 1;
        while (j >= 0 && t < a[j])
        {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = t;
    }
}
//2:BinaryInsertSort
template <typename T>
void BinaryInsertSort(T a[], int n)
{
    //l:low h:high m:mid
    int l, h;
    for (int i = 0; i < n; i++)
    {
        T t = a[i], l = 0, h = i - 1;
        while (l <= h)
        {
            int m = (l + h) >> 1;
            t < a[m] ? h = m - 1 : l = m + 1;
        }
        for (int j = i - 1; j >= h + 1; j--)
            a[j + 1] = a[j];
        a[h + 1] = t;
        //a[l-1] = t;
    }
}
//3:ShellSort
template <typename T>
void ShellSort(T a[], int n)
{
    int k = n / 2;
    while (k > 0)
    {
        //g: gap
        for (int g = 0; g < n; g++)
        {
            for (int i = g + k; i < n; i += k)
            {
                T t = a[i];
                int j = i - k;
                while (j >= 0 && t < a[j])
                {
                    a[j + k] = a[j];
                    j -= k;
                }
                a[j + k] = t;
            }
        }
        k /= 2;
    }
}
//4:BubbleSort
template <typename T>
void BubbleSort(T a[], int n)
{
    for (int i = n - 1; i > 0; i--)
    {
        int swaped = 1;
        for (int j = 0; j < i; j++)
        {
            if (a[j] > a[j + 1])
            {
                swap(a[j], a[j + 1]);
                swaped = 0;
            }
        }
        if (swaped)
            break;
    }
}
//5:QuickSort
template <typename T>
int Partition(T a[], int l, int r)
{
    T t = a[l];
    while (l < r)
    {
        while (l < r && a[r] >= t)
            r--;
        a[l] = a[r];
        while (l < r && a[l] < t)
            l++;
        a[r] = a[l];
    }
    a[l] = t;
    return l;
}

template <typename T>
void QuickSort(T a[], int l, int r)
{
    if (l >= r)
        return;
    int pivotloc = Partition(a, l, r);
    QuickSort(a, l, pivotloc - 1);
    QuickSort(a, pivotloc + 1, r);
}
//6:SelectSort
template <typename T>
// void SelectSort(T a[], int n)
// {
//     for (int i = 0; i < n - 1; i++)
//         for (int j = i + 1; j < n; j++)
//             if (a[i] > a[j])
//                 swap(a[i], a[j]);
// }
void SelectSort(T a[], int n)
{
    for (int i = 0; i < n - 1; i++)
    {
        int idx = i;
        for (int j = i + 1; j < n; j++)
            if (a[j] < a[idx])
                idx = j;
        if (i != idx)
            swap(a[i], a[idx]);
    }
}
//7:HeapSort
template <typename T>
void heapify(T a[], int i, int n)
{
    //c: child
    if (i >= n)
        return;
    int c = 2 * i + 1;
    int largest = i;
    if (c + 1 < n && a[c] < a[c + 1])
        c++;
    if (c < n && a[largest] < a[c])
        largest = c;
    if (largest != i)
    {
        swap(a[i], a[largest]);
        heapify(a, largest, n);
    }
}
template <typename T>
void HeapSort(T a[], int n)
{
    //build heap
    for (int i = n / 2 - 1; i >= 0; i--)
        heapify(a, i, n);
    //arranging array
    for (int i = n - 1; i >= 0; i--)
    {
        swap(a[0], a[i]);
        heapify(a, 0, i);
    }
}
//8:MergeSort
template <typename T>
void Merge(T a[], int l, int m, int r)
{
    //l: left r: right m: mid
    //n1: length of left array
    //n2: length of right array
    int n1 = m - l + 1, n2 = r - m;
    int L[n1], R[n2];
    for (int i = 0; i < n1; i++)
        L[i] = a[i + l];
    for (int i = 0; i < n2; i++)
        R[i] = a[i + m + 1];
    int i = 0, j = 0, k = l;
    while (i < n1 && j < n2)
    {
        if (L[i] <= R[j])
        {
            a[k] = L[i];
            i++;
        }
        else
        {
            a[k] = R[j];
            j++;
        }
        k++;
    }
    while (i < n1)
    {
        a[k] = L[i];
        i++;
        k++;
    }
    while (j < n1)
    {
        a[k] = R[j];
        j++;
        k++;
    }
}
template <typename T>
void MergeSort(T a[], int l, int r)
{
    if (l >= r)
        return;
    int m = (l + r) >> 1;
    MergeSort(a, 0, m);
    MergeSort(a, m + 1, r);
    Merge(a, l, m, r);
}
//9:RadixSort
template <typename T>
void CountSort(T a[], int e, int n)
{
    int o[n + 1], cnt[10] = {0};
    for (int i = 0; i < n; i++)
        cnt[(a[i] / e) % 10]++;
    for (int i = 1; i < 10; i++)
        cnt[i] += cnt[i - 1];
    for (int i = n - 1; i >= 0; i--)
    {
        o[cnt[(a[i] / e) % 10]] = a[i];
        cnt[(a[i] / e) % 10]--;
    }
    for (int i = 1; i <= n; i++)
        a[i - 1] = o[i];
}
template <typename T>
void RadixSort(T a[], int n)
{
    int m = *max_element(a, a + n);
    for (int e = 1; m / e > 0; e *= 10)
        CountSort(a, e, n);
}

int main()
{
    int a[1 << 10], n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
        scanf("%d", &a[i]);
    // InsertSort(a, n);
    // BinaryInsertSort(a, n);
    // BubbleSort(a, n);
    // QuickSort(a, 0, n - 1);
    // SelectSort(a, n);
    // HeapSort(a, n);
    // MergeSort(a, 0, n - 1);
    // RadixSort(a, n);
    for (int i = 0; i < n; i++)
        printf("%d ", a[i]);
    return 0;
}

(测试数据坐上来自己动)

Tilmant
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Select_Sort
12-23
选择排序（Selection sort）是一种不稳定的排序方法，每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。其主要应用于计算机和数学领域。它的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对n个元素的表进行排序总共进行至多n-1次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。
选择排序
野狼窝
07-17 363
/** *选择排序 */public class SelectSort{ public void selectSort(int[] a) { int len = a.length; int k, temp; for (int i = 0; i < len; i++) { k = i; for (int j = k + 1; j < l
排序算法----》选择排序
weixin_42454225的博客
03-05 67
选择排序是我认为最垃圾的一个排序算法，因为他时间复杂度和冒泡一样n^2 ，最关键的是他的不稳定性，当然选择排序也是一个最简单直观的排序算法 public static void sort(int [] a){ for(int i=a.length-1;i>0;i--){ int minindex=0; for(int j=1;j<=i;j++){ if(a[minindex]>a[j]){
排序算法系列一(冒泡排序)
毛C毛Py的专栏
12-20 528
  for( int i=0;i   for( int j=0; j     if(a[i]>a[j]) a[i]^=a[j]^=a[i]^=a[j];or  for( int i=n-1;i>0; i--)     for( int j=0; j       if(a[j]>a[j+1])  a[j]^=a[j+1]^=a[j]^=a[j+1]; 
适用 C# 语言实现升序/降序的 “基数排序”、“堆排序”、“桶排序”、“快速排序”、“选择排序”、“冒泡排序” 等算法
liulilittle的博客
10-15 747
测试数组：var array = new int[] { 73, 57, 49, 99, 133, 20, 1 };4、桶排序：BucketSort2(array, false);2、基数排序：RadixSort(array, false);3、快速排序：QuickSort(array, false);1、堆排序：HeapSort(array, false);1、桶排序【堆内存负载重：O(n + k)】1、快速排序（QuickSort）4、桶排序（BucketSort）1、基数排序（矢量排序）
基于比较的排序算法汇总 选择排序法 插入排序法 归并排序法 快速排序法 堆排序法 冒泡排序法 希尔排序法
最新发布
01-15
在IT领域，排序算法是计算机科学中的基础但至关重要的概念，尤其在数据处理和算法设计中扮演着核心角色。本文将深入探讨标题中提到的几种基于比较的排序算法：选择排序、插入排序、归并排序、快速排序、堆排序、冒泡...
最快的排序算法 最快的内部排序法—桶排序法，排序算法数据结构
04-07
最快的排序算法 最快的内部排序法—桶排序法，排序算法数据结构
常见经典排序算法（C语言）1希尔排序 二分插入法 直接插入法 带哨兵的直接排序法 冒泡排序 选择排序 快速排序 堆排序.docx
05-07
常见的经典排序算法有希尔排序、二分插入法、直接插入法、带哨兵的直接排序法、冒泡排序、选择排序、快速排序、堆排序等。 一、希尔排序（Shell 排序法） 希尔排序法，又称宿小增量排序，是 1959 年由 D.L.Shell ...
最快的排序算法 最快的内部排序法—桶排序法 (1)，排序算法数据结构
04-07
最快的排序算法 最快的内部排序法—桶排序法 (1)，排序算法数据结构
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
java排序算法
09-10
java实现的常用的几种基本排序算法，插入、交换、选择、归并
冒泡排序法+输入输出数组
10-31
上次的改进，审核求过.
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
排序算法实验报告
12-23
希尔排序，冒泡排序、快速排序递归排序，快速排序非递归排序，快速排序改进算法
6种排序算法的排序系统
01-10
六种排序算法的排序系统 本篇文章主要讲解了六种排序算法的排序系统，包括插入排序、冒泡排序、选择排序、快速排序、堆排序和归并排序。该系统可以让用户选择六种排序算法中的任意一个，并输出结果。 插入排序 ...
数据结构——排序算法（选择排序）
weixin_40701758的博客
10-24 157
#include<iostream> #include<string> using namespace std; template<class T> void mySwap(T &a, T &b){ T temp=a; a=b; b=temp; } //利用选择排序进行计算 template<typename T> void mySort(T arr[], int len){ for(int i=0;..
1. 设计一个函数模板，其中包括数据成员T a[n]以及对其进行由大到小排序的成员函数 sort( )，模板参数T可实例化成字符串
m0_64190853的博客
05-14 564
本代码结合快排 #include<iostream> using namespace std; template<typename T> int min_re(T a[], int left, int right) { T b = a[left]; while (left < right) { while (a[right] >= b && right >left) right--; a[left] = a[right];
排序算法（一）冒泡排序
qq_37089829的博客
10-14 126
思想：外层循环有n-1轮，内存循环每次从尾部到头部（i）之后的范围内，每相邻两个元素进行比较。 Python版本： # 冒泡排序 class Solution: def BubbleSort(self,arr): n = len(arr) for i in range(0,n-1): for j in range(n-1,i,-1): if arr[j]<arr[i]:
C语言选择法排序
小生南瞧
04-28 1552
选择法降序排序 思路：通过反复求最大值进行排序； a，一组数有n个数 b，通过比较前一个数值与后一个数值，找出其中最大的数，放在a[0]中； c，通过比较前一个数值与后一个数值，找出第二大数，放在a[1]中； … d，通过比较前一个数值与后一个数值，最后最小的数，放在a[n-1]中； 如果前值小于后值，则进行值替换；最多有n-1次替换操作； 例 /*选择法降序排序*/ #include...
数据排序算法详解：选择排序法
选择排序是一种简单直观的排序算法，它的基本思想是在未排序的序列中找到最小（或最大）的元素，放到序列的起始位置，然后再从剩余未排序的元素中继续寻找最小（或最大）的元素，然后放到已排序序列的末尾，以此类推...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值