ord是什么意思

ord在PASCAL中有对应的函数，强制转换就可以,作用就是求一个字符对应的ascii码(AsciI码就是字母在计算机中的二进制编码)的值。

杜集ssl适用于网站、小程序/APP、API接口等需要进行数据传输应用场景，ssl证书未来市场广阔！成为创新互联公司的ssl证书销售渠道，可以享受市场价格4-6折优惠！如果有意向欢迎电话联系或者加微信：18982081108（备注：SSL证书合作）期待与您的合作！

pascal（结构化编程语言）

Pascal的名称是为了纪念十七世纪法国著名哲学家和数学家BlaisePascal而来的，它由瑞士NiklausWirth教授于六十年代末设计并创立的。

Pascal语言语法严谨，层次分明，程序易写，可读性强，是第一个结构化编程语言。

Pascal计算机程序教程如今已经有专业化课程，并且越来越完善和严格化。

Pascal有6个主要的版本，分别是ActionPascal、UnextendedPascal、ExtendedPascaL、Object-OrientedExtensionstoPascal、BorlandPascal和DelphiObjectPascal。

Pascal语言广泛用于各种软件，程序分为名称（program后自拟）、设置（var后规定）、开始（begin)、程序（正文）、读取（read/readln）、结束（end），结构层次强，严谨而又紧密。

c语言中ord()函数的功能是什么？

序数函数，函数返回值为字符在ASCII码中的序号。

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

pascal中ord函数和length函数的作用

ord

没有对应的函数，强制转换就可以,作用就是求一个字符对应的ascii码的值

length对应的是

strlen，求字符串长度

如

int

a

=

(int)'a';

#include

char

*p

=

"123";

int

len

=

strlen(p);

strlen参数不能传入null指针

国家二级C语言结构体问题

程序开始先定义了一个ord类型的结构

然后定义了一个数组dt[2]，该数组为ord类型，并且对其进行了显式初始化

初始化结束后，变成如下状态：

dt[0].x = 1;

dt[0].y = 2;

dt[1].x = 3;

dt[1].y = 4;

主程序开始后，先定义了一个ord类型的指针p，并将数组dt[2]的首地址传给该指针，换句话说现在指针p指向数组dt所在的内存区域。

紧接着是两个输出函数：

++p-x这条指令，根据其优先级可以将其改写为:

++(p-x);该指令实际上是先得到dt[0].x的值，然后使该值自增.因此第一次输出的结果为2。

++p-y这条指令同理，也可以将其改写为：

++(p-y);先得到dt[0].y的值，然后使该值自增，输出结果为3。

程序运行结束后dt数组变成如下状态：

dt[0].x = 2;

dt[0].y = 3;

dt[1].x = 3;

dt[1].y = 4;

可以通过DEBUG模式清楚的看到该过程的完整操作，LZ可以自己试试

C语言排序

//总共给你整理了7种排序算法：希尔排序，链式基数排序，归并排序

//起泡排序，简单选择排序，树形选择排序，堆排序,先自己看看吧，

//看不懂可以再问身边的人或者查资料,既然可以上网，我相信你所在的地方信息流通方式应该还行,所有的程序全部在VC++6.0下编译通过

//希尔排序

#includestdio.h

typedef int InfoType; // 定义其它数据项的类型

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

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

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

#define MAXSIZE 20 // 一个用作示例的小顺序表的最大长度

typedef int KeyType; // 定义关键字类型为整型

struct RedType // 记录类型

{

KeyType key; // 关键字项

InfoType otherinfo; // 其它数据项，具体类型在主程中定义

};

struct SqList // 顺序表类型

{

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

int length; // 顺序表长度

};

void ShellInsert(SqList L,int dk)

{ // 对顺序表L作一趟希尔插入排序。本算法是和一趟直接插入排序相比，

// 作了以下修改：

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

// 2.r[0]只是暂存单元,不是哨兵。当j=0时,插入位置已找到。算法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]对顺序表L作希尔排序。算法10.5

int k;

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

{

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

printf("第%d趟排序结果: ",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}; // 增量序列数组

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);

}

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

//链式基数排序

typedef int InfoType; // 定义其它数据项的类型

