ord是什么意思

ord在PASCAL中有對(duì)應(yīng)的函數(shù)，強(qiáng)制轉(zhuǎn)換就可以,作用就是求一個(gè)字符對(duì)應(yīng)的ascii碼(AsciI碼就是字母在計(jì)算機(jī)中的二進(jìn)制編碼)的值。

杜集ssl適用于網(wǎng)站、小程序/APP、API接口等需要進(jìn)行數(shù)據(jù)傳輸應(yīng)用場(chǎng)景，ssl證書(shū)未來(lái)市場(chǎng)廣闊！成為創(chuàng)新互聯(lián)公司的ssl證書(shū)銷(xiāo)售渠道，可以享受市場(chǎng)價(jià)格4-6折優(yōu)惠！如果有意向歡迎電話聯(lián)系或者加微信：18982081108（備注：SSL證書(shū)合作）期待與您的合作！

pascal（結(jié)構(gòu)化編程語(yǔ)言）

Pascal的名稱(chēng)是為了紀(jì)念十七世紀(jì)法國(guó)著名哲學(xué)家和數(shù)學(xué)家BlaisePascal而來(lái)的，它由瑞士NiklausWirth教授于六十年代末設(shè)計(jì)并創(chuàng)立的。

Pascal語(yǔ)言語(yǔ)法嚴(yán)謹(jǐn)，層次分明，程序易寫(xiě)，可讀性強(qiáng)，是第一個(gè)結(jié)構(gòu)化編程語(yǔ)言。

Pascal計(jì)算機(jī)程序教程如今已經(jīng)有專(zhuān)業(yè)化課程，并且越來(lái)越完善和嚴(yán)格化。

Pascal有6個(gè)主要的版本，分別是ActionPascal、UnextendedPascal、ExtendedPascaL、Object-OrientedExtensionstoPascal、BorlandPascal和DelphiObjectPascal。

Pascal語(yǔ)言廣泛用于各種軟件，程序分為名稱(chēng)（program后自擬）、設(shè)置（var后規(guī)定）、開(kāi)始（begin)、程序（正文）、讀?。╮ead/readln）、結(jié)束（end），結(jié)構(gòu)層次強(qiáng)，嚴(yán)謹(jǐn)而又緊密。

c語(yǔ)言中ord()函數(shù)的功能是什么？

序數(shù)函數(shù)，函數(shù)返回值為字符在ASCII碼中的序號(hào)。

如：ord(‘a(chǎn)’)=97，ord(‘0’)=48，ord(true)=1 。

pascal中ord函數(shù)和length函數(shù)的作用

ord

沒(méi)有對(duì)應(yīng)的函數(shù)，強(qiáng)制轉(zhuǎn)換就可以,作用就是求一個(gè)字符對(duì)應(yīng)的ascii碼的值

length對(duì)應(yīng)的是

strlen，求字符串長(zhǎng)度

如

int

a

=

(int)'a';

#include

char

*p

=

"123";

int

len

=

strlen(p);

strlen參數(shù)不能傳入null指針

國(guó)家二級(jí)C語(yǔ)言結(jié)構(gòu)體問(wèn)題

程序開(kāi)始先定義了一個(gè)ord類(lèi)型的結(jié)構(gòu)

然后定義了一個(gè)數(shù)組dt[2]，該數(shù)組為ord類(lèi)型，并且對(duì)其進(jìn)行了顯式初始化

初始化結(jié)束后，變成如下?tīng)顟B(tài)：

dt[0].x = 1;

dt[0].y = 2;

dt[1].x = 3;

dt[1].y = 4;

主程序開(kāi)始后，先定義了一個(gè)ord類(lèi)型的指針p，并將數(shù)組dt[2]的首地址傳給該指針，換句話說(shuō)現(xiàn)在指針p指向數(shù)組dt所在的內(nèi)存區(qū)域。

緊接著是兩個(gè)輸出函數(shù)：

