电话薄算法源码

1. 两道编程算法题（两图一道），题目如下，可以给出算法思路或者源代码，源代码最好是C语言的

就会个第一题(因为第一题上已经给出了大致思路)

思路:用map容器(它的内部数据结构是一颗红黑树，查找和插入数据速度非常快)
map<int,st>a;//key(int)：设置为1~n的数;value(st):设置为key的前驱和后继；

这样一来就可以像链表快速插入数据，又可以像数组随机访问元素(key,就相当于数组的下标)

下面是代码和运行截图；

看代码前建议先了解一下map容器的具体用法;

#include<iostream>

#include<map>

#include<vector>

using namespace std;

struct st{//两个成员变量用来储存前驱和后继

int left;//0

int right;//1

st()

{

left=0;

right=0;

}

};

void input(map<int,st> &a)//输出

{

st t;

int s=0;

map<int,st>::iterator it;//迭代器(指针)

for(it=a.begin();it!=a.end();it++)//循环迭代

{

t=it->second;

if(t.left==0)//左边等于0,说明该数是第一个数

{

s=it->first;//记录key

break;

}

}

t=a[s];

cout<<s<<" ";

while(t.right!=0)//循环找当前数的右边的数(右边的为0，就说明该数是最后一个数)

{

cout<<t.right<<" ";

t=a[t.right];

}

}

int main()

{

st t,t_i,t_x,t_k,s;

map<int,st>a;

map<int,st>::iterator it;

int n,x,p,x_l,x_r;

cin>>n;

for(int i=1;i<=n;i++)//map容器赋初值(i,t)

//i:(key)下标;t:(value)结构体变量

{

a.insert(make_pair(i,t));

}

for(int i=2;i<=n;i++)

{

cin>>x>>p;

if(p==0)//x的左边插入i

{

t=a[x];

if(t.left==0)//x的左边没有数

{

t_x.left=i;

t_i.right=x;

a[x]=t_x;

a[i]=t_i;

}

else//x的左边有数

{

int x_left;

t_x=a[x];

x_left=t_x.left;

t_k=a[x_left];

t_i.right=x;

t_i.left=t_x.left;

t_k.right=i;

t_x.left=i;

a[x]=t_x;

a[i]=t_i;

a[x_left]=t_k;

}

}

else//x的右边插入i

{

t=a[x];

if(t.right==0)//x的右边没有数

{

t_x.right=i;

t_i.left=x;

a[x]=t_x;

a[i]=t_i;

}

else//x的左边有数

{

int x_right;

t_x=a[x];

x_right=t_x.right;

t_k=a[x_right];

t_i.left=x;

t_i.right=t_x.right;

t_k.left=i;

t_x.right=i;

a[x]=t_x;

a[i]=t_i;

a[x_right]=t_k;

}

}

}

for(it=a.begin();it!=a.end();it++)//循环迭代打印各个数之间的关系

{

cout<<it->first<<" ";

cout<<"左边:";

cout<<it->second.left<<" ";

cout<<"右边:";

cout<<it->second.right<<endl;

}

input(a);//打印序列

return 0;

}

/*

4

1 0

2 1

1 0

2 3 4 1

*/

2. 请大家使用C语言完成电话号码查询系统。 设有一个电话号码薄,它

有虚的，原来的宪法的电话号码的查询的系统有设置一个电话号码和QQ号码不就可以完成了

3. C# 实现的手机打电话 源码

这个要跟网络服务商 联通 等等 以及 手机服务商沟通 。。 因为打电话是要收费的 。。 不是免费就能打电话的 ！！ 当然有专门做这样的软件的公司 。。

4. 求一个Camellia算法的VB源码

c++算法

#

include "pch.h"

#ifdef WORD64_AVAILABLE

#include "camellia.h"
#include "misc.h"

NAMESPACE_BEGIN(CryptoPP)

// Define internal Camellia function macros

inline word64 Camellia::Base::F(word64 X)
{
word32 t1 = (word32)(X >> 32);
word32 t2 = (word32)(X & 0xFFFFFFFFL);
t2= (s2[GETBYTE(t2, 3)] << 24) |
(s3[GETBYTE(t2, 2)] << 16) |
(s4[GETBYTE(t2, 1)] << 8) |
(s1[GETBYTE(t2, 0)]);
t1= (s1[GETBYTE(t1, 3)] << 24) |
(s2[GETBYTE(t1, 2)] << 16) |
(s3[GETBYTE(t1, 1)] << 8) |
(s4[GETBYTE(t1, 0)]);
t1 ^= rotlFixed(t2, 8);
t2 ^= rotlFixed(t1, 16);
t1 ^= rotlFixed(t2, 24);
t2 ^= rotlFixed(t1, 24);
return ((word64)t2 << 32) | (word64)t1;
}