typedef int KeyType; // 定义RedType类型的关键字为整型

struct RedType // 记录类型(同c10-1.h)

{

KeyType key; // 关键字项

InfoType otherinfo; // 其它数据项

};

typedef char KeysType; // 定义关键字类型为字符型

#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

// 函数结果状态代码

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等

typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE

#define MAX_NUM_OF_KEY 8 // 关键字项数的最大值

#define RADIX 10 // 关键字基数，此时是十进制整数的基数

#define MAX_SPACE 1000

struct SLCell // 静态链表的结点类型

{

KeysType keys[MAX_NUM_OF_KEY]; // 关键字

InfoType otheritems; // 其它数据项

int next;

};

struct SLList // 静态链表类型

{

SLCell r[MAX_SPACE]; // 静态链表的可利用空间，r[0]为头结点

int keynum; // 记录的当前关键字个数

int recnum; // 静态链表的当前长度

};

typedef int ArrType[RADIX];

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

{ // 初始化静态链表L（把数组D中的数据存于L中）

char c[MAX_NUM_OF_KEY],c1[MAX_NUM_OF_KEY];

int i,j,max=D[0].key; // max为关键字的最大值

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进制整型转化为字符型,存入c

for(j=strlen(c);jL.keynum;j++) // 若c的长度max的位数,在c前补'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的映射(个位整数)

return c-'0';

}

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

{ // 静态键表L的r域中记录已按(keys[0],…,keys[i-1])有序。本算法按

// 第i个关键字keys[i]建立RADIX个子表,使同一子表中记录的keys[i]相同。

// f[0..RADIX-1]和e[0..RADIX-1]分别指向各子表中第一个和最后一个记录

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个关键字映射到[0..RADIX-1]

if(!f[j])

f[j]=p;

else

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

e[j]=p; // 将p所指的结点插入第j个子表中

}

}

int succ(int i)

{ // 求后继函数

return ++i;

}

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

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

// 一个链表，e[0..RADIX-1]为各子表的尾指针。算法10.16

int j,t;

for(j=0;!f[j];j=succ(j)); // 找第一个非空子表，succ为求后继函数

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

t=e[j]; // r[0].next指向第一个非空子表中第一个结点

while(jRADIX-1)

{

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

if(f[j])

{ // 链接两个非空子表

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

t=e[j];

}

}

r[t].next=0; // t指向最后一个非空子表中的最后一个结点

}

void printl(SLList L)

