排序算法归集

最新推荐文章于 2023-06-18 19:23:26 发布
最新推荐文章于 2023-06-18 19:23:26 发布
阅读量295 收藏
点赞数 1
分类专栏： 排序 文章标签： 快速排序 算法 leetcode 排序算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28217563/article/details/106562649
版权
  1. 冒泡排序
int *sortArray(int* nums, int numsSize, int* returnSize)
{
        *returnSize = numsSize;
        int tmp;
        for (int i = 0; i < numsSize; ++i) {
                for (int j = 0; j > numsSize - 1; ++j) {
                        if (nums[j] < nums[j + 1]) {
                                tmp = nums[j];
                                nums[j] = nums[j + 1];
                                nums[j + 1] = tmp;
                        }
                }
        }
        return nums;
}
  1. 选择排序
int* sortArray(int* nums, int numsSize, int* returnSize)
{
        *returnSize = numsSize;
        int tmp;
        for (int i = 0; i < numsSize - 1; ++i) {
                for (int j = i + 1; j > 0; --j) {
                        if (nums[j] < nums[j - 1]) {
                                tmp = nums[j];
                                nums[j] = nums[j - 1];
                                nums[j - 1] = tmp;
                        }
                }
        }
        return nums;
}
  1. 插入排序
int* sortArray(int* nums, int numsSize, int* returnSize)
{
        *returnSize = numsSize;
        int tmp, index;
        for (int i = 0; i < numsSize; ++i) {
                tmp = INT_MAX;
                for (int j = i; j < numsSize; ++j) {
                        if (tmp > nums[j]) {
                                tmp = nums[j];
                                index = j;
                        }
                }
                nums[index] = nums[i];
                nums[i] = tmp;
        }
        return nums;
}
  1. 堆排序
#define right_tree(i) (2 * i + 1)
#define left_tree(i) (2 * i)
#define parent_tree(i) (i / 2)

void max_heapify(int *s, int i, int nums_size)
{
        if ((i >= nums_size) || (i < 0))
                return;
        int l = left_tree(i);
        int r = right_tree(i);
        int target;
        int tmp;
        if (l >= nums_size)
                return;
        if (r >= nums_size)
                return;
        target = (s[l] > s[i]) ? l : i;
        target = (s[r] > s[target]) ? r : target;

        if (target != i) {
                tmp = s[target];
                s[target] = s[i];
                s[i] = tmp;
                max_heapify(s, target, nums_size);
        }
}

void build_max_heapify(int *s, int nums_size)
{
        for (int j = nums_size/2 - 1; j >= 0; --j) {
                max_heapify(s, j, nums_size);
        }
}

void heap_sort(int *s, int nums_size)
{
        int tmp;
        build_max_heapify(s, nums_size);
        for (int i = nums_size - 1; i > 0; --i) {
                tmp = s[0];
                s[0] = s[i];
                s[i] = tmp;
                max_heapify(s, 0, i);
        }
}

int* sortArray(int* nums, int numsSize, int* returnSize)
{
        *returnSize = numsSize;
        heap_sort(nums, numsSize);
        return nums;
}
  1. 归并排序
void merge_sort(int *nums, int nums_size)
{
        int m = nums_size / 2;
        int l_index = 0;
        int r_index = m;
        int n_index = 0;
        int *nums_l = malloc(m * sizeof(int));
        int *nums_r = malloc((nums_size - m) * sizeof(int));
        if ((nums_l == NULL) || (nums_r == NULL))
                return;

        while ((r_index < nums_size) || (l_index < m)) {
                if (l_index < m)
                        nums_l[l_index] = nums[l_index];
                if (r_index < nums_size)
                        nums_r[r_index - m] = nums[r_index];
                r_index++;
                l_index++;
        }
        l_index = 0;
        r_index = 0;
        n_index = 0;
        while ((r_index < nums_size) || (l_index < m)) {
                if (n_index >= nums_size) {
                        break;
                }

                if ((l_index < m) && (r_index < nums_size - m)) {
                        if (nums_l[l_index] < nums_r[r_index]) {
                                nums[n_index++] = nums_l[l_index++];
                        } else {
                                nums[n_index++] = nums_r[r_index++];
                        }
                } else if (l_index < m) {
                        nums[n_index++] = nums_l[l_index++];
                } else if (r_index < nums_size) {
                        nums[n_index++] = nums_r[r_index++];
                } else {
                        break;
                }
        }
}