#define ROUND2(Xp, K1, K2) \
{ (Xp)[1] ^= F((Xp)[0] ^ K1); (Xp)[0] ^= F((Xp)[1] ^ K2); }

inline void Camellia::Base::FLlayer(word64 *x, word64 K1, word64 K2)
{
word32 Xl = (word32)(x[0] >> 32);
word32 Xr = (word32)(x[0] & 0xFFFFFFFFL);
Xr ^= rotlFixed(Xl & (word32)(K1 >> 32), 1);
Xl ^= (Xr | (word32)(K1 & 0xFFFFFFFFL));
x[0] = ((word64)Xl << 32) | (word64)Xr;

Xl = (word32)(x[1] >> 32);
Xr = (word32)(x[1] & 0xFFFFFFFFL);
Xl ^= (Xr | (word32)(K2 & 0xFFFFFFFFL));
Xr ^= rotlFixed(Xl & (word32)(K2 >> 32), 1);
x[1] = ((word64)Xl << 32) | (word64)Xr;
}

inline void rotl128(word64 *x, unsigned int bits)
{
word64 temp = x[0] >> (64 - bits);
x[0] = (x[0] << bits) | (x[1] >> (64 - bits));
x[1] = (x[1] << bits) | temp;
}

void Camellia::Base::UncheckedSetKey(CipherDir dir, const byte *key, unsigned int keylen)
{
AssertValidKeyLength(keylen);

m_rounds = (keylen >= 24) ? 4 : 3;
unsigned int kslen = (8 * m_rounds + 2);
m_key.New(8 * kslen);
word64 *ks = m_key;

FixedSizeSecBlock<word64, 32> keyword;
word64 *kw = keyword;

#define KL (kw+0)
#define KR (kw+2)
#define KA (kw+4)
#define KB (kw+6)

if (keylen == 16)
{
GetUserKey(BIG_ENDIAN_ORDER, kw, 2, key, keylen);
KA[0] = KL[0];
KA[1] = KL[1];
}
else
{
if (keylen == 24)
{
GetUserKey(BIG_ENDIAN_ORDER, kw, 3, key, keylen);
KR[1] = ~KR[0];
}
else
{
GetUserKey(BIG_ENDIAN_ORDER, kw, 4, key, keylen);
}
KA[0] = KL[0] ^ KR[0];
KA[1] = KL[1] ^ KR[1];
}
ROUND2(KA, W64LIT(0xA09E667F3BCC908B), W64LIT(0xB67AE8584CAA73B2));
KA[0] ^= KL[0];
KA[1] ^= KL[1];
ROUND2(KA, W64LIT(0xC6EF372FE94F82BE), W64LIT(0x54FF53A5F1D36F1C));

if (keylen == 16)
{
ks[0] = KL[0]; ks[1] = KL[1];
rotl128(KL, 15);
ks[4] = KL[0]; ks[5] = KL[1];
rotl128(KL, 30);
ks[10] = KL[0]; ks[11] = KL[1];
rotl128(KL, 15);
ks[13] = KL[1];
rotl128(KL, 17);
ks[16] = KL[0]; ks[17] = KL[1];
rotl128(KL, 17);
ks[18] = KL[0]; ks[19] = KL[1];
rotl128(KL, 17);
ks[22] = KL[0]; ks[23] = KL[1];

ks[2] = KA[0]; ks[3] = KA[1];
rotl128(KA, 15);
ks[6] = KA[0]; ks[7] = KA[1];
rotl128(KA, 15);
ks[8] = KA[0]; ks[9] = KA[1];
rotl128(KA, 15);
ks[12] = KA[0];
rotl128(KA, 15);
ks[14] = KA[0]; ks[15] = KA[1];
rotl128(KA, 34);
ks[20] = KA[0]; ks[21] = KA[1];
rotl128(KA, 17);
ks[24] = KA[0]; ks[25] = KA[1];
}
else
{
KB[0] = KA[0] ^ KR[0];
KB[1] = KA[1] ^ KR[1];
ROUND2(KB, W64LIT(0x10E527FADE682D1D), W64LIT(0xB05688C2B3E6C1FD));

ks[0] = KL[0]; ks[1] = KL[1];
rotl128(KL, 45);
ks[12] = KL[0]; ks[13] = KL[1];
rotl128(KL, 15);
ks[16] = KL[0]; ks[17] = KL[1];
rotl128(KL, 17);
ks[22] = KL[0]; ks[23] = KL[1];
rotl128(KL, 34);
ks[30] = KL[0]; ks[31] = KL[1];

rotl128(KR, 15);
ks[4] = KR[0]; ks[5] = KR[1];
rotl128(KR, 15);
ks[8] = KR[0]; ks[9] = KR[1];
rotl128(KR, 30);
ks[18] = KR[0]; ks[19] = KR[1];
rotl128(KR, 34);
ks[26] = KR[0]; ks[27] = KR[1];

rotl128(KA, 15);
ks[6] = KA[0]; ks[7] = KA[1];
rotl128(KA, 30);
ks[14] = KA[0]; ks[15] = KA[1];
rotl128(KA, 32);
ks[24] = KA[0]; ks[25] = KA[1];
rotl128(KA, 17);
ks[28] = KA[0]; ks[29] = KA[1];

ks[2] = KB[0]; ks[3] = KB[1];
rotl128(KB, 30);
ks[10] = KB[0]; ks[11] = KB[1];
rotl128(KB, 30);
ks[20] = KB[0]; ks[21] = KB[1];
rotl128(KB, 51);
ks[32] = KB[0]; ks[33] = KB[1];
}

if (dir == DECRYPTION) // reverse key schele order
{
std::swap(ks[0], ks[kslen-2]);
std::swap(ks[1], ks[kslen-1]);
for (unsigned int i=2; i<kslen/2; i++)
{
std::swap(ks[i], ks[kslen-1-i]);
}
}
}

