【C语言】选择排序+求出以前数组的位置

已于 2022-03-01 22:40:51 修改
阅读量3.1k 收藏 4
点赞数
分类专栏： C语言笔记 文章标签： c语言
于 2021-09-01 00:00:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Roger_717/article/details/120029509
版权

 1. 对负数数组取绝对值进行排序（从大到小）

#include<stdio.h>
#include<math.h>
void SelectionSort(int *arr, int n) 
{
    for (int i = 0; i < n; i++) 
    {
        int Maxkey = abs(arr[i]); 
        for(int j=i; j<n; j++)
        {
            if(Maxkey<abs(arr[j]))
            {
                int temp = abs(arr[j]);
                arr[j]=abs(Maxkey);
                Maxkey=abs(temp);
            }
        }
        arr[i]=abs(Maxkey);
    }
}

int main() {
    int a[] = {-12,-7,-9,-22,-22,-88,-4,-1,1,-1,-53};
    int n = sizeof(a)/sizeof(int);
    InsertSort(a, n);
    printf("The sorted array is:");
    for (int i = 0; i < n; i++) {
        printf(" %d", a[i]);
    }
    printf("\n");
    return 0;
}

2. 对负数数组取绝对值进行排序（从小到大）

#include<stdio.h>
#include<math.h>
void SelectionSort(int *arr, int n) 
{
    for (int i = 0; i < n; i++) 
    {
        int Minkey = abs(arr[i]); 
        for(int j=i; j<n; j++)
        {
            if(Minkey>abs(arr[j]))
            {
                int temp = abs(arr[j]);
                arr[j]=abs(Minkey);
                Minkey=abs(temp);
            }
        }
        arr[i]=abs(Minkey);
    }
}

int main() {
    int a[] = {-12,-7,-9,-22,-22,-88,-4,-1,1,-1,-53};
    int n = sizeof(a)/sizeof(int);
    SelectionSort(a, n);
    printf("The sorted array is:");
    for (int i = 0; i < n; i++) {
        printf(" %d", a[i]);
    }
    printf("\n");
    return 0;
}

 2.1 在keil5中需要包括头文件

#include <math.h>
#include <stdlib.h>//abs
void SelectionSort(int8_t *arr, int8_t n) 
{
    int8_t Minkey;
    int8_t temp;
    for (int8_t i = 0; i < n; i++) 
    {
        Minkey = abs(arr[i]); 
        for(int j=i; j<n; j++)
        {
            if(Minkey>abs(arr[j]))
            {
                temp = abs(arr[j]);
                arr[j]=abs(Minkey);
                Minkey=abs(temp);
            }
        }
        arr[i]=abs(Minkey);
    }
}

 2.2 sizeof(array)/sizeof(int)

array是个数组，
sizeof (array)就是这个数组所占的内存总量（字节数),
sizeof(int)就是单个所占的内存。
所以，sizeof(array)/sizeof(int)就是array数组的元素的个数。

3. 求一维数组最大值的位置

求出数组长度，设立一个变量imax记录当前最大值的下标；对数组进行遍历比较，总是把最大值的下标赋给imax，遍历完成后imax即为所求位置。

#include<stdio.h>
int main(void){
    int a[]={1,6,18,19,13,5,2,-20,30,4,12,14,15,16,17,7,8,9,10,11},i,imax,ln;
    ln=sizeof(a)/sizeof(int);
    for(i=imax=0;i<ln;i++)
        if(a[imax]<a[i])
            imax=i;
    printf("The maximum is the subscript of %d elements.\n",imax);
    return 0;
}

4. 求一维数组最小值的位置

#include<stdio.h>
int main(void){
    int a[]={1,6,18,19,13,5,2,-20,30,4,12,14,15,16,17,7,8,9,10,11},i,imin,ln;
    ln=sizeof(a)/sizeof(int);
    for(i=imin=0;i<ln;i++)
        if(a[imin]>a[i])
            imin=i;
    printf("The minimum is the subscript of %d elements.\n",imin);
    return 0;
}

