算法升序

1. 试编写一个算法 将升序的二叉排序树变为降序的二叉排序树

将一棵根为root的升序二叉排序树转为降序二叉排序树，算法思路是：
(1) 如果树root为空，算法结束；
(2) 将root的左子树转为降序二叉排序树，将root的右子树转为降序二叉排序树；
(3) 将root的左右孩子进行交换，即左孩子变为右孩子，右孩子变为左孩子。

在c语言下，用二叉链表表示二叉排序树，实现该算法的过程如下：
typedef char datatype;
typedef struct _node{
datatype data;
_node *lchild, *rchild;
}TNode, *PNode, BitTree, *PBitTnode, *PSearchTree;

void ChangeDescen(PSearchTree root) {//将根为root的升序二叉排序树转换为降序
PNode tmp;
if(root == NULL) return;
ChangeDescen(root->lchild);
ChangeDescen(root->rchild);
tmp = root->lchild;
root->lchild = root->rchild;
root->rchild = tmp;
}

2. 给定一个数列，如何用归并排序算法把它排成升序,用c语言实现。

void MergeSort(int x[],int n) { //非递归归并排序
//元素数组为x，其长度为n
int i,j,k1,k2,l;
int *a;
for(i=1;i<=n-1;i=i*2)//i为插入排序的子段长度
{
for(j=1;j<=n-1;j=j+2*i)//j为进行插入排序的子段起始位置
{
a=(int *)malloc(2*i*sizeof(int));
l=0;k1=j;k2=j+i;
while((l<2*i)&&(k2<=n-1)&&(k2<j+2*i)&&(k1<j+i))
{//子段中，比较，移至辅助内存
if(x[k1]<x[k2])
{
a[l++]=x[k1];k1++;
}
else
{
a[l++]=x[k2];k2++;
}
}
if((k2>n-1)||(k2>=j+2*i))
{//子段的后一段超出数组范围
for(;k1<j+i;k1++)
a[l++]=x[k1];
}
else//就只有第一段就超数组了
{
if(k1>=j+i)
{
for(;(k2<j+2*i)&&(k2<=n-1);k2++)
a[l++]=x[k2];
}
}
for(k1=0;k1<l;k1++)//最后移位
{
x[j+k1]=a[k1];
}free(a);
}
}
}

非递归的归并排序，我以前写的。
中间malloc与free的话，是为了方便管理不定大小的空间，这里需要malloc.h的头文件

3. 利用选择排序算法,对下面一组数进行排序（升序),并写出每趟排序结果:{49,38,65,97,76,13,27,59}

C语言实现冒泡排序
#include<stdio.h>
main(){
int myArray[]={49,38,65,97,76,13,27,59};
int i,j,temp;

for (i=1;i<8;i++) {

for (j=i+1; j<8; j++) {
if (myArray[j]>myArray[i]) {

temp=myArray[j];
myArray[j]=myArray[i];
myArray[i]=temp;

}
}

printf("第%d趟,%d",i+1,myArray[i]);
printf("\n");

}

}
运行结果为：
第一趟：13,38,65,97,76,49,27,59;
第二趟：13,27,65,97,76,49,38,59;
第三趟：13,27,38,97,76,49,65,59;
第四趟：13,27,38,49,76,97,65,59;
第五趟：13,27,38,49,59,97,65,76;
第六趟：13,27,38,49,59,65,97,76;
第七趟：13,27,38,49,59,65,76,97;
第八趟：13,27,38,49,59,65,76,97;

以下是用AS3.0语言写的：如果需要其它语言请说；

var myArray:Array=new Array(49,38,65,97,76,13,27,59);
var temp:Number;

for (var i:int=1; i<9; i++) {

for (var j:int=0; j<8; j++) {
if (myArray[j]>myArray[i]) {

temp=myArray[j];
myArray[j]=myArray[i-1];
myArray[i-1]=temp;

}
}

trace("第"+ i +"趟："+myArray);

}
//第1趟：59,38,49,65,97,13,27,76
//第2趟：38,76,49,59,65,13,27,97
//第3趟：38,49,97,59,76,13,27,65
//第4趟：38,49,59,97,76,13,27,65
//第5趟：76,38,49,59,65,13,97,27
//第6趟：76,38,49,59,65,13,97,27
//第7趟：97,76,38,49,59,13,65,27
//第8趟：97,76,38,49,59,13,65,27