typedef BlockGetAndPut<word64, BigEndian> Block;

void Camellia::Base::ProcessAndXorBlock(const byte *inBlock, const byte *xorBlock, byte *outBlock) const
{
FixedSizeSecBlock<word64, 16> mb;
word64 *m = mb;
const word64 *ks = m_key;

Block::Get(inBlock)(m[0])(m[1]);

m[0] ^= ks[0];
m[1] ^= ks[1];
ks += 2;
for (unsigned int i = m_rounds; i > 0; --i)
{
ROUND2(m, ks[0], ks[1]);
ROUND2(m, ks[2], ks[3]);
ROUND2(m, ks[4], ks[5]);
if (i != 1)
{
FLlayer(m, ks[6], ks[7]);
ks += 8;
}
else
{
m[0] ^= ks[7];
m[1] ^= ks[6];
}
}

Block::Put(xorBlock, outBlock)(m[1])(m[0]);
}

// The Camellia s-boxes

const byte Camellia::Base::s1[256] =
{
112,130,44,236,179,39,192,229,228,133,87,53,234,12,174,65,
35,239,107,147,69,25,165,33,237,14,79,78,29,101,146,189,
134,184,175,143,124,235,31,206,62,48,220,95,94,197,11,26,
166,225,57,202,213,71,93,61,217,1,90,214,81,86,108,77,
139,13,154,102,251,204,176,45,116,18,43,32,240,177,132,153,
223,76,203,194,52,126,118,5,109,183,169,49,209,23,4,215,
20,88,58,97,222,27,17,28,50,15,156,22,83,24,242,34,
254,68,207,178,195,181,122,145,36,8,232,168,96,252,105,80,
170,208,160,125,161,137,98,151,84,91,30,149,224,255,100,210,
16,196,0,72,163,247,117,219,138,3,230,218,9,63,221,148,
135,92,131,2,205,74,144,51,115,103,246,243,157,127,191,226,
82,155,216,38,200,55,198,59,129,150,111,75,19,190,99,46,
233,121,167,140,159,110,188,142,41,245,249,182,47,253,180,89,
120,152,6,106,231,70,113,186,212,37,171,66,136,162,141,250,
114,7,185,85,248,238,172,10,54,73,42,104,60,56,241,164,
64,40,211,123,187,201,67,193,21,227,173,244,119,199,128,158
};

