编译任意从小加到大的程序

Ⅰ 编写程序,建立一个带有节点的单向链表，输入字符串，并按从小到大顺序组织到链表中

int main()

{

Link head; //链表(不带头节点)

int n;

printf("输入链表的长度n: ");

scanf("%d",&n);

printf("连续输入%d个数据(以空格隔开): ",n);

head=CreateLink(n);

printf(" 原本链表的节点是: ");

DispLink(head);

LinkSort(head);

printf(" 从大到小排序之后: ");

DispLink(head);

printf(" ");

return 0;

}

链表的具体存储表示为：

① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）

② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)）

链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。

以上内容参考：网络-单链表

Ⅱ 用C++6.0编译代码:任意输入一组数，实现从小到大的排列。

(1)2分法查找
(2)插入排序(稳定)

(3)冒泡排序(稳定)

(4)基数排序

(5)归并排序

(6)直接选择排序(不稳定)

(7)快速排序(不稳定)

(8)希尔排序(不稳定)

(9)堆排序

=================================================

(1)2分法查找有序连续内存

template <class C>

int bsearch(C value,iterator begin,iterator end){

iterator mid=& begin[(end-begin)/2];

if(*mid==value)return begin-mid;

else{

if(begin==end)return -1;

if(value<*mid)return
bsearch(value,begin,mid);

else return
bsearch(value,++mid,end);

}

return -1;

}

int main(void){

int buf2[]={1,3,9,10};

int idx=bsearch<int,int*>(1,buf2,&buf2[3]);

if(idx!=-1)printf("v=%d,pos=%d\n",buf2[idx],idx);

else printf("not found\n");

return 0;

}

(2)插入排序(稳定)----当然，可以用折半插入排序来提高性能

template <class T>

void isort(T begin,size_t length){

size_t l=length*sizeof(*begin);

T s=(T)malloc(l);

s[0]=begin[0];

for(int b=1;b<length;++b){

size_t
c=0;

for(;c<b;++c){

if(begin[b]<s[c]){

for(size_t k=b-c;k>0;--k){

s[c+k]=s[c+k-1];

}

break;

}

}

s[c]=begin[b];

}

memcpy(begin,s,l);

delete[] s;

}

main(...)

short buf2[]={11,3,9,10,7,6,15,2};

isort(buf2,8);

for(int
i=0;i<sizeof(buf2)/sizeof(short);++i)printf("%d ",buf2[i]);

(3)冒泡排序(稳定)
template <class T>

void bubsort(T s,size_t len){

for(int i=0;i<len-1;++i){//loop count

int
op=0;

for(int m=0;m<len-i;++m){

if(s[m]>s[m+1]){

int tmp=s[m];

s[m]=s[m+1];

s[m+1]=tmp;

op=1;

}

}

if(!op)return;

}

}

(4)基数排序:O(nlog(r)m)其中r为所采取的基数，而logr(n)=m为堆数，在某些时候，基数排序法的效率高于其它的比较性排序法。合理设计r和m的值，可以得到最有解。它利用了每次比较以后得到的历史信息。需要根据需求具体设计，没有通用形式，必须根据具体问题的信息具体设计，例如扑克牌排序等。它的核心思想是利用数据的某方面的特定信息。下面的例子是排序如果各2位正数，使用了10个桶
#include<cstdio>

#include<cstdlib>

#include<algorithm>

#include<iterator>

#include<iostream>

//Radix,Bucket sort

#define DEMICAL 10

int buk[DEMICAL][DEMICAL+1];//bucket

short t[DEMICAL];//top;

int *p;