5. 求一维数组绝对值最小值的位置

#include<stdio.h>
#include<math.h>
int main(void){
    int a[]={4,6,18,19,13,5,2,-20,30,4,12,1,-1,16,17,7,8,9,10,11},i,imin,ln;
    ln=sizeof(a)/sizeof(int);
    for(i=imin=0;i<ln;i++)
        if(a[imin]>abs(a[i]))
            imin=i;
    printf("The minimum is the subscript of %d elements.\n",imin);
    return 0;
}

这种算法只能求出数组左边的最小值，如果数组中有两个最小值，那么求出的数组位置就是左面最小值的位置。

6. 用C语言对一维数组排序,并输出原来的位置

可以先用冒泡排序对数组进行排序，然后对排序的数组进行遍历，找出其在排序之前数组中的位置

 这种方法对于重复数组效果就不行了，因为它总是与第一个重复元素进行比较，如何值比较一次呢？

#include<stdio.h>
#include <cstring>
void SelectionSort(int *arr, int n) 
{
    for (int i = 0; i < n; i++) 
    {
        int Minkey = arr[i]; 
        for(int j=i; j<n; j++)
        {
            if(Minkey>arr[j])
            {
                int temp = arr[j];
                arr[j]=Minkey;
                Minkey=temp;
            }
        }
        arr[i]=Minkey;
    }
}

int main() {
    int a[] = {5,1,1,1,1,0,1,1,1,2};
    int b[10];
    int c[10];
    int k;
    int n = sizeof(a)/sizeof(int);
    memcpy(&b, &a, sizeof(a));
    SelectionSort(a, n);
    printf("The sorted array is:");
    printf("\n");
    for (int i = 0; i < n; i++) {
        printf(" %d", b[i]);
    }
    printf("\n");
    for (int ip = 0; ip < n; ip++) {
        printf(" %d", a[ip]);
    }
    printf("\n");
    for (int ii=0;ii<n;ii++)
    {
        for (int j=0;j<n;j++)
        {
            if (a[ii]==b[j])
            {
                c[k++] = j; //因为说的是第几位而不是下标
                break;
            } 
        }
    }
    for (int iii=0;iii<n;iii++)
    {
        printf("%d ",c[iii]);
    }
    printf("\n");
    return 0;
}

 改进：

#include<stdio.h>
#include <cstring>
void SelectionSort(int *arr, int n) 
{
    for (int i = 0; i < n; i++) 
    {
        int Minkey = arr[i]; 
        for(int j=i; j<n; j++)
        {
            if(Minkey>arr[j])
            {
                int temp = arr[j];
                arr[j]=Minkey;
                Minkey=temp;
            }
        }
        arr[i]=Minkey;
    }
}

int main() {
    int z1=0,z2=1,z3=2,z4=3,z5=4;
    int a[] = {1,2,1,1,-3};
    int b[10];
    int c[10];
    int k = 0;
    int n = sizeof(a)/sizeof(int);
    memcpy(&b, &a, sizeof(a));
    SelectionSort(a, n);
    printf("The sorted array is:");
    printf("\n");
    for (int i = 0; i < n; i++) {
        printf(" %d", b[i]);
    }
    printf("\n");
    for (int ip = 0; ip < n; ip++) {
        printf(" %d", a[ip]);
    }
    printf("\n");
    for (int ii=0;ii<n;ii++)
    {
        if(a[ii] == b[z1])
        {
            c[k++]=z1;
            z1=10;
        }
        else if(a[ii] == b[z2])
        {
            c[k++]=z2;
            z2=10;
        }
        else if(a[ii] == b[z3])
        {
            c[k++]=z3;
            z3=10;
        }
        else if(a[ii] == b[z4])
        {
            c[k++]=z4;
            z4=10;
        }
        else if(a[ii] == b[z5])
        {
            c[k++]=z5;
            z5=10;
        }
    }
    for (int iii=0;iii<n;iii++)
    {
        printf("%d ",c[iii]);
    }
    printf("\n");
    return 0;
}