4. c语言编程:对10个数冒泡排序（升序）。

#include<stdio.h>

intmain(){

intnumber[10]={95,45,15,78,84,51,24,12，34，23};

for(int j=0;j< 9;j++)

for(int i=0;i< 9 -j;i++） {

if(a[i]>a[i+1]) {

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

a[i+1]=temp; }

}

for(int i=0;i< 10;i++）{

printf（“%d”，a[i]）; }

}

插入排序

已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。

首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。

b[2]~b[m]用相同方法插入。

快速排序

快速排序是大家已知的常用排序算法中最快的排序方法。已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先任取数据a[x]作为基准。

比较a[x]与其它数据并排序，使a[x]排在数据的第k位，并且使a[1]~a[k-1]中的每一个数据<a[x]，a[k+1]~a[n]中的每一个数据>a[x]，然后采用分治的策略分别对a[1]~a[k-1]和a[k+1]~a[n]两组数据进行快速排序。

希尔排序

已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。

首先取一增量d(d<n)，将a[1]、a[1+d]、a[1+2d]……列为第一组，a[2]、a[2+d]、a[2+2d]……列为第二组……，a[d]、a[2d]、a[3d]……列为最后一组以次类推，在各组内用插入排序，然后取d'<d，重复上述操作，直到d=1。

5. 已知一个无序数组a[ n ],试编写一算法,实现数组的升序排列。

#include "stdio.h"
#include "stdlib.h"
#include "malloc.h"
#include "conio.h"
#include "windows.h"
#define N 8
int a[N];

void init(int a[]) //将排序的数字输入
{
int i;
printf("请输入[%d]个数字:\n",N);
for(i=0;i<N;i++)
scanf("%d",&a[i]);
}
void print(int a[]) // 打印
{
int i;
for(i=0;i<N;i++)
printf("%5d",a[i]);
printf("\n\n");
}

void sort(int a[])//排序
{
int i,j,x;
for(i=1;i<N;i++)
{
x=a[i];
j=i-1;
while((j>=0)&&(a[j]>x))
{
a[j+1]=a[j];
j--;
}

a[j+1]=x;
}
}

/*void main()
{
printf("现在开始排序!\n");
init(a);
system("cls");
print(a);
sort(a);
print(a);
}*/

void main()
{

char ch;
int h,temp=0;
labl:
system("cls");
printf("\t\t===========================================\n\n");
printf("\t\t---------------【1】.将排序的数字输入----\n\n");
printf("\t\t---------------【2】.排序----------------\n\n");
printf("\t\t---------------【3】.打印----------------\n\n");
printf("\t\t---------------【4】.退出----------------\n\n");

talla:
printf("请输入数字选项:_");
scanf("%d",&h);
switch(h)
{

case 1:

case 1: loop_1:
init(a);
printf("\n 添加成功 ！\n");
printf("是否重新 【Y/N】:_");
fflush(stdin);
ch=getchar();
printf("%c",ch);
if(ch=='y'||ch=='Y')
{
Sleep(500);
goto loop_1;
}
else{

printf("\n是否返回 【Y/N】:_");
fflush(stdin);
ch=getchar();
printf("%c",ch);
if(ch=='y'||ch=='Y')
{
Sleep(500);
goto loop_1;
}
else{
printf("\n谢谢 使用 !\n");
exit(0);
}
}

case 2:
printf("\n未排序数字(一共有【%d】个数字) :\n",N);
print(a);
printf("\n排序后的数字：\n");
sort(a);
print(a);
printf("\n是否返回菜单 【Y/N】:\n");
fflush(stdin);
ch=getchar();
printf("%c",ch);
if(ch=='y'||ch=='Y')
{
printf("\n正在返回菜单.....!\n");
Sleep(500);
goto labl;
}
else
{
printf("谢谢 使用 !\n");
exit(0);
}

case 3:

printf("\n一共有【%d】个数字 :\n",N);
print(a);
printf("\n 是否返回菜单 【Y/N】:_");
fflush(stdin);
ch=getchar();
printf("%c",ch);
if(ch=='y'||ch=='Y')
{
printf("正在返回菜单.....!");
Sleep(500);
goto labl;
}
else
{
printf("谢谢 使用 !\n");
exit(0);
}

case 4: printf("谢谢 使用"); exit(0);

default: printf("输入 有误 请重 输入 !");
goto talla;

}

}

6. 对10个整数进行排序（升序）。用C语言怎么编程

你好。。

适合使用冒泡排序法。示例如下：

#include<stdio.h>
#defineSIZE8

voidbubble_sort(inta[],intn);

voidbubble_sort(inta[],intn)//n为数组a的元素个数
{
inti,j,temp;
for(j=0;j<n-1;j++)
for(i=0;i<n-1-j;i++)
{
if(a[i]>a[i+1])//数组元素大小按升序排列
{
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
}
}
intmain()
{
intnumber[SIZE]={95,45,15,78,84,51,24,12};
inti;
bubble_sort(number,SIZE);
for(i=0;i<SIZE;i++)
{
printf("%d",number[i]);
}
printf("
");
}

希望有所帮助~

7. c语言 堆排序算法升序排列N个数

#include<cstdio>

intarr[120000];
intmain()
{
intT,n;
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
for(inti=1;i<=n;i++)
scanf("%d",&arr[i]);
sort(arr+1,arr+n+1);
for(inti=1;i<=n;i++)
printf("%d%c",arr[i],i==n?'
':'';
}
return0;
}

8. 升序排列是什么意思

升序：按从小到大的顺序排列(如1、3、5、6、7、9)。降序：就是按从大到小的顺序排列(如9、8、6、4、3、1)。

拓展资料：

排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。分内部排序和外部排序，若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。

反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。内部排序的过程是一个逐步扩大记录的有序序列长度的过程。

常见排序算法

快速排序、希尔排序、堆排序、直接选择排序不是稳定的排序算法，而基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序是稳定的排序算法。

9. c#:排序算法的实现。分别利用冒泡、直接插入、直接选择算法实现排序（升序）。

#region 冒泡排序( 100k无序0-100k 21秒 )
void mppx冒泡排序(int[] pxsz)
{
for (int j = 1; j < pxsz.Length; j++)
{
for (int i = 0; i < pxsz.Length - j; i++)
{
if (pxsz[i] > pxsz[i + 1])
{
int temp = pxsz[i + 1];
pxsz[i + 1] = pxsz[i];
pxsz[i] = temp;
}
}
}
}
#endregion

#region 选择排序( 100k无序0-100k 10秒 )
void xzpx选择排序(int[] pxsz)
{
int min_index;
for (int i = 0; i < pxsz.Length - 1; i++)
{
min_index = i;
for (int j = i + 1; j < pxsz.Length; j++)//每次扫描选择最小项
{
if (pxsz[j] < pxsz[min_index]) min_index = j;
}
if (min_index != i)//找到最小项交换，即将这一项移到列表中的正确位置
{
int temp = pxsz[i];
pxsz[i] = pxsz[min_index];
pxsz[min_index] = temp;
}
}
}
#endregion

#region 插入排序( 100k无序0-100k 5秒 )
void crpx插入排序(int[] pxsz)
{
for (int i = 1; i < pxsz.Length; i++)//循环从第二个数组元素开始，因为arr[0]作为最初已排序部分
{
int temp = pxsz[i];//temp标记为未排序第一个元素
int j = i - 1;
while (j >= 0 && pxsz[j] > temp)/*将temp与已排序元素从小到大比较，寻找temp应插入的位置*/
{
pxsz[j + 1] = pxsz[j];
j--;
}
pxsz[j + 1] = temp;
}

}
#endregion