void getb(size_t b){

printf("\nt[b]=%d,",t[b]);

if(t[b]==0){

printf("buk[%d] is empty",b);

return;

}else{

for(int i=1;i<=t[b];++i){

printf("buk[%d,%d]=%d
",b,i,buk[b][i]);

*p++=buk[b][i];

}

}

}

void getall(){for(int a=0;a<DEMICAL;++a){getb(a);} printf("\n");}

int main(int argc, char *argv[])

{

int
pi[]={34,23,53,66,73,81,13,22,5,98,92,2,35,6,78,81,51,20,63,55,31,61,90,27,77};

int l=sizeof(pi)/sizeof(int);

#define PUSH(b,v) buk[b][++t[b]]=v

for(size_t i=0;i<l;++i){//low demical

int hvb=pi[i]%10;

PUSH(hvb,pi[i]);

}

p=pi;

getall();

(&pi[0],&pi[l],ostream_iterator<int>(cout," "));

printf("\n");

for(int st=0;st<DEMICAL;++st){t[st]=0;}

for(size_t i=0;i<l;++i){//high demical

int hvb=pi[i]/10;

PUSH(hvb,pi[i]);

}

p=pi;

getall();

(&pi[0],&pi[l],ostream_iterator<int>(cout," "));

printf("\n");

return 0;

}

(5)归并排序

template <class T>

void merge(T* begin,T* end,size_t len){

int es=sizeof(*begin);//元素大小

int ss=1;//sub size;//组内元素个数

while(ss<len){

int gs=ss<<1;

int group=len/gs+len%gs;//分组个数

if(gs>group)group=1;

printf("gsize=%d,group=%d,ss=%d===========\n",gs,group,ss);

for(int i=0;i<group;++i){

T* left=&begin[i*gs];

T* mid =&begin[i*gs+gs];

if(i==group-1)mid=end;//always process end element

mergesort<T*>(left,mid,end);//由于两部分已经有序，因此可以使用mergeList方法来实现合并

}

ss<<=1;

}

}
归并的递归实现

void merge(T* begin,T*end){

int* mid=(int*)( ( (int)begin+(int)end )/2 );

if(begin!=mid)merge(begin,mid);

if(mid!=end) merge(++mid,end);

mergesort<T*>(begin,mid,end);//实现方法同上

}

(6)直接选择排序(不稳定)

/*用法

int buf[]={7,3,5,2,4,9,3,12,1,6};

csort(buf,&buf[10]);

*/

template <class T>

void csort(T* begin,T* end){

for(T* b=begin;b!=end;++b){

T* n=b;

++n;

bool op=false;

while(n!=end){

T v=*b;

if(*n<v){

*n^=*b;

*b^=*n;

*n^=*b;

op=true;

}

++n;

}

if(op==false)return;

}

}

(7)快速排序(不稳定)----如果您的实现比我的更简短，欢迎对比:)

/*用法

int buf[]={17,3,15,2,4,9,3,12,1,6};

qsort(&buf[0],&buf[10]);

(&buf[0],&buf[10],ostream_iterator<int>(cout,"
"));

*/

#define swap(x,y) (x)^=(y);(y)^=(x);(x)^=(y)

template <class T>

void qsort(T begin,T end){

T left=begin;

if(++left>=end)return;//只有一个元素了

size_t m= ( (size_t)end-(size_t)begin )/(2*sizeof(T));//STL里面这个中间位置是怎么计算的? int*并没有distace和advance这样对应的迭代方法... ...

T mid=&begin[m];

swap(*begin,*mid);

T last=left;

for(;left!=end;++left){

if(*begin>*left){//找到了更小的数

if(left!=last){

swap(*left,*last);

}

++last;

}

}

qsort(begin,last);

qsort(last,end);

}

(8)希尔排序(不稳定)
可以理解为直接插入排序的变体。这里只给出伪代码:
首先实现一个直接插入排序

void isort(*begin,size_t offset,size_t number);
这里offset是插入排序的间隔，number是插入排序的元素个数

void shellsort(T begin,T end,size_t s){

for(int g=sqr(s);g>1;g=sqr(g)){/A/分组

size_t gs=s/g;//gs 是 group size

for(int n=0;n<gs;++n){//每次分组以后,处理某个组里面全部的元素

isort(begin+n*g, g, g);

}//每个组的所有元素

if(gs*g<s)isort(begin+gs*g,g,s-gs*g);//末尾剩余的元素

}//若干个组

}

(9)最后隆重推出百万级俱乐部成员:
堆排序。程序模板在gcc3.4.2下验证通过

#include<cstdio>

#include<cstdlib>

#include<cstdio>

#include<iostream>

#include<iterator>

using namespace std;

#define swap(x,y) (x)^=(y);(y)^=(x);(x)^=(y)

template <class T>