const byte Camellia::Base::s2[256] =
{
224,5,88,217,103,78,129,203,201,11,174,106,213,24,93,130,
70,223,214,39,138,50,75,66,219,28,158,156,58,202,37,123,
13,113,95,31,248,215,62,157,124,96,185,190,188,139,22,52,
77,195,114,149,171,142,186,122,179,2,180,173,162,172,216,154,
23,26,53,204,247,153,97,90,232,36,86,64,225,99,9,51,
191,152,151,133,104,252,236,10,218,111,83,98,163,46,8,175,
40,176,116,194,189,54,34,56,100,30,57,44,166,48,229,68,
253,136,159,101,135,107,244,35,72,16,209,81,192,249,210,160,
85,161,65,250,67,19,196,47,168,182,60,43,193,255,200,165,
32,137,0,144,71,239,234,183,21,6,205,181,18,126,187,41,
15,184,7,4,155,148,33,102,230,206,237,231,59,254,127,197,
164,55,177,76,145,110,141,118,3,45,222,150,38,125,198,92,
211,242,79,25,63,220,121,29,82,235,243,109,94,251,105,178,
240,49,12,212,207,140,226,117,169,74,87,132,17,69,27,245,
228,14,115,170,241,221,89,20,108,146,84,208,120,112,227,73,
128,80,167,246,119,147,134,131,42,199,91,233,238,143,1,61
};

const byte Camellia::Base::s3[256] =
{
56,65,22,118,217,147,96,242,114,194,171,154,117,6,87,160,
145,247,181,201,162,140,210,144,246,7,167,39,142,178,73,222,
67,92,215,199,62,245,143,103,31,24,110,175,47,226,133,13,
83,240,156,101,234,163,174,158,236,128,45,107,168,43,54,166,
197,134,77,51,253,102,88,150,58,9,149,16,120,216,66,204,
239,38,229,97,26,63,59,130,182,219,212,152,232,139,2,235,
10,44,29,176,111,141,136,14,25,135,78,11,169,12,121,17,
127,34,231,89,225,218,61,200,18,4,116,84,48,126,180,40,
85,104,80,190,208,196,49,203,42,173,15,202,112,255,50,105,
8,98,0,36,209,251,186,237,69,129,115,109,132,159,238,74,
195,46,193,1,230,37,72,153,185,179,123,249,206,191,223,113,
41,205,108,19,100,155,99,157,192,75,183,165,137,95,177,23,
244,188,211,70,207,55,94,71,148,250,252,91,151,254,90,172,
60,76,3,53,243,35,184,93,106,146,213,33,68,81,198,125,
57,131,220,170,124,119,86,5,27,164,21,52,30,28,248,82,
32,20,233,189,221,228,161,224,138,241,214,122,187,227,64,79
};

const byte Camellia::Base::s4[256] =
{
112,44,179,192,228,87,234,174,35,107,69,165,237,79,29,146,
134,175,124,31,62,220,94,11,166,57,213,93,217,90,81,108,
139,154,251,176,116,43,240,132,223,203,52,118,109,169,209,4,
20,58,222,17,50,156,83,242,254,207,195,122,36,232,96,105,
170,160,161,98,84,30,224,100,16,0,163,117,138,230,9,221,
135,131,205,144,115,246,157,191,82,216,200,198,129,111,19,99,
233,167,159,188,41,249,47,180,120,6,231,113,212,171,136,141,
114,185,248,172,54,42,60,241,64,211,187,67,21,173,119,128,
130,236,39,229,133,53,12,65,239,147,25,33,14,78,101,189,
184,143,235,206,48,95,197,26,225,202,71,61,1,214,86,77,
13,102,204,45,18,32,177,153,76,194,126,5,183,49,23,215,
88,97,27,28,15,22,24,34,68,178,181,145,8,168,252,80,
208,125,137,151,91,149,255,210,196,72,247,219,3,218,63,148,
92,2,74,51,103,243,127,226,155,38,55,59,150,75,190,46,
121,140,110,142,245,182,253,89,152,106,70,186,37,66,162,250,
7,85,238,10,73,104,56,164,40,123,201,193,227,244,199,158
};

NAMESPACE_END

#endif // WORD64_AVAILABLE

5. 软电话开发SIp软电话源码在哪有免费下载android软电话,vc软电话,sip协议