++p-x這條指令，根據(jù)其優(yōu)先級(jí)可以將其改寫(xiě)為:

++(p-x);該指令實(shí)際上是先得到dt[0].x的值，然后使該值自增.因此第一次輸出的結(jié)果為2。

++p-y這條指令同理，也可以將其改寫(xiě)為：

++(p-y);先得到dt[0].y的值，然后使該值自增，輸出結(jié)果為3。

程序運(yùn)行結(jié)束后dt數(shù)組變成如下?tīng)顟B(tài)：

dt[0].x = 2;

dt[0].y = 3;

dt[1].x = 3;

dt[1].y = 4;

可以通過(guò)DEBUG模式清楚的看到該過(guò)程的完整操作，LZ可以自己試試

C語(yǔ)言排序

//總共給你整理了7種排序算法：希爾排序，鏈?zhǔn)交鶖?shù)排序，歸并排序

//起泡排序，簡(jiǎn)單選擇排序，樹(shù)形選擇排序，堆排序,先自己看看吧，

//看不懂可以再問(wèn)身邊的人或者查資料,既然可以上網(wǎng)，我相信你所在的地方信息流通方式應(yīng)該還行,所有的程序全部在VC++6.0下編譯通過(guò)

//希爾排序

#includestdio.h

typedef int InfoType; // 定義其它數(shù)據(jù)項(xiàng)的類(lèi)型

#define EQ(a,b) ((a)==(b))

#define LT(a,b) ((a)(b))

#define LQ(a,b) ((a)=(b))

#define MAXSIZE 20 // 一個(gè)用作示例的小順序表的最大長(zhǎng)度

typedef int KeyType; // 定義關(guān)鍵字類(lèi)型為整型

struct RedType // 記錄類(lèi)型

{

KeyType key; // 關(guān)鍵字項(xiàng)

InfoType otherinfo; // 其它數(shù)據(jù)項(xiàng)，具體類(lèi)型在主程中定義

};

struct SqList // 順序表類(lèi)型

{

RedType r[MAXSIZE+1]; // r[0]閑置或用作哨兵單元

int length; // 順序表長(zhǎng)度

};

void ShellInsert(SqList L,int dk)

{ // 對(duì)順序表L作一趟希爾插入排序。本算法是和一趟直接插入排序相比，

// 作了以下修改：

// 1.前后記錄位置的增量是dk,而不是1;

// 2.r[0]只是暫存單元,不是哨兵。當(dāng)j=0時(shí),插入位置已找到。算法10.4

int i,j;

for(i=dk+1;i=L.length;++i)

if LT(L.r[i].key,L.r[i-dk].key)

{ // 需將L.r[i]插入有序增量子表

L.r[0]=L.r[i]; // 暫存在L.r[0]

for(j=i-dk;j0LT(L.r[0].key,L.r[j].key);j-=dk)

L.r[j+dk]=L.r[j]; // 記錄后移，查找插入位置

L.r[j+dk]=L.r[0]; // 插入

}

}

void print(SqList L)

{

int i;

for(i=1;i=L.length;i++)

printf("%d ",L.r[i].key);

printf("\n");

}

void print1(SqList L)

{

int i;

for(i=1;i=L.length;i++)

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);

printf("\n");

}

void ShellSort(SqList L,int dlta[],int t)

{ // 按增量序列dlta[0..t-1]對(duì)順序表L作希爾排序。算法10.5

int k;

for(k=0;kt;++k)

{

ShellInsert(L,dlta[k]); // 一趟增量為dlta[k]的插入排序

printf("第%d趟排序結(jié)果: ",k+1);

print(L);

}

}

#define N 10

#define T 3

void main()

{

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8},{55,9},{4,10}};

SqList l;

int dt[T]={5,3,1}; // 增量序列數(shù)組

for(int i=0;iN;i++)

l.r[i+1]=d[i];