void hadjust(T heap,size_t len){

size_t sub=len/2;//不大于n/2的整数

while(sub){

size_t left =sub<<1;

size_t right=left+1;

int csub;//需要交换的子节点

if(right>len)csub=left;

else
csub=heap[left-1]>heap[right-1]?left:right;

if(heap[sub-1]>=heap[csub-1]){

--sub;

continue;

}

swap(heap[sub-1],heap[csub-1]);

--sub;

}

}

template <class T>

void hsort(T heap,size_t s){

while(s>1){

hadjust<T>(heap,s);

swap(heap[0],heap[s-1]);

--s;

}

}

int main(void){

int buf[]={17,3,15,2,4,9,3,12,1,6,8,12};

hsort(buf,12);

(&buf[0],&buf[12],ostream_iterator<int>(cout," "));

system("PAUSE");

return 0;

}

Ⅲ c语言编译，将输入的三个值以从小到大的顺序输出，下面的这段程序无法编译，是什么原因，请帮忙改正

你不觉得
scanf("%f,%f,%f",&a,&b,&c);
这句很奇怪吗？
%f之间为什么要加逗号啊。

指针啊，传递指针，传递变量无用。

另外，你的exchange函数为什么要返回“float"?即便如此，你函数内部也没有return 任何变量，编译都不会同过。把第一个float改成void.

最后，也是最关键的错误，你这整个思路就错了，如果是3 2 1，会进行如下操作:
3>2 变成2 3 1
3>1 变成2 1 3
2<3 不变
结果2 1 3

Ⅳ c语言 任意输入5个数从小到大排列 程序怎么写

#include <stdio.h>
int main(int argc, char *argv[])
{
int a[5]; /*保存5个数的数组*/
int i = 0 , j = 0; /*计数器*/
int m = 0 ; /*用于标识最小的那个数*/
int n; /*用于两个数的交换，中间值*/

/*从键盘接收5个数*/
for( i = 0 ; i < 5 ; i ++)
{
printf("请输入第%d个数", i + 1);
scanf("%d",&a[i]);
}

/*排序算法：选择排序*/
for( i = 0 ; i < 5 ; i ++)
{
m = i ;
for( j = i +1 ; j < 5 ; j ++)
if( a[j] < a[m] )
m = j ;
n = a[i];
a[i] = a[m];
a[m] = n;
}

/*输出*/
printf("经过排序后，这些数是:\n");
for( i = 0 ; i < 5 ;i ++)
printf("%d ",a[i]);
printf("\n");
return 0;
}

Ⅳ 编写C语言程序，把一个数组按从小到大的次序排列起来

源程序以及算法注释如下：

#define _CRT_SECURE_NO_WARNINGS//VS编译环境需要进行宏定义，VC6.0可忽略

#include<stdio.h>//输入输出头文件

int main()

{

int number[10], New_number[10];//定义数组的数据类型为整型

int i, j, m, n, k;//定义变量的数据类型为整型

printf("input 10 <int> number：");//文字提示

for (i = 0; i <= 9; i++)//用循环输入数值给数组number并赋给数组New_number

{

scanf("%d", &number[i]);//输入10个整形数字到数组中

New_number[i] = number[i];//数组number元素赋给数组New_number

}

for (n = 0; n <= 8; n++)//要进行(10-1)组比较

for (j = 0; j <= 8 - n; j++)//每组进行(10减第几组)次比较

{

if (number[j] > number[j + 1])//比较大小并将小的赋给前面的数组

{

k = number[j];//将相对较大的元素赋值给中间元素

number[j] = number[j + 1];//将相对较小的元素送达前面一个位置

number[j + 1] = k;//将中间变量元素送给后面一个位置

}

if (New_number[j] < New_number[j + 1])//比较大小并将大的赋给前面的数组

{

k = New_number[j + 1];//将相对较小的元素赋值给中间元素

New_number[j + 1] = New_number[j];//将相对较大的元素送达前面一个位置

New_number[j] = k;//将中间变量元素送给后面一个位置

}

}

printf("min-->max： ");//文字提示

for (m = 0; m <= 9; m++)//依次从小到大输出

printf("%d ", number[m]);//输出元素

printf(" ");

printf("max-->min： ");//文字提示

for (m = 0; m <= 9; m++)//依次从大到小输出

printf("%d ", New_number[m]);//输出元素

printf(" ");

return 0;

}

