C语言：用选择排序法对一个数组里的数进行排序，从小到大，要求选出小的进行排序

这样：

int a = (int )malloc(sizeof(int) n); //动态分配数组空间 ，有几个元素，n就是几。

for(i=0; i<n; i++)

{

a[i]=录入数值;

}

Sort(a, n);

for(j=0; j<n; j++)

{

printf("%d",a[ij);//输出的内容就是排序好了的

}

//下面方法是用来排序的

void Sort(int a, int n)

{

int i, j, temp;

for(i=0; i<n; i++)

{

for(j=i; j<n; j++)

{

if(a[i] > a[j])

{

temp = a[i];

a[i] = a[j];

a[j] = temp;

}

}

}

扩展资料：

注意事项

1、选择排序法是将序列分为两段，有序前列和无序后列，每次查找无序后列中最大元素，将其插入到有序前列的最末尾处，直至无序后列最后一个元素，最终排序后的序列为降序序列。

2、适用于包括数组和向量在内的序列。

3、选择排序与冒泡排序的区别是选择排序每次遍历时会记住最大元素的位置，只进行一次交换，而冒泡排序每次遍历时会交换两个顺序不合法的元素。

算法程序：

#include "stdafxh"

#include<iostream>

using namespace std;

void SelectSort(int A[],int n)

{

for(int i = 0;i < n;i++ )

{

int max =i;

for(int j = i+1;j < n;j++) //查找最大元素所在位置

{

if (A[j] > A[max])

max =j;

}

int temp = A[max];  //交换无序后列中首元素与最大元素的位置

A[max] = A[i];

A[i] = temp;

}

}

#include<stdioh>

#include<stdlibh>

void BubbleSort(int a[], const int first, const int last);//冒泡排序

void InsertSort(int a[], const int first, const int last);//插入排序

void SelectSort(int a[], const int first, const int last);//选择排序

void MergeSort(int a[], const int p, const int r);//合并排序

void QuickSort(int a[],const int p,const int r);//快速排序

void ShellSort(int a[],const int p,const int r,const int dlta[],const int t);//希尔排序

void HeapSort(int a[],const int p, int r); //堆排序

void StoogeSort(int a[],const int p,const int r);//Stooge排序(不用)算法复杂度没算清楚

void main()

{

//插入排序算法

int a[11] = {6,4,5,3,2,1};

int dlta[]={9,5,3,2,1};

//BubbleSort(a,0,5);

//InsertSort(a,0,5);

//SelectSort(a,0,5);

//MergeSort(a,0,5);

//QuickSort(a,0,5);

//ShellSort(a,0,5,dlta,5);

HeapSort(a,0,5);

//StoogeSort(a,0,5);

for(int i=0; i<=5;i++)

{

printf("%d ",a[i]);

}

}

/冒泡排序/

void BubbleSort(int a[], int first, int last)

{

//实现对数组a[]中a[first]到a[last]升序的“冒泡”排序

int i,j,temp;

for(i=first; i<=last; i++)

{

for(j=first; j< last-i; j++)

{

if(a[j] > a[j+1])

{

temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

}

}

/插入排序/

void InsertSort(int a[], int first, int last)

{

//实现对数组a[]中a[first]到a[last]升序的“插入”排序

//最坏情况为n的平方，，多用于小数组

int i,j,temp;

for(i=first+1; i<=last; i++)

{

temp = a[i];

j = i - 1;

while((j >= 0) && (a[j] > temp))

{

a[j+1] = a[j];

j--;

}

a[j+1] = temp;

}

}

/选择排序/

void SelectSort(int a[], int first, int last)

{

//实现对数组a[]中a[first]到a[last]升序的“选择”排序

int i, j, temp, num;

for(i=first; i<last; i++)

{

num = i;

for(j=i+1; j<=last; j++)

{

if(a[j] < a[num])

{

num = j;

}

}

if(i != num)

{

temp = a[num];

a[num] = a[i];

a[i] = temp;

}

}

}

/合并排序/

void Merge(int a[],const int p,const int q,const int r)

{

//合并排序算法中的实现合并的子程序

int iLLength,iRLength;

int L, R, i, j, k;

iLLength = q - p + 1;

iRLength = r - q;

L = (int )malloc(iLLengthsizeof(int)); //或者 C++中 new int[iLLength];

R = (int )malloc(iRLengthsizeof(int)); //或者 C++中 new int[iRLength];

if(L == 0 || R== 0)

{

printf("内存分配失败！！！");

return;

}

for(i=0; i<iLLength; i++)

{

L[i] = a[p+i];

}

for(j=0; j<iRLength; j++)

{

R[j] = a[q+j+1];

}

i = 0;

j = 0;

for(k=p; k<=r; k++)

{

if((i<iLLength) && (j<iRLength) && (L[i]<=R[j]) || (j == iRLength))

{

a[k] = L[i];

i++;

}

else if(j<iRLength)

{

a[k] = R[j];

j++;

}

}

free(R);free(L);

}

void MergeSort(int a[],const int p,const int r)

{

//合并排序算法-主程序

//nlg(n),系数较小

int q;

if(p<r)

{

q = (p+r)/2;

MergeSort(a,p,q);

MergeSort(a,q+1,r);

Merge(a,p,q,r);

}

}

/Stooge排序/

void StoogeSort(int a[],const int p,const int r)

{

//Stooge算法

int temp, k;

if(a[p]>a[r])

{

temp = a[p];

a[p] = a[r];

a[r] = temp;

}

if((p+1) >= r)

{

return;

}

k = (r-p+1)/3;

StoogeSort(a,p,r-k);

StoogeSort(a,p+k,r);

StoogeSort(a,p,r-k);

}

/快速排序/

int QuickPartition(int a[],const int p,const int r)

{

//快速排序的(关键)分治过程

int temp, x, i, j;

x = a[r];

i = p - 1;

for(j=p; j<r; j++)

{

if(a[j] <= x)

{

i = i + 1;

temp = a[i];

a[i] = a[j];

a[j] = temp;

}

}

temp = a[i+1];

a[i+1] = a[r];

a[r] = temp;

return (i+1);

}

/

void QuickSort(int a[],const int p,const int r)

{

//快速排序算法-主程序

//与下面的“尾递归实现方法”比较，缺点：右边数组的递归不是必须的，增加了运行堆栈深度和调用开销

int q;

if(p < r)

{

q = QuickPartition(a, p, r);

QuickSort(a, p, q-1);

QuickSort(a, q+1, r);

}

}

/

void QuickSort(int a[],int p,const int r)

{

//快速排序算法-主程序

//“尾递归实现方法”是对上面的快速排序主程序实现的一种优化

//系数较小,常用大数组

int q;

while(p < r)

{

q = QuickPartition(a, p, r);

QuickSort(a, p, q-1);

p = q + 1;

}

}

/希尔排序/

void ShellInsert(int a[],const int p,const int r, int dk)

{

//希尔排序算法的关键子程序-插入排序子程序

int i, j, temp;

for(i=p+dk; i<=r; i++)

{

if(a[i] < a[i-dk])

{

temp = a[i];

for(j=i-dk; ((j>=0) && (temp < a[j])); j -= dk)

{

a[j+dk] = a[j];

}

a[j+dk] = temp;

}

}

}

void ShellSort(int a[],const int p,const int r,const int dlta[],const int t)

{

//希尔排序算法-主程序

//按增量序列dlta[]中的前t个增量，实现对数组a[]中a[p]到a[r]的排序

//dlta[]可能取值如：1,2,3,5,9 dala[k]=2^(t-k+1)-1 其中0<=k<=t<=ld(b-1)

//增量序列的最后一个值必须是1

//增量序列中的值没有除1以外的因子， 其精确时间复杂度：数学上尚未解决的难题

int k;

for(k=0; k<t; k++)

{

ShellInsert(a,p,r,dlta[k]);

}

}

/堆排序/

//堆排序，不如快速排序

//但是可用其来实现“优先级队列”

int Parent(int i)

{

return ((i+1)/2-1);

}

int Right(int i)

{

return (2(i+1)-1);

}

int Left(int i)

{

return (2(i+1));

}

void Max_Heapify(int a[],const int hplast,const int i)

{

int l, r,largest,temp;

l = Left(i);

r = Right(i);

largest = ((l<=hplast) && (a[l]>a[i])) l:i;

if((r<=hplast) && (a[r]>a[largest]))

{

largest = r;

}

if(largest != i)

{

temp = a[i];

a[i] = a[largest];

a[largest] = temp;

Max_Heapify(a,hplast,largest);

}

}

void Build_Max_Heap(int a[],const int p, const int r)

{

int i;

for(i = (p+r)/2; i>=p; i--)

{

Max_Heapify(a,r,i);

}

}

void HeapSort(int a[],const int p, int r)

{

int i,temp;

Build_Max_Heap(a,p,r);

for(i = r; i > p; i--)

{

temp = a[p];

a[p] = a[i];

a[i] = temp;

r -= 1;

Max_Heapify(a,r,0);

}

}

第二种叫插值排序，不过我只会c#，java。

c#:

List<int> sList = new List<int>(ss);

for (int i = 0; i < sListCount; i++)

{

int tt = i;

for (int j = i - 1; j >= 0; j--)

{

int temp = 0;

if (sList[j] > sList[tt])

{

temp = sList[tt];

sListRemoveAt(tt);

sListInsert(j, temp);

tt--;

}

}

}

for (int i = 0; i < sListCount; i++)

{

ConsoleWriteLine(sList[i]);

}

public class MaoPao 

{

    public static void main(String args[])

    {

        int[] arr={2,1,3,4,6,5,7,8,9,0,10};

        //N是数组的元素个数，这样无论多少个数，直接修改arr中的元素就行了，

        //不需要调整循环次数

        int N = arrlength;       

        int temp=0;

        //冒泡排序：每次把最大的放到最后，N-i是因为第i次排序之后，

        //数组arr的最后i个数已经是按照大小顺序的了，所以不需要再排序了

        //比如第一次排序之后，最后一个数肯定是最大的，下一次只需要排前9个就行了。                                   

        for(int i=1;i<N;++i)

        {

            for(int j=0;j<N-i;++j)          

            {

                //如果前面的数比后面的大，则不是按照顺序的，因此要交换

                if(arr[j]>arr[j+1])    

                {

                    temp=arr[j];           //交换2个数

                    arr[j]=arr[j+1];

                    arr[j+1]=temp;

                }

            }

        }

        for(int i=0;i<N;++i)         //输出排序后的结果

        {

            Systemoutprint(arr[i]+"  ");

        }

    }

}

忘采纳。

具体算法如下：

1、快速排序算法快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要Ο（n log n)次比较。在最坏状况下则需要Ο（n2)次比较，但这种状况并不常见。

2、堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

3、归并排序（Merge sort，台湾译作：合并排序）是建立在归并 *** 作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

4、二分查找算法是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜 素过程结束。

5、BFPRT算法解决的问题十分经典，即从某n个元素的序列中选出第k大（第k小）的元素，通过巧妙的分 析，BFPRT可以保证在最坏情况下仍为线性时间复杂度。

6、深度优先搜索算法，是搜索算法的一种。它沿着树的深度遍历树的节点，尽可能深的搜索树的分 支。当节点v的所有边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。

以上就是关于C语言：用选择排序法对一个数组里的数进行排序，从小到大，要求选出小的进行排序全部的内容，包括:C语言：用选择排序法对一个数组里的数进行排序，从小到大，要求选出小的进行排序、3. 用任意一种编程语言（C/C++/Java/C#/VB.NET）写出任意一种你所知的排序算法（比如：冒泡排序， 归并排、用一种算法实现排序~~小程序求助，在线等答案等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！