l.length=N;

printf("排序前: ");

print(l);

ShellSort(l,dt,T);

printf("排序后: ");

print1(l);

}

/*****************************************************************/

//鏈?zhǔn)交鶖?shù)排序

typedef int InfoType; // 定義其它數(shù)據(jù)項(xiàng)的類(lèi)型

typedef int KeyType; // 定義RedType類(lèi)型的關(guān)鍵字為整型

struct RedType // 記錄類(lèi)型(同c10-1.h)

{

KeyType key; // 關(guān)鍵字項(xiàng)

InfoType otherinfo; // 其它數(shù)據(jù)項(xiàng)

};

typedef char KeysType; // 定義關(guān)鍵字類(lèi)型為字符型

#includestring.h

#includectype.h

#includemalloc.h // malloc()等

#includelimits.h // INT_MAX等

#includestdio.h // EOF(=^Z或F6),NULL

#includestdlib.h // atoi()

#includeio.h // eof()

#includemath.h // floor(),ceil(),abs()

#includeprocess.h // exit()

#includeiostream.h // cout,cin

// 函數(shù)結(jié)果狀態(tài)代碼

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

typedef int Status; // Status是函數(shù)的類(lèi)型,其值是函數(shù)結(jié)果狀態(tài)代碼，如OK等

typedef int Boolean; // Boolean是布爾類(lèi)型,其值是TRUE或FALSE

#define MAX_NUM_OF_KEY 8 // 關(guān)鍵字項(xiàng)數(shù)的最大值

#define RADIX 10 // 關(guān)鍵字基數(shù)，此時(shí)是十進(jìn)制整數(shù)的基數(shù)

#define MAX_SPACE 1000

struct SLCell // 靜態(tài)鏈表的結(jié)點(diǎn)類(lèi)型

{

KeysType keys[MAX_NUM_OF_KEY]; // 關(guān)鍵字

InfoType otheritems; // 其它數(shù)據(jù)項(xiàng)

int next;

};

struct SLList // 靜態(tài)鏈表類(lèi)型

{

SLCell r[MAX_SPACE]; // 靜態(tài)鏈表的可利用空間，r[0]為頭結(jié)點(diǎn)

int keynum; // 記錄的當(dāng)前關(guān)鍵字個(gè)數(shù)

int recnum; // 靜態(tài)鏈表的當(dāng)前長(zhǎng)度

};

typedef int ArrType[RADIX];

void InitList(SLList L,RedType D[],int n)

{ // 初始化靜態(tài)鏈表L（把數(shù)組D中的數(shù)據(jù)存于L中）

char c[MAX_NUM_OF_KEY],c1[MAX_NUM_OF_KEY];

int i,j,max=D[0].key; // max為關(guān)鍵字的最大值

for(i=1;in;i++)

if(maxD[i].key)

max=D[i].key;

L.keynum=int(ceil(log10(max)));

L.recnum=n;

for(i=1;i=n;i++)

{

L.r[i].otheritems=D[i-1].otherinfo;

itoa(D[i-1].key,c,10); // 將10進(jìn)制整型轉(zhuǎn)化為字符型,存入c

for(j=strlen(c);jL.keynum;j++) // 若c的長(zhǎng)度max的位數(shù),在c前補(bǔ)'0'

{

strcpy(c1,"0");

strcat(c1,c);

strcpy(c,c1);

}

for(j=0;jL.keynum;j++)

L.r[i].keys[j]=c[L.keynum-1-j];

}

}

int ord(char c)

{ // 返回k的映射(個(gè)位整數(shù))

return c-'0';

}

void Distribute(SLCell r[],int i,ArrType f,ArrType e) // 算法10.15