void sort_array(int *nums, int nums_size)
{
        int m = nums_size / 2;
        if (nums_size > 1) {
                sort_array(nums, m);
                sort_array(nums + m, nums_size - m);
                merge_sort(nums, nums_size);
        }
}

int* asortArray(int* nums, int numsSize, int* returnSize)
{
        *returnSize = numsSize;
        sort_array(nums, numsSize);
        return nums;
}
  1. 计数排序(待排序数只能大于零)
int* sortArray(int* nums, int numsSize, int* returnSize)
{
        *returnSize = numsSize;
        int *A = calloc(numsSize, sizeof(int));
        int nums_max = INT_MIN;
        for (int i = 0; i < numsSize; ++i) {
                if (nums[i] > nums_max)
                        nums_max = nums[i];
        }
        int *B = calloc(nums_max + 1, sizeof(int));
        for (int i = 0; i < numsSize; ++i)
                B[nums[i]] += 1;
        for (int i = 1; i <= nums_max; ++i)
                B[i] += B[i - 1];

        for (int i = numsSize - 1; i >= 0; --i) {
                A[B[nums[i]]-1] = nums[i];
                B[nums[i]] -= 1;
        }
        return A;
}
  1. 计数排序(待排序数可以小于零)
1). 
int* sortArray(int* nums, int numsSize, int* returnSize)
{
        *returnSize = numsSize;
        int *A = calloc(numsSize, sizeof(int));
        int nums_max = INT_MIN;
        int nums_min = INT_MAX;
        for (int i = 0; i < numsSize; ++i) {
                if (nums[i] > nums_max) {
                        nums_max = nums[i];
                }
                if (nums[i] < nums_min) {
                        nums_min = nums[i];
                }
        }
        if (nums_min < 0)
                nums_max = nums_max - nums_min;

        int *B = calloc(nums_max + 1, sizeof(int));
        for (int i = 0; i < numsSize; ++i) {
                if (nums_min < 0)
                        nums[i] -= nums_min;
                B[nums[i]] += 1;
        }
        for (int i = 1; i <= nums_max; ++i)
                B[i] += B[i - 1];
        for (int i = numsSize - 1; i >= 0; --i) {
                A[B[nums[i]]-1] = nums[i];
                B[nums[i]] -= 1;
        }

        if (nums_min < 0) {
                for (int i = 0; i < numsSize; ++i)
                        A[i] += nums_min;
        }
        return A;
}

