演算法升序

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