思思软电话V2.0功能列表： 1、支持SIP协议。 2、支持录音功能。 3、支持电话本功能。 4、支持通话记录功能。 5、DTMF方式支持 RFC2833 或者 SIP INFO 6、语音编码方式支持 G729a或者G711方式 7、支持 不加密、RC4加密、VOS加密三种加密方式。 8、支持显余额功能。（目前支持SVSS、VOS显余额，需要在服务器上额外安装局端程序） 9、支持最小化与来电弹屏。 10、支持windows xp,win2000,win2003,win vista,win7 11、支持绿色安装版（也可制作安装包）。 12、支持保存多条账户信息。 13、支持广告弹窗功能。（需在服务器安装局端程序） 14、支持显示网络质量状态图。 15、支持最快服务器搜索功能。

请网络搜索思思软电话就可以找到卖家了。

6. excel表格电话簿怎么做 来个示例

准备工具/材料：装有windows 10的电脑一台，Microsoft Office 家庭和学生版 2016 excel软件。

excel表格电话簿做法如下：

1、首先，根据要设置的项目，选择第一行中的单元格作为标题行。

7. 谁能用C++帮我编写电话号码拨薄程序啊

最好先自己写，不正确贴上来我没给你参谋一下~
先给你一段参考，试着自己改改吧~
#include<iostream>
using namespace std;
struct tel
{
char name[20];
char number[15];// 此处用用字符型处理数字
};
void search1(tel toatal[],char name[], int n)
{
int intsearch=0;
for(int i=0;i<n;i++)
{
if(strcmp(toatal[i].name,name)==0)//姓名的精确查找
{
cout<<"你输入的姓名是:"<<toatal[i].name<<" "<<"对应的号码是:"<<toatal[i].number<<endl;
intsearch++;
}
}
if(intsearch==0)
{
cout<<"对不起，你输入的姓名没有在资料库里面，请重新选择功能1键，进行重新查找"<<endl;
}

}
void search2(tel toatal[],char number[], int n)//号码的精确查找
{
int intsearch=0;
for(int i=0;i<n;i++)
{
if(strcmp(toatal[i].number,number)==0)
{
cout<<toatal[i].name<<" "<<toatal[i].number<<endl;
intsearch++;
}
}
if(intsearch==0)
cout<<"对不起，没有你要找的记录"<<endl;
else
cout<<"共找到了"<<intsearch<<"条记录"<<endl;

}
void search3(tel toatal[],char name[], int n)//姓名模糊查询
{
int intsearch=0;
for(int i=0;i<n;i++)
{
if((toatal[i].name[0]==name[0])&&(toatal[i].name[1]==name[1]))// 直接判断
{
cout<<"姓名："<<toatal[i].name<<" "<<"学号:"<<toatal[i].number<<endl;
intsearch++;
}
}
if(intsearch==0)
cout<<"对不起，没有找到相关的记录!"<<endl;
else
cout<<"总共找到"<<intsearch<<"记录"<<endl;
}
void search4(tel toatal[],char number[], int n)//号码的模糊查询
{
int intsearch=0;
for(int i=0;i<n;i++)
for(int j=0;j<3;j++)
{
if(toatal[i].number[j]==number[j])//此可以把号码前三位一样的输出
{
if(j==2)
{
cout<<"学号对应的姓名:"<<toatal[i].name<<" "<<"对应的学号是"<<toatal[i].number<<endl;
intsearch++;
}
}
else
break;
}
if(intsearch==0)
cout<<"对不起，没有这样的学号"<<endl;
else
cout<<"总共找到"<<intsearch<<"条记录"<<endl;
}