{ // 靜態(tài)鍵表L的r域中記錄已按(keys[0],…,keys[i-1])有序。本算法按

// 第i個(gè)關(guān)鍵字keys[i]建立RADIX個(gè)子表,使同一子表中記錄的keys[i]相同。

// f[0..RADIX-1]和e[0..RADIX-1]分別指向各子表中第一個(gè)和最后一個(gè)記錄

int j,p;

for(j=0;jRADIX;++j)

f[j]=0; // 各子表初始化為空表

for(p=r[0].next;p;p=r[p].next)

{

j=ord(r[p].keys[i]); // ord將記錄中第i個(gè)關(guān)鍵字映射到[0..RADIX-1]

if(!f[j])

f[j]=p;

else

r[e[j]].next=p;

e[j]=p; // 將p所指的結(jié)點(diǎn)插入第j個(gè)子表中

}

}

int succ(int i)

{ // 求后繼函數(shù)

return ++i;

}

void Collect(SLCell r[],ArrType f,ArrType e)

{ // 本算法按keys[i]自小至大地將f[0..RADIX-1]所指各子表依次鏈接成

// 一個(gè)鏈表，e[0..RADIX-1]為各子表的尾指針。算法10.16

int j,t;

for(j=0;!f[j];j=succ(j)); // 找第一個(gè)非空子表，succ為求后繼函數(shù)

r[0].next=f[j];

t=e[j]; // r[0].next指向第一個(gè)非空子表中第一個(gè)結(jié)點(diǎn)

while(jRADIX-1)

{

for(j=succ(j);jRADIX-1!f[j];j=succ(j)); // 找下一個(gè)非空子表

if(f[j])

{ // 鏈接兩個(gè)非空子表

r[t].next=f[j];

t=e[j];

}

}

r[t].next=0; // t指向最后一個(gè)非空子表中的最后一個(gè)結(jié)點(diǎn)

}

void printl(SLList L)

{ // 按鏈表輸出靜態(tài)鏈表

int i=L.r[0].next,j;

while(i)

{

for(j=L.keynum-1;j=0;j--)

printf("%c",L.r[i].keys[j]);

printf(" ");

i=L.r[i].next;

}

}

void RadixSort(SLList L)

{ // L是采用靜態(tài)鏈表表示的順序表。對(duì)L作基數(shù)排序，使得L成為按關(guān)鍵字

// 自小到大的有序靜態(tài)鏈表，L.r[0]為頭結(jié)點(diǎn)。算法10.17

int i;

ArrType f,e;

for(i=0;iL.recnum;++i)

L.r[i].next=i+1;

L.r[L.recnum].next=0; // 將L改造為靜態(tài)鏈表

for(i=0;iL.keynum;++i)

{ // 按最低位優(yōu)先依次對(duì)各關(guān)鍵字進(jìn)行分配和收集

Distribute(L.r,i,f,e); // 第i趟分配

Collect(L.r,f,e); // 第i趟收集

printf("第%d趟收集后:\n",i+1);

printl(L);

printf("\n");

}

}

void print(SLList L)

{ // 按數(shù)組序號(hào)輸出靜態(tài)鏈表

int i,j;

printf("keynum=%d recnum=%d\n",L.keynum,L.recnum);

for(i=1;i=L.recnum;i++)

{

printf("keys=");

for(j=L.keynum-1;j=0;j--)

printf("%c",L.r[i].keys[j]);

printf(" otheritems=%d next=%d\n",L.r[i].otheritems,L.r[i].next);

}

}

void Sort(SLList L,int adr[]) // 改此句(類(lèi)型)

{ // 求得adr[1..L.length]，adr[i]為靜態(tài)鏈表L的第i個(gè)最小記錄的序號(hào)

int i=1,p=L.r[0].next;

while(p)

{

adr[i++]=p;

p=L.r[p].next;

}

}

void Rearrange(SLList L,int adr[]) // 改此句(類(lèi)型)