void HeatingChannelArray(void)
{
    int z0=0,z1=1,z2=2,z3=3,z4=4,z5=5,z6=6,z7=7,z8=8,z9=9, \
        z10=10,z11=11,z12=12,z13=13,z14=14,z15=15;
    int i,j;
    getDValue();
    memcpy(&SortArray,&TempDValue,sizeof(TempDValue));//原有数据拷贝
    SelectionSort(TempDValue, CHANNELNUM);
    for(i = 0; i < CHANNELNUM; i++)
    {
        if(TempDValue[i] == SortArray[z0])//排序后与原值比较
        {
            ArrayLabel[j++]=z0;
            z0=16;//标志位更改不允许再次进入
        }
        else if(TempDValue[i] == SortArray[z1])
        {
            ArrayLabel[j++]=z1;
            z1=16;
        }
        else if(TempDValue[i] == SortArray[z2])
        {
            ArrayLabel[j++]=z2;
            z2=16;
        }
        else if(TempDValue[i] == SortArray[z3])
        {
            ArrayLabel[j++]=z3;
            z3=16;
        }
        else if(TempDValue[i] == SortArray[z4])
        {
            ArrayLabel[j++]=z4;
            z4=16;
        }
        else if(TempDValue[i] == SortArray[z5])
        {
            ArrayLabel[j++]=z5;
            z5=16;
        }
        else if(TempDValue[i] == SortArray[z6])
        {
            ArrayLabel[j++]=z6;
            z6=16;
        }
        else if(TempDValue[i] == SortArray[z7])
        {
            ArrayLabel[j++]=z7;
            z7=16;
        }
        else if(TempDValue[i] == SortArray[z8])
        {
            ArrayLabel[j++]=z8;
            z8=16;
        }
        else if(TempDValue[i] == SortArray[z9])
        {
            ArrayLabel[j++]=z9;
            z9=16;
        }
        else if(TempDValue[i] == SortArray[z10])
        {
            ArrayLabel[j++]=z10;
            z10=16;
        }
        else if(TempDValue[i] == SortArray[z11])
        {
            ArrayLabel[j++]=z11;
            z11=16;
        }
        else if(TempDValue[i] == SortArray[z12])
        {
            ArrayLabel[j++]=z12;
            z12=16;
        }
        else if(TempDValue[i] == SortArray[z13])
        {
            ArrayLabel[j++]=z13;
            z13=16;
        }
        else if(TempDValue[i] == SortArray[z14])
        {
            ArrayLabel[j++]=z14;
            z14=16;
        }
        else if(TempDValue[i] == SortArray[z15])
        {
            ArrayLabel[j++]=z15;
            z15=16;
        }        
    }   
}
#include <stdio.h>
#include <cstring>
void SelectionSort(int *arr, int *order, int n)
{
    for (int i = 0; i < n; i++)
    {
        order[i] = i;
    }
    for (int i = 0; i < n; i++)
    {
        int Minkey = arr[i];
        int order_num = order[i];
        for (int j = i; j < n; j++)
        {
            if (Minkey > arr[j])
            {
                int temp = arr[j];
                arr[j] = Minkey;
                Minkey = temp;

                int temp2 = order[j];
                order[j] = order_num;
                order_num = temp2;
            }
        }
        arr[i] = Minkey;

        order[i] = order_num;
    }
}

int main()
{
    int a[] = {1, 1, 1, 1, -3};
    int b[10];
    int order[10];
    int k = 0;
    int n = sizeof(a) / sizeof(int);
    memcpy(&b, &a, sizeof(a));
    SelectionSort(a, order, n);
    printf("The sorted array is:");
    printf("\n");
    for (int i = 0; i < n; i++)
    {
        printf(" %d", b[i]);
    }
    printf("\n");
    for (int i = 0; i < n; i++)
    {
        printf(" %d", a[i]);
    }
    printf("\n");
    for (int i = 0; i < n; i++)
    {
        printf(" %d", order[i]);
    }
    printf("\n");
    return 0;
}