2).
int* sortArray(int* nums, int numsSize, int* returnSize)
{
        *returnSize = numsSize;
        int *A = calloc(numsSize, sizeof(int));
        int nums_max = INT_MIN;
        int nums_min = INT_MAX;
        for (int i = 0; i < numsSize; ++i) {
                if (nums[i] > nums_max) {
                        nums_max = nums[i];
                }
                if (nums[i] < nums_min) {
                        nums_min = nums[i];
                }
        }
        if (nums_min < 0)
                nums_max = nums_max - nums_min;
        else 
                nums_min = 0;

        int *B = calloc(nums_max + 1, sizeof(int));
        for (int i = 0; i < numsSize; ++i)
                B[nums[i] - nums_min] += 1;
        
        for (int i = 1; i <= nums_max; ++i)
                B[i] += B[i - 1];

        for (int i = numsSize - 1; i >= 0; --i) {
                A[B[nums[i] - nums_min]-1] = nums[i];
                B[nums[i] - nums_min] -= 1;
        }
        free(B);
        return A;
}
mnlife_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习全套教程（七）-- 数据集介绍与划分
python爬虫人工智能大数据
03-21 961
Python爬虫人工智能教程：www.python88.cn 编程资源网：www.python66.cn 数据集介绍与划分 学习目标 目标 知道数据集的分为训练集和测试集 知道sklearn的分类、回归数据集 应用 无 拿到的数据是否全部都用来训练一个模型？ 1、 数据集的划分 机器学习一般的数据集会划分为两个部分： 训练数据：用于训练，构建模型 测试数据：在...
归并算法总结
weixin_42534963的博客
09-25 500
1.算法原理 把两个或多个有序的子序列合并为一个 2.归并排序算法步骤 若low<high，则将序列从中间mid=(low+high)/2分开 对左半部分[low,mid]递归地进行归并排序 对右半部分[mid+1,high]递归地进行归并排序 将左右两个有序的子序列Merge为一个 3.具体算法 #include<stdio.h> #include<stdlib.h> #include<string.h> void Merge(int A[],int B[]
数据结构：归并排序算法，详解，图解 -- 数据结构算法集
九瓜的博客
06-12 912
归并排序算法 归并排序算法讲的是先分后合： 总的来说归并排序就是把原序列都拆分为单个的元素，然后从单个的元素开始进行按照大小合并到中间list中，排序完成。 这里的拆分比较容易，重点讲解合并 合并的步骤： 首先创建一个用于存放排好序的列表result ， 然后比较两个list中首元素的大小， 把较小的元素放到列表result中，并且在序列中删除该元素，以防止影响后面判断 ， 重复步骤2、3操作，直到有一个list为空， 将剩下不为空的list合并到列表result后面， result就是合并、排序后的列表
leetcode分类-algorithm:基本算法归集，主要来源于CLRS《算法导论》，*Algo.java主要对应各个算法的实现，*Test
06-30
leetcode 分类 algorithm 本工程涵盖基本算法和容器操作基础 ，部分算法来源于CLRS算法导论相关章节，在此向CLRS等诸位先驱致敬！ advanced包相关： 为先进算法和数据结构相关内容，包含 1.b-tree的实现，以及文本数据库的简易实现 2.斐波那契堆的实现 ods包为开源数据库的源码，在此感谢Pat Morin sort包相关: 根据排序算法的特性，可以分为比较排序（例如冒泡、堆排序、插入排序、归并排序、快速排序、选择排序、希尔排序等）和非比较排序（例如计数排序、基数排序和桶排序） 不同的排序，对数据类型和幅值的要求不一，因此应用场合也各有不同 GenericAlgoTester.java 通用测试类，支持多种数据类型，支持2份相同数组的排序比较（与JDK自带J.U.A的Arrays.sort算法进行对比） 子类需要重载showtime方法来实现具体的排序 yuanjun.chen.base.sort.BubbleSortAlgo.java 冒泡排序实现类，yuanjun.chen.base.sort.BubbleSortTest.java实现相应测试 yu
大数据治理.数据采集/归集技术
u010025781的博客
06-18 2119
DATAx是阿里开源的一个异构数据源离线同步工具，致力于实现包括关系型数据库(MySQL、Oracle等)、HDFS、Hive、ODPS、HBase、FTP等各种异构数据源之间稳定高效的数据同步功能。 FlinkCDC --Change Data Capture--捕数据库中数据变更的获技术.
十大排序算法
10-16
常见10大算法，从原理，动图解析到代码实现，逐步分析，让你轻松入门算法
排序算法实验报告
12-23
希尔排序，冒泡排序、快速排序递归排序，快速排序非递归排序，快速排序改进算法
数据排序算法.docx
最新发布
07-22
### 数据排序算法详解 #### 一、概述 排序算法作为数据结构与算法分析中的核心内容之一，被广泛应用于计算机科学的各个领域。根据处理数据的方式不同，排序算法大致可以分为两类：内部排序算法和外部排序算法。 #...
排序算法源码
08-02
在IT领域，排序算法是计算机科学中的基础但至关重要的概念，尤其对于编程和算法设计而言。这些算法用于组织和优化数据结构，使数据按照特定顺序排列。以下是对压缩包文件中包含的几种排序算法源码的详细解释： 1. ...
排序算法包
01-18
在计算机科学中，排序算法是数据处理的重要组成部分，它们用于将一组数据按照特定顺序排列。本包中的"排序算法包"使用C++编程语言实现了一些经典的排序算法，旨在帮助开发者和学习者深入理解这些算法的工作原理和...
记录｜一种0代码自动归集数据并可视化推送的解决方案
qq_41771196的博客
04-11 624
0代码自建个性化的股票分析平台。
java数据类型归集，整理
network_dream的博客
08-22 515
原始数据类型-包括byte，short，int，long， float，double，boolean和char type Size Range default byte 1字节(Byte）/8位(bit) -128（-2^7） to 127（2^7-1） 0 short 2字节(Byte）/16位(bit) -32768（-2^15） to 32767（2^15 - 1）...
算法笔记day1
weixin_54116202的博客
06-03 871
知识点：数组 nums指的输入数组nums，numsSize是指的数组nums的长度，returnSize指的是数组returnSize的返回长度 *returnSize=numsSize；返回数组的长度等于数组nums的长度 a = (int*)malloc(sizeof(int) * numsSize); 为数组a分配numsSize个内存，新建数组要分配内存！ 新建一个数组int* a； 算法： 利用sunsSize控制循环次数，利用sum求出前m项的和并赋值给a[m]。 注意...
3.2 二分查找
qq_51047851的博客
01-17 809
704 二分查找题目给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。思路具体代码实现(C++)模型(知识点) 题目 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。 示例 1: 输入: nums = [-1,0,3,5,9,12], target = 9 输出:
LeetCode三数之和——C
有人_295的博客
08-18 2000
来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/3sum 题目描述 给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。 注意：答案中不可以包含重复的三元组。 例如, 给定数组 nums = [-1, 0, 1, 2, -1, -4]...
分治算法之全排列 c语言,最大子序和--分治法（附四种算法代码）
weixin_35705475的博客
05-25 1037
本文代码均采用C++0x01.问题给定一个整数数组 nums，找到一个具有最大和的连续子数组(子数组最少包含一个元素)，返回其最大和。输入示例：[-2,1,-3,4,-1,2,1,-5,4]输出示例：6解释：连续子数组[4,-1,2,1] 的和最大，为6。C++函数形式为 intmaxSubArray(vector&nums)0x02.分析问题这是一个连续的子列和问题，很明...
C++ vector用法初记
nuc_Sheryl的博客
07-20 3721
一维vector 创建一维vector： vectorint> nums;//不指定长度 vectorint> nums(n); // 指定长度为n 添加元素 nums.push_back(1);//直接从数组末端添加 nums[i] = 1;//直接赋值给第i个位置 删除元素 nums.resize(nums.size-i); //直接将数组长度减小，某种方式上删掉了后面i个 n
LeetCode消失的数字（三种解法详解）
iEucliwood的博客
05-01 577
数组nums包含从0到n的所有整数，但其中缺了一个。请编写代码找出那个缺失的整数。你有办法在O(n)时间内完成吗？ 函数接口如下 int missingNumber(int* nums, int numsSize){ } 其中nums为指向数组首元素的指针，numsSize为数组大小。 方法一：位运算 利用位运算中的异或，异或的位运算规则是，1^1=0，1^0=1，0^0=0，从这里能看出，异或的运算能找出两个数中不相同的位并标为1，比如两个相同的数它们的位是相同的异或为0，x^x=0，与0异
Java排序算法详解与实现
【资源摘要信息】: "Java排序算法汇总，包括插入排序、交换排序、选择排序、归并排序和基数排序。适用于不同规模和顺序的数组，选择合适的排序算法能提高效率。" 在计算机科学中，排序算法是用于对一组数据进行排序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值