{ // adr給出靜態(tài)鏈表L的有序次序，即L.r[adr[i]]是第i小的記錄。

// 本算法按adr重排L.r，使其有序。算法10.18(L的類(lèi)型有變)

int i,j,k;

for(i=1;iL.recnum;++i) // 改此句(類(lèi)型)

if(adr[i]!=i)

{

j=i;

L.r[0]=L.r[i]; // 暫存記錄L.r[i]

while(adr[j]!=i)

{ // 調(diào)整L.r[adr[j]]的記錄到位直到adr[j]=i為止

k=adr[j];

L.r[j]=L.r[k];

adr[j]=j;

j=k; // 記錄按序到位

}

L.r[j]=L.r[0];

adr[j]=j;

}

}

#define N 10

void main()

{

RedType d[N]={{278,1},{109,2},{63,3},{930,4},{589,5},{184,6},{505,7},{269,8},{8,9},{83,10}};

SLList l;

int *adr;

InitList(l,d,N);

printf("排序前(next域還沒(méi)賦值):\n");

print(l);

RadixSort(l);

printf("排序后(靜態(tài)鏈表):\n");

print(l);

adr=(int*)malloc((l.recnum)*sizeof(int));

Sort(l,adr);

Rearrange(l,adr);

printf("排序后(重排記錄):\n");

print(l);

}

/*******************************************/

//歸并排序

#includestdio.h

typedef int InfoType; // 定義其它數(shù)據(jù)項(xiàng)的類(lèi)型

#define EQ(a,b) ((a)==(b))

#define LT(a,b) ((a)(b))

#define LQ(a,b) ((a)=(b))

#define MAXSIZE 20 // 一個(gè)用作示例的小順序表的最大長(zhǎng)度

typedef int KeyType; // 定義關(guān)鍵字類(lèi)型為整型

struct RedType // 記錄類(lèi)型

{

KeyType key; // 關(guān)鍵字項(xiàng)

InfoType otherinfo; // 其它數(shù)據(jù)項(xiàng)，具體類(lèi)型在主程中定義

};

struct SqList // 順序表類(lèi)型

{

RedType r[MAXSIZE+1]; // r[0]閑置或用作哨兵單元

int length; // 順序表長(zhǎng)度

};

void Merge(RedType SR[],RedType TR[],int i,int m,int n)

{ // 將有序的SR[i..m]和SR[m+1..n]歸并為有序的TR[i..n] 算法10.12

int j,k,l;

for(j=m+1,k=i;i=mj=n;++k) // 將SR中記錄由小到大地并入TR

if LQ(SR[i].key,SR[j].key)

TR[k]=SR[i++];

else

TR[k]=SR[j++];

if(i=m)

for(l=0;l=m-i;l++)

TR[k+l]=SR[i+l]; // 將剩余的SR[i..m]復(fù)制到TR

if(j=n)

for(l=0;l=n-j;l++)

TR[k+l]=SR[j+l]; // 將剩余的SR[j..n]復(fù)制到TR

}

void MSort(RedType SR[],RedType TR1[],int s, int t)

{ // 將SR[s..t]歸并排序?yàn)門(mén)R1[s..t]。算法10.13

int m;

RedType TR2[MAXSIZE+1];

if(s==t)

TR1[s]=SR[s];

else

{

m=(s+t)/2; // 將SR[s..t]平分為SR[s..m]和SR[m+1..t]

MSort(SR,TR2,s,m); // 遞歸地將SR[s..m]歸并為有序的TR2[s..m]

MSort(SR,TR2,m+1,t); // 遞歸地將SR[m+1..t]歸并為有序的TR2[m+1..t]

Merge(TR2,TR1,s,m,t); // 將TR2[s..m]和TR2[m+1..t]歸并到TR1[s..t]

}

}

void MergeSort(SqList L)

{ // 對(duì)順序表L作歸并排序。算法10.14

MSort(L.r,L.r,1,L.length);

}

void print(SqList L)

{

int i;

for(i=1;i=L.length;i++)

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);

printf("\n");

}

#define N 7

void main()