{ // 按链表输出静态链表

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是采用静态链表表示的顺序表。对L作基数排序，使得L成为按关键字

// 自小到大的有序静态链表，L.r[0]为头结点。算法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改造为静态链表

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

{ // 按最低位优先依次对各关键字进行分配和收集

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)

{ // 按数组序号输出静态链表

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[]) // 改此句(类型)

{ // 求得adr[1..L.length]，adr[i]为静态链表L的第i个最小记录的序号

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

while(p)

{

adr[i++]=p;

p=L.r[p].next;

}

}

void Rearrange(SLList L,int adr[]) // 改此句(类型)

{ // adr给出静态链表L的有序次序，即L.r[adr[i]]是第i小的记录。

// 本算法按adr重排L.r，使其有序。算法10.18(L的类型有变)

int i,j,k;

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

if(adr[i]!=i)

{

j=i;

L.r[0]=L.r[i]; // 暂存记录L.r[i]

while(adr[j]!=i)

{ // 调整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域还没赋值):\n");

print(l);

RadixSort(l);

printf("排序后(静态链表):\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; // 定义其它数据项的类型

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

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

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

#define MAXSIZE 20 // 一个用作示例的小顺序表的最大长度

typedef int KeyType; // 定义关键字类型为整型

struct RedType // 记录类型

{

KeyType key; // 关键字项

InfoType otherinfo; // 其它数据项，具体类型在主程中定义

};

struct SqList // 顺序表类型

{

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

int length; // 顺序表长度

};

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]复制到TR

if(j=n)

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

TR[k+l]=SR[j+l]; // 将剩余的SR[j..n]复制到TR

}

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

{ // 将SR[s..t]归并排序为TR1[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)

{ // 对顺序表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

// 函数结果状态代码

#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中整数序列重新排列成自小至大有序的整数序列(起泡排序)

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);

}

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

//简单选择排序

#includestdio.h

typedef int InfoType; // 定义其它数据项的类型

#define MAXSIZE 20 // 一个用作示例的小顺序表的最大长度

typedef int KeyType; // 定义关键字类型为整型

struct RedType // 记录类型

{

KeyType key; // 关键字项

InfoType otherinfo; // 其它数据项，具体类型在主程中定义

};

struct SqList // 顺序表类型

{

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

int length; // 顺序表长度

};

int SelectMinKey(SqList L,int i)

{ // 返回在L.r[i..L.length]中key最小的记录的序号

KeyType min;

int j,k;

k=i; // 设第i个为最小

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)

{ // 对顺序表L作简单选择排序。算法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个记录交换

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);

}

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

//树形选择排序

#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

// 函数结果状态代码

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等

typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE

typedef int InfoType; // 定义其它数据项的类型

#define MAXSIZE 20 // 一个用作示例的小顺序表的最大长度

typedef int KeyType; // 定义关键字类型为整型

struct RedType // 记录类型

{

KeyType key; // 关键字项

InfoType otherinfo; // 其它数据项，具体类型在主程中定义

};

struct SqList // 顺序表类型

{

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

int length; // 顺序表长度

};

void TreeSort(SqList L)

{ // 树形选择排序

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

RedType *t;

l=(int)ceil(log(n)/log(2))+1; // 完全二叉树的层数

k=(int)pow(2,l)-1; // l层完全二叉树的结点总数

k1=(int)pow(2,l-1)-1; // l-1层完全二叉树的结点总数

t=(RedType*)malloc(k*sizeof(RedType)); // 二叉树采用顺序存储结构

for(i=1;i=n;i++) // 将L.r赋给叶子结点

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

for(i=k1+n;ik;i++) // 给多余的叶子的关键字赋无穷大

t[i].key=INT_MAX;

j1=k1;

j=k;

while(j1)

{ // 给非叶子结点赋值

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]; // 将当前最小值赋给L.r[i]

j1=0;

for(j=1;jl;j++) // 沿树根找结点t[0]在叶子中的序号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; // 序号为j1的结点的双亲结点序号

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; // 定义其它数据项的类型

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

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

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

#define MAXSIZE 20 // 一个用作示例的小顺序表的最大长度

typedef int KeyType; // 定义关键字类型为整型

struct RedType // 记录类型

{

KeyType key; // 关键字项

InfoType otherinfo; // 其它数据项，具体类型在主程中定义

};

struct SqList // 顺序表类型

{

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

int length; // 顺序表长度

};

typedef SqList HeapType; // 堆采用顺序表存储表示

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

{ // 已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义，本函数

// 调整H.r[s]的关键字,使H.r[s..m]成为一个大顶堆(对其中记录的关键字而言)

RedType rc;

int j;

rc=H.r[s];

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

{ // 沿key较大的孩子结点向下筛选

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

++j; // j为key较大的记录的下标

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

break; // rc应插入在位置s上

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

s=j;

}

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

}

void HeapSort(HeapType H)

{ // 对顺序表H进行堆排序。算法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)

{ // 将堆顶记录和当前未经排序子序列H.r[1..i]中最后一个记录相互交换

t=H.r[1];

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

H.r[i]=t;

HeapAdjust(H,1,i-1); // 将H.r[1..i-1]重新调整为大顶堆

}

}

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语言，编写函数，将一个整数插入到一维数组的指定位置，并在主函数中调用该函数，在主函数中输出结果

#include stdio.h

void insert(int a[],int n,int x,int k)  //将数字X插入到已有n个元素的数组a中第k个位置

{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("原有几个数字：");

scanf("%d",n);

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

a[i]=i+1;

printf("原有的数字：\n");

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

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

printf("\n");

printf("要插入的数字：");

scanf("%d",x);

printf("要插到第几个位置：");

scanf("%d",k);

insert(a,n,x,k);

printf("插入后的数字：\n");

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

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

printf("\n");

return 0;

}

文章标题：ord函数c语言 ord函数c语言需要引入什么函数库
当前URL：http://scyanting.com/article/hgijjg.html