電話薄演算法源碼

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復值。