{

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7}};

SqList l;

int i;

for(i=0;iN;i++)

l.r[i+1]=d[i];

l.length=N;

printf("排序前:\n");

print(l);

MergeSort(l);

printf("排序后:\n");

print(l);

}

/**********************************************/

//起泡排序

#includestring.h

#includectype.h

#includemalloc.h // malloc()等

#includelimits.h // INT_MAX等

#includestdio.h // EOF(=^Z或F6),NULL

#includestdlib.h // atoi()

#includeio.h // eof()

#includemath.h // floor(),ceil(),abs()

#includeprocess.h // exit()

#includeiostream.h // cout,cin

// 函數(shù)結(jié)果狀態(tài)代碼

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

typedef int Status;

typedef int Boolean;

#define N 8

void bubble_sort(int a[],int n)

{ // 將a中整數(shù)序列重新排列成自小至大有序的整數(shù)序列(起泡排序)

int i,j,t;

Status change;

for(i=n-1,change=TRUE;i1change;--i)

{

change=FALSE;

for(j=0;ji;++j)

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

{

t=a[j];

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

a[j+1]=t;

change=TRUE;

}

}

}

void print(int r[],int n)

{

int i;

for(i=0;in;i++)

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

printf("\n");

}

void main()

{

int d[N]={49,38,65,97,76,13,27,49};

printf("排序前:\n");

print(d,N);

bubble_sort(d,N);

printf("排序后:\n");

print(d,N);

}

/****************************************************/

//簡(jiǎn)單選擇排序

#includestdio.h

typedef int InfoType; // 定義其它數(shù)據(jù)項(xiàng)的類(lèi)型

#define MAXSIZE 20 // 一個(gè)用作示例的小順序表的最大長(zhǎng)度

typedef int KeyType; // 定義關(guān)鍵字類(lèi)型為整型

struct RedType // 記錄類(lèi)型

{

KeyType key; // 關(guān)鍵字項(xiàng)

InfoType otherinfo; // 其它數(shù)據(jù)項(xiàng)，具體類(lèi)型在主程中定義

};

struct SqList // 順序表類(lèi)型

{

RedType r[MAXSIZE+1]; // r[0]閑置或用作哨兵單元

int length; // 順序表長(zhǎng)度

};

int SelectMinKey(SqList L,int i)

{ // 返回在L.r[i..L.length]中key最小的記錄的序號(hào)

KeyType min;

int j,k;

k=i; // 設(shè)第i個(gè)為最小

min=L.r[i].key;

for(j=i+1;j=L.length;j++)

if(L.r[j].keymin) // 找到更小的

{

k=j;

min=L.r[j].key;

}

return k;

}

void SelectSort(SqList L)

{ // 對(duì)順序表L作簡(jiǎn)單選擇排序。算法10.9

int i,j;

RedType t;

for(i=1;iL.length;++i)

{ // 選擇第i小的記錄，并交換到位

j=SelectMinKey(L,i); // 在L.r[i..L.length]中選擇key最小的記錄

if(i!=j)

{ // 與第i個(gè)記錄交換

t=L.r[i];

L.r[i]=L.r[j];

L.r[j]=t;

}

}

}

void print(SqList L)

{

int i;

for(i=1;i=L.length;i++)

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);

printf("\n");

}

#define N 8

void main()

{

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};

SqList l;

int i;

for(i=0;iN;i++)

l.r[i+1]=d[i];

l.length=N;

printf("排序前:\n");

print(l);

SelectSort(l);

printf("排序后:\n");

print(l);

}

/************************************************/

//樹(shù)形選擇排序

#includestring.h

#includectype.h

#includemalloc.h // malloc()等

#includelimits.h // INT_MAX等

#includestdio.h // EOF(=^Z或F6),NULL

#includestdlib.h // atoi()

#includeio.h // eof()

#includemath.h // floor(),ceil(),abs()