米杰的声音
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数组排序同时返回元素在原数组中的位置
白马负金羁
10-27 1万+
对数组中的元素进行排序是非常基础的问题，从现有的众多排序算法中任选一种即可实现。但是如果要求排序后同时返回新的（有序）数组中每个元素在旧的（未排序）数组中之原始位置，问题可能就变得有些棘手了
【C语言】选择排序
m0_58863372的博客
01-18 1231
题目：输入 10 个整数，将这 10 个整数按升序排列输出，并且奇数在前，偶数在后。比如， 如果输入的 10 个数是 1 2 3 4 5 6 7 8 9 10，则输出 1 3 5 7 9 2 4 6 8 10。 思路：将输入的 10 个整数，按其就行分别放在数组 a 的左部和右部。其具体方法就是 设置两个整型变量 odd 和 even，分别表示奇数和偶数存放在数组 a 中元素的下标，odd初始 值为 0，每存放一个奇数 odd 就加 1，even初始值为 9，每存放一个偶数 even 就减 1，然后通
排序一个数组（数组元素有重复的）,并且记住新数组的元素在原数组中的位置
xwq的博客
09-13 2141
//保留数组的初始下标 int[] index_init = new int[array.length]; for (int i = 0; i &amp;amp;lt; index_init.length; i++) { index_init[i] = i; } for (int i = 0; i &amp;amp;lt; array.l...
让无序数组元素进行排序，排序完后将排序后元素对应的原先元素的位置输出
smallgyy的专栏
12-04 7720
题目： 让无序数组元素进行排序，排序完后将排序后元素对应的原先元素的位置输出 （1）方法1 方法1：先将数组元素原先的对应位置记录在另一个数组中        并在进行选择排序的过程中，交换数组元素的同时也交换对应位置数组中的对应元素值 /* 选择法排序 并在排序后的数组元素在原先数组的对应位置输出 方法1：先将数组元素原先的对应位置记录在另一个数组中 并在进行选择
快速排序原理及实现（c语言实现，超详细）
一只懒猫的博客
02-15 2310
这是我的第一篇博客，如果有不足之处希望大家指正在留言区指正。 我也是一个新手，在自学数据结构时了解到了这个排序算法，自己就产生了很浓的兴趣然后就研究了一下，不过这个排序算法据说是面试常考的一个题目，以下是我个人的一些心得。 虽然冒泡排序和快排一样，都是属于交换类的排序，那快速排序为什么比冒泡快？快话不多说，先举个例子。 ...
C 排序问题 SDUT
zhangzhaolin12的博客
12-20 1826
Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 输入10个整数，将它们从小到大排序后输出，并给出现在每个元素在原来序列中的位置。 Input 输入数据有一行，包含10个整数，用空格分开。 Output 输出数据有两行，第一行为排序后的序列，第二行为排序后各个元素在原来序列中的位置。 Sample Input 1...
如何将任意长度的一维数组排序，并输出排序后的元素在原数组中的位置。
qq_67513034的博客
01-10 453
如何将任意长度的一维数组排序，并输出排序后的元素在原数组中的位置。
c语言合并两个已排序数组的示例(c语言数组排序)
01-20
问题：将两个已排序数组合并成一个排序数组 这里先不考虑大数据量的情况(在数据量很大时不知大家有什么好的思路或方法？)，只做简单数组的处理。 简单代码如下： 说明：之所以把merge函数定义成返回数组长度，是因为...
C语言实现选择排序、冒泡排序和快速排序的代码示例
09-02
在本文中，我们将探讨三种经典的排序算法：选择排序、冒泡排序和快速排序，并通过C语言的代码示例来理解它们的工作原理。 1. **选择排序（Selection Sort）** 选择排序是一种简单直观的排序算法。它的工作原理是每...
C语言选择排序算法及实例代码
09-02
选择排序是一种简单直观的排序算法，它的基本思想是在未排序的序列中找到最小（或最大）的元素，存放到排序序列的起始位置，然后再从剩余未排序的元素中继续寻找最小（或最大）的元素，放到已排序序列的末尾。...
冒泡排序和简单选择排序c语言
03-14
冒泡排序 简单选择排序 c语言基础 排序算法 数组操作 排序算法实验 简单的c语言程序 排序算法输出
数组冒泡排序并记录原有位置
xuetoor的专栏
05-09 4368
#include /* 常规冒泡排序 */ void BubbleSort(int a[], int n) { int i = 0; int j = 0; int tmp = 0; for (i = 0; i n - 1; ++i) { for (j = 1; j n - i; ++j) {
数组排序并记录原位置c语言,一数组按顺序序存放，插入一个数，按原来排序规律放在相应位置...
weixin_39886547的博客
05-24 397
该楼层疑似违规已被系统折叠隐藏此楼查看此楼前面已经有一道类似的题目为这道题做铺垫，我已经做出来啦。前面的题目是这样的：用选择法对10个数进行排序。我的做法，就是一个个对比扫描，从左到右递增。代码如下：#include #define N 10int main (){int array[N];int i,j,k,temp; // i 为基准位置，j 为当前被扫描元素位置，k 用于暂存出现的较小的元...
输出排序后的值和排序前的位置（结构体）
最新发布
2301_80408845的博客
12-06 338
【代码】输出排序后的值和排序前的位置（结构体）
【C语言】快速排序输出排序前后以及每趟排序的结果
csdnabcaq的博客
03-24 2277
【代码】【C语言】快速排序输出排序前后以及每趟排序的结果。
c语言return大小排序,数组从大到小排序，并返回他们原先在数组的上标位置
weixin_30925033的博客
05-18 503
C/C++ code#include#includeint my_sort(int src[], int size, int index[]){int i, j;if (src == NULL || index == NULL)return 0;for (i = 0; i < size - 1; i++){for (j = i + 1; j < size; j++){if (src[j...
c语言输入10个数从小到大排序,C语言冒泡法排序：任意输入十个数排序（从小到大；从大到小）...
weixin_32334681的博客
05-20 1万+
满意答案#include"stdio.h"//从小到大排序void main(){int i,j,t,str[10];printf("请给数组str赋初值:\n");for(i=0;i<10;i++) //对数组进行初始化scanf("%d",str[i]);for(j=1;j<10;j++) //开始进行排序for(i=0;i<10-j...
【C语言】选择排序从小到大，从大到小，详细注释
热门推荐
qq_35094756的博客
02-01 3万+
【选择排序程序如下】 程序修改说明：程序中的if(b[j] < b[m])即是排序方式，< 即从小到大排序，改成 > 即从大到小排序 #include <stdio.h> int main() { #define LEN 10 int b[LEN];//1,3,2,9,8,7,6,5,4,0 int i, j, m, temp; printf("请输入10个整数："); for( i = 0; i < LEN; i++) s
归并排序算法
mantou_riji的博客
11-04 73
归并排序 题目： 归并排序： 给定你一个长度为 n 的整数数列。 请你使用归并排序对这个数列按照从小到大进行排序。 并将排好序的数列按顺序输出。 输入格式 输入共两行，第一行包含整数 n。 第二行包含 nn个整数（所有整数均在 1∼10^9范围内），表示整个数列。 输出格式 输出共一行，包含 n 个整数，表示排好序的数列。 数据范围 1≤n≤1000001≤n≤100000 输入样例： 5 3 1 2 4 5 输出样例： 1 2 3 4 5 代码： using namespace std; #includ
c语言用选择法对一个数组进行排序
04-23
好的，我可以为您提供一些C语言的代码，用选择法（也称为选择排序）对一个数组进行排序： ```c #include void selectionSort(int arr[], int n) { int i, j, min_idx; // 循环数组元素 for (i = 0; i ; i++) ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

米杰的声音

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

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

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

打赏作者

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

抵扣说明：

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

余额充值