main()
{
tel toatal[100];
char name[10], number[15];
int i=0;
int iSelect;
cout<<"请输入数据:"<<endl;
cout<<"注释：当输入的姓名为0时，而且输入的学号为0时，输入结束"<<endl;
for(;i<100;i++)
{
cout<<"请输入第"<<i+1<<"个姓名:";
cin>>toatal[i].name;
cout<<endl;
cout<<"请输入第"<<i+1<<"个号码:";
cin>>toatal[i].number;
cout<<endl;
if(toatal[i].name[0]=='0')
break;
}

cout<<"please input the number that your want to do:"<<endl;
cout<<"***********************************"<<endl;
cout<<" ***0:退出查询系统***"<<endl;
cout<<"***********************************"<<endl;
cout<<" ***1:姓名精确查找***"<<endl;
cout<<"***********************************"<<endl;
cout<<" ***2:号码精确查找***"<<endl;
cout<<"***********************************"<<endl;
cout<<" ***3:姓名模糊查找***"<<endl;
cout<<"***********************************"<<endl;
cout<<" ***4:号码模糊查找***"<<endl;
cout<<"***********************************"<<endl;
cout<<" ****** ****** "<<endl;
while(cin>>iSelect)
{
switch(iSelect)
{
case 0:
cout<<"!!!"<<endl;
return 0;
case 1:
cout<<"enter the search name(请输入要寻找的姓名信息):::"<<endl;//姓名的精确查找，输入全名
cin>>name;
search1(toatal,name,i);
break;
case 2:
cout<<"enter the search number(请输入要寻找的学号信息):::"<<endl;//号码的精确查找，输入全号码
cin>>number;
search2(toatal,number,i);
break;
case 3:
cout<<"enter the vague name(请输入一个姓氏):::"<<endl;//姓名模糊查找，只输入姓
cin>>name;
search3(toatal,name,i);
break;
case 4:
cout<<"enter the vague number(请输入号码的前三位):::"<<endl;//号码模糊查找，只输入号码前三位
cin>>number;
search4(toatal,number,i);
break;
default :
cout<<"please input the right number!!"<<endl;
break;
}
cout<<"请输入你要选择的功能键(0---4)"<<endl;
}
}

8. 在电话号码薄中任取一个电话号码，设后面4个数中的每一个数是等可能地取自0，1，2，…9，则后面四个

排列组合

如图

如果你认可我的回答，请点击“采纳答案”，祝学习进步！

手机提问的朋友在客户端右上角评价点【采纳】即可

9. 图解查找算法之插值查找（带源码）

在前面我们了解了二分查找，就是把一个集合的元素一分为二，用中间值和目标查找值相比较，直到要查找的值和中间值相等，则表示查找成功，反之表示不成功。为什么这里会再次提到二分查找呢？事实上，插值查找是二分查找的升级版。

用一个很简单的例子就可以把插值查找解释的很清楚。在字典里面找”boy”这个单词时，我们肯定不会从第一页开始找，而是从首字母为b的位置开始查找，然后再找到第二个字母在字母表中的位置，找到对应的位置后，重复这个过程，这样就可以快速的找到目标单词。

接下来就介绍一下插值查找吧。

我们知道的的二分查找有一个必要的前提，必须是有序的数组才可以进行二分查找，同样插值查找也只能用于一个呈线性增长的有序数组中。

首先我们在数组中找到左边索引low和右边的索引high，目标查找值key

在二分查找中mid表示数组的中间值，而插值查找中mid表示一个自适应处，插值查找每次是从自适应mid处开始查找，mid的计算方式为：low + (key – arr[low]) / (arr[high] – arr[low]) * (high - low)；在这里mid表示的就是目标值key在序列总的所占比。

源码：

int func(int arr[], int len, int key)

{

      int low,high,mid;

      low = 0;

      high = len-1;

  int h = (key-arr[low])/(arr[high]-arr[low]);

      while(low <= high)

      {

          mid = h * (high - low);

          if(key < arr[mid])

          {

              high = mid - 1;

          }

          else if(key > arr[mid])

          {

            low = mid + 1;

          }

          else

          {

              return mid;

          }

      }

    return -1;

  }

10. c语言编写一个程序，电话薄排序

修改后的程序
#include <stdio.h>
#define n 7
int main()
{
int i,j,ptr_2=0;
int a[n],*ptr_1;
ptr_1=&a[0];
printf("输入%d个数：",n);
for (i=0;i<n;i++)
{
scanf("%d",&a[i]);
}
printf("ok1\n");
for(i=0;i<n;i++)
{
for(j=0;j<n-i-1;j++)
{
if (*(ptr_1+j) < *(ptr_1+j+1))
{
ptr_2=*(ptr_1+j+1);
*(ptr_1+j+1)=*(ptr_1+j);
*(ptr_1+j)=ptr_2;
}
}
}
printf("排序后的数为： ");
for(i=0;i<n;i++)
{
printf("%d ",*ptr_1);
ptr_1++;
}
printf("\n");
return 0;
}
注意ptr_2是指针，未申请空间不能*ptr_2复值。