#includeprocess.h // exit()

#includeiostream.h // cout,cin

// 函數(shù)結(jié)果狀態(tài)代碼

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

typedef int Status; // Status是函數(shù)的類(lèi)型,其值是函數(shù)結(jié)果狀態(tài)代碼，如OK等

typedef int Boolean; // Boolean是布爾類(lèi)型,其值是TRUE或FALSE

typedef int InfoType; // 定義其它數(shù)據(jù)項(xiàng)的類(lèi)型

#define MAXSIZE 20 // 一個(gè)用作示例的小順序表的最大長(zhǎng)度

typedef int KeyType; // 定義關(guān)鍵字類(lèi)型為整型

struct RedType // 記錄類(lèi)型

{

KeyType key; // 關(guān)鍵字項(xiàng)

InfoType otherinfo; // 其它數(shù)據(jù)項(xiàng)，具體類(lèi)型在主程中定義

};

struct SqList // 順序表類(lèi)型

{

RedType r[MAXSIZE+1]; // r[0]閑置或用作哨兵單元

int length; // 順序表長(zhǎng)度

};

void TreeSort(SqList L)

{ // 樹(shù)形選擇排序

int i,j,j1,k,k1,l,n=L.length;

RedType *t;

l=(int)ceil(log(n)/log(2))+1; // 完全二叉樹(shù)的層數(shù)

k=(int)pow(2,l)-1; // l層完全二叉樹(shù)的結(jié)點(diǎn)總數(shù)

k1=(int)pow(2,l-1)-1; // l-1層完全二叉樹(shù)的結(jié)點(diǎn)總數(shù)

t=(RedType*)malloc(k*sizeof(RedType)); // 二叉樹(shù)采用順序存儲(chǔ)結(jié)構(gòu)

for(i=1;i=n;i++) // 將L.r賦給葉子結(jié)點(diǎn)

t[k1+i-1]=L.r[i];

for(i=k1+n;ik;i++) // 給多余的葉子的關(guān)鍵字賦無(wú)窮大

t[i].key=INT_MAX;

j1=k1;

j=k;

while(j1)

{ // 給非葉子結(jié)點(diǎn)賦值

for(i=j1;ij;i+=2)

t[i].keyt[i+1].key?(t[(i+1)/2-1]=t[i]):(t[(i+1)/2-1]=t[i+1]);

j=j1;

j1=(j1-1)/2;

}

for(i=0;in;i++)

{

L.r[i+1]=t[0]; // 將當(dāng)前最小值賦給L.r[i]

j1=0;

for(j=1;jl;j++) // 沿樹(shù)根找結(jié)點(diǎn)t[0]在葉子中的序號(hào)j1

t[2*j1+1].key==t[j1].key?(j1=2*j1+1):(j1=2*j1+2);

t[j1].key=INT_MAX;

while(j1)

{

j1=(j1+1)/2-1; // 序號(hào)為j1的結(jié)點(diǎn)的雙親結(jié)點(diǎn)序號(hào)

t[2*j1+1].key=t[2*j1+2].key?(t[j1]=t[2*j1+1]):(t[j1]=t[2*j1+2]);

}

}

free(t);

}

void print(SqList L)

{

int i;

for(i=1;i=L.length;i++)

printf("(%d,%d)",L.r[i].key,L.r[i].otherinfo);

printf("\n");

}

#define N 8

void main()

{

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};

SqList l;

int i;

for(i=0;iN;i++)

l.r[i+1]=d[i];

l.length=N;

printf("排序前:\n");

print(l);

TreeSort(l);

printf("排序后:\n");

print(l);

}

/****************************/

//堆排序

#includestdio.h

typedef int InfoType; // 定義其它數(shù)據(jù)項(xiàng)的類(lèi)型

#define EQ(a,b) ((a)==(b))

#define LT(a,b) ((a)(b))

#define LQ(a,b) ((a)=(b))