程序运行结果如下：

(5)编译任意从小加到大的程序扩展阅读：

其他简单实现程序：

#include<stdio.h>

int main()

{

int a[10]={0};

int i,j,temp;

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

{

scanf("%d",&a[i]);

}

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

{

for(j = 0;j<10-i-1;j++)

{

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

{

temp = a[j];

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

a[j+1] = temp;

}

}

}

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

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

return 0;

}

Ⅵ c++编译5个数从小到大排列的不用数组的程序

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<iostream>
#include<algorithm>

usingnamespacestd;

#definesize10000

inta,b,c,d,e;

voidswap(int&a,int&b){	//交换两个值
	intt=a;a=b;b=t;
}

intmain(){
	scanf("%d%d%d%d%d",&a,&b,&c,&d,&e);
	while((a>b)||(b>c)||(c>d)||(d>e)){
		if(a>b)	swap(a,b);
		if(b>c)	swap(b,c);
		if(c>d)	swap(c,d);
		if(d>e)swap(d,e);
	}
	printf("%d%d%d%d%d",a,b,c,d,e);	
}

Ⅶ 编写java程序：从命令行输入任意个整数，将它们从小到大的顺序输出到屏幕。

import java.util.Scanner;

public class aaa {
public static void main(String[] arg)
{
Scanner sc=new Scanner(System.in);
int []x=new int[3];
for(int i=0;i<3;i++){

System.out.println ("请输入:");
x[i]=Integer.parseInt(sc.next());
}
for (int i = 0; i<x.length-1; i++)
{
for (int j = i+1; j<x.length; j++)
{
if(x[i]>x[j])//小于是从大到小。
{
int t=x[i];
x[i]=x[j];
x[j]=t;
}
}

}
for (int i = 0; i<x.length; i++)
{
System.out.println (x[i]);
}
}

}

Ⅷ 在C语言中 编写一个程序实现从小到大排序

#include<stdio.h>
#include<stdlib.h>

intcmp(constvoid*a,constvoid*b)
{
return*(int*)a-*(int*)b;
}

intmain(intargc,char**argv)
{
inta[]={1,-2,53,49,144,65,267,98,112};
inti;

qsort(a,sizeof(a)/sizeof(int),sizeof(int),cmp);

for(i=0;i<sizeof(a)/sizeof(int);++i)
printf("%d",a[i]);

printf("
");

return0;
}

如果要自己实现排序函数的话

#include<stdio.h>

voidqsort(int*a,intleft,intright)
{
intp=(left+right)/2;//以中间数作为主元
intk=a[p];
inti=left,j=right;

while(i<j)
{
//从左边开始将大于主元的数放在主元右边
while((i<=p)&&(a[i]<=k))
++i;
if(i<p)
{
a[p]=a[i];
p=i;
}

//从右边开始将小于主元的数放在左边
while((j>=p)&&(a[j]>=k))
--j;
if(j>p)
{
a[p]=a[j];
p=j;
}
}

a[p]=k;
//如果左边的数大于1个则递归左边
if(p-left>1)
qsort(a,left,p-1);
//如果右边的数大于1个则递归右边
if(right-p>1)
qsort(a,p+1,right);
}

intmain(intargc,char**argv)
{
inta[]={1,-2,53,49,144,65,267,98,112};
inti;

qsort(a,0,sizeof(a)/sizeof(int)-1);

for(i=0;i<sizeof(a)/sizeof(int);++i)
printf("%d",a[i]);
printf("
");

return0;
}

Ⅸ 给任意的三个数字，要求按照从小到大输出，用SQL语句编写一个执行程序

declare @a1 int,@a2 int, @a3 int
select @a1=3,@a2=2,@a3=1 --赋值

select @a1 as a
union
select @a2 as a
union
select @a3 as a
order by a asc
PRINT '结果如网络中所示'

Ⅹ C++从1加到100的程序怎么写

#include <iostream.h>

int main()

{

int sum=0;

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

{

sum=sum+i;

}

cout<<sum<<endl;

return 0;

}