#define MAXSIZE 20 // 一個(gè)用作示例的小順序表的最大長(zhǎng)度

typedef int KeyType; // 定義關(guān)鍵字類(lèi)型為整型

struct RedType // 記錄類(lèi)型

{

KeyType key; // 關(guān)鍵字項(xiàng)

InfoType otherinfo; // 其它數(shù)據(jù)項(xiàng)，具體類(lèi)型在主程中定義

};

struct SqList // 順序表類(lèi)型

{

RedType r[MAXSIZE+1]; // r[0]閑置或用作哨兵單元

int length; // 順序表長(zhǎng)度

};

typedef SqList HeapType; // 堆采用順序表存儲(chǔ)表示

void HeapAdjust(HeapType H,int s,int m) // 算法10.10

{ // 已知H.r[s..m]中記錄的關(guān)鍵字除H.r[s].key之外均滿足堆的定義，本函數(shù)

// 調(diào)整H.r[s]的關(guān)鍵字,使H.r[s..m]成為一個(gè)大頂堆(對(duì)其中記錄的關(guān)鍵字而言)

RedType rc;

int j;

rc=H.r[s];

for(j=2*s;j=m;j*=2)

{ // 沿key較大的孩子結(jié)點(diǎn)向下篩選

if(jmLT(H.r[j].key,H.r[j+1].key))

++j; // j為key較大的記錄的下標(biāo)

if(!LT(rc.key,H.r[j].key))

break; // rc應(yīng)插入在位置s上

H.r[s]=H.r[j];

s=j;

}

H.r[s]=rc; // 插入

}

void HeapSort(HeapType H)

{ // 對(duì)順序表H進(jìn)行堆排序。算法10.11

RedType t;

int i;

for(i=H.length/2;i0;--i) // 把H.r[1..H.length]建成大頂堆

HeapAdjust(H,i,H.length);

for(i=H.length;i1;--i)

{ // 將堆頂記錄和當(dāng)前未經(jīng)排序子序列H.r[1..i]中最后一個(gè)記錄相互交換

t=H.r[1];

H.r[1]=H.r[i];

H.r[i]=t;

HeapAdjust(H,1,i-1); // 將H.r[1..i-1]重新調(diào)整為大頂堆

}

}

void print(HeapType H)

{

int i;

for(i=1;i=H.length;i++)

printf("(%d,%d)",H.r[i].key,H.r[i].otherinfo);

printf("\n");

}

#define N 8

void main()

{

RedType d[N]={{49,1},{38,2},{65,3},{97,4},{76,5},{13,6},{27,7},{49,8}};

HeapType h;

int i;

for(i=0;iN;i++)

h.r[i+1]=d[i];

h.length=N;

printf("排序前:\n");

print(h);

HeapSort(h);

printf("排序后:\n");

print(h);

}

C語(yǔ)言，編寫(xiě)函數(shù)，將一個(gè)整數(shù)插入到一維數(shù)組的指定位置，并在主函數(shù)中調(diào)用該函數(shù)，在主函數(shù)中輸出結(jié)果

#include stdio.h

void insert(int a[],int n,int x,int k) ?//將數(shù)字X插入到已有n個(gè)元素的數(shù)組a中第k個(gè)位置

{for(int i=n;i=k;i--)

a[i]=a[i-1];

a[k-1]=x;

}

int main()

{int i,n,x,k,a[100];

printf("原有幾個(gè)數(shù)字：");

scanf("%d",n);

for(int i=0;in;i++)

a[i]=i+1;

printf("原有的數(shù)字：\n");

for(int i=0;in;i++)

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

printf("\n");

printf("要插入的數(shù)字：");

scanf("%d",x);

printf("要插到第幾個(gè)位置：");

scanf("%d",k);

insert(a,n,x,k);

printf("插入后的數(shù)字：\n");

for(int i=0;in+1;i++)

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

printf("\n");

return 0;

}