⑴ c語言怎樣將變數存入數組
我猜是因為數組初始化的值必須都是編譯期常量，而你的Adr是一個變數，跟它相關的(Adr>>4)*17,(Adr&0x0F)*17也都是變數，所以不能用來初始化數組。
可以把Adr定義為一個符號常量試試看，即
#defineAdr(0xA5)
來代替
u8Adr=0xA5;
⑵ C語言排序
//總共給你整理了7種排序演算法：希爾排序，鏈式基數排序，歸並排序
//起泡排序，簡單選擇排序，樹形選擇排序，堆排序,先自己看看吧，
//看不懂可以再問身邊的人或者查資料,既然可以上網，我相信你所在的地方信息流通方式應該還行,所有的程序全部在VC++6.0下編譯通過
//希爾排序
#include<stdio.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;j>0&<(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;k<t;++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;i<N;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; // 定義關鍵字類型為字元型
#include<string.h>
#include<ctype.h>
#include<malloc.h> // malloc()等
#include<limits.h> // INT_MAX等
#include<stdio.h> // EOF(=^Z或F6),NULL
#include<stdlib.h> // atoi()
#include<io.h> // eof()
#include<math.h> // floor(),ceil(),abs()
#include<process.h> // exit()
#include<iostream.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;i<n;i++)
if(max<D[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);j<L.keynum;j++) // 若c的長度<max的位數,在c前補'0'
{
strcpy(c1,"0");
strcat(c1,c);
strcpy(c,c1);
}
for(j=0;j<L.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;j<RADIX;++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(j<RADIX-1)
{
for(j=succ(j);j<RADIX-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;i<L.recnum;++i)
L.r[i].next=i+1;
L.r[L.recnum].next=0; // 將L改造為靜態鏈表
for(i=0;i<L.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;i<L.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);
}
/*******************************************/
//歸並排序
#include<stdio.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<=m&&j<=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;i<N;i++)
l.r[i+1]=d[i];
l.length=N;
printf("排序前:\n");
print(l);
MergeSort(l);
printf("排序後:\n");
print(l);
}
/**********************************************/
//起泡排序
#include<string.h>
#include<ctype.h>
#include<malloc.h> // malloc()等
#include<limits.h> // INT_MAX等
#include<stdio.h> // EOF(=^Z或F6),NULL
#include<stdlib.h> // atoi()
#include<io.h> // eof()
#include<math.h> // floor(),ceil(),abs()
#include<process.h> // exit()
#include<iostream.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;i>1&&change;--i)
{
change=FALSE;
for(j=0;j<i;++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;i<n;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);
}
/****************************************************/
//簡單選擇排序
#include<stdio.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].key<min) // 找到更小的
{
k=j;
min=L.r[j].key;
}
return k;
}
void SelectSort(SqList &L)
{ // 對順序表L作簡單選擇排序。演算法10.9
int i,j;
RedType t;
for(i=1;i<L.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;i<N;i++)
l.r[i+1]=d[i];
l.length=N;
printf("排序前:\n");
print(l);
SelectSort(l);
printf("排序後:\n");
print(l);
}
/************************************************/
//樹形選擇排序
#include<string.h>
#include<ctype.h>
#include<malloc.h> // malloc()等
#include<limits.h> // INT_MAX等
#include<stdio.h> // EOF(=^Z或F6),NULL
#include<stdlib.h> // atoi()
#include<io.h> // eof()
#include<math.h> // floor(),ceil(),abs()
#include<process.h> // exit()
#include<iostream.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;i<k;i++) // 給多餘的葉子的關鍵字賦無窮大
t[i].key=INT_MAX;
j1=k1;
j=k;
while(j1)
{ // 給非葉子結點賦值
for(i=j1;i<j;i+=2)
t[i].key<t[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;i<n;i++)
{
L.r[i+1]=t[0]; // 將當前最小值賦給L.r[i]
j1=0;
for(j=1;j<l;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;i<N;i++)
l.r[i+1]=d[i];
l.length=N;
printf("排序前:\n");
print(l);
TreeSort(l);
printf("排序後:\n");
print(l);
}
/****************************/
//堆排序
#include<stdio.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(j<m&<(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;i>0;--i) // 把H.r[1..H.length]建成大頂堆
HeapAdjust(H,i,H.length);
for(i=H.length;i>1;--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;i<N;i++)
h.r[i+1]=d[i];
h.length=N;
printf("排序前:\n");
print(h);
HeapSort(h);
printf("排序後:\n");
print(h);
}
⑶ c語言中的，adr<<=1;和adr=<<1;還有adr<<1.它們的區別
沒有第二種這樣的寫法
adr<<=1; 等同於 adr = adr<<1;
adr<<1，這只是個表達式，不能作為語句
⑷ C語言，編寫一個簡單的通訊錄管理系統
實現一個通訊錄管理系統；
通訊錄管理系統可以用來存儲1000個人的信息，每個人的信息包括：
姓名、性別、年齡、電話、住址
**提供方法：
1. 添加聯系人信息
2. 刪除指定聯系人信息
3. 查找指定聯系人信息
4. 修改指定聯系人信息
5. 顯示所有聯系人信息
6. 清空所有聯系人
7. 以名字排序所有聯系人**
1、linkman.h(頭文件）
3、程序運行結果部分示範：
⑸ 計算機二級C語言主要考點
引用。。：
數據結構與演算法
1 演算法
演算法：是指解題方案的准確而完整的描述。
演算法不等於程序，也不等計算機方法，程序的編制不可能優於演算法的設計。
演算法的基本特徵：是一組嚴謹地定義運算順序的規則，每一個規則都是有效的，是明確的，此順序將在有限的次數下終止。特徵包括：
（1）可行性；
（2）確定性，演算法中每一步驟都必須有明確定義，不充許有模稜兩可的解釋，不允許有多義性；
（3）有窮性，演算法必須能在有限的時間內做完，即能在執行有限個步驟後終止，包括合理的執行時間的含義；
（4）擁有足夠的情報。
演算法的基本要素：一是對數據對象的運算和操作；二是演算法的控制結構。
指令系統：一個計算機系統能執行的所有指令的集合。
基本運算和操作包括：算術運算、邏輯運算、關系運算、數據傳輸。
演算法的控制結構：順序結構、選擇結構、循環結構。
演算法基本設計方法：列舉法、歸納法、遞推、遞歸、減斗遞推技術、回溯法。
演算法復雜度：演算法時間復雜度和演算法空間復雜度。
演算法時間復雜度是指執行演算法所需要的計算工作量。
演算法空間復雜度是指執行這個演算法所需要的內存空間。
2 數據結構的基本基本概念
數據結構研究的三個方面：
（1）數據集合中各數據元素之間所固有的邏輯關系，即數據的邏輯結構；
（2）在對數據進行處理時，各數據元素在計算機中的存儲關系，即數據的存儲結構；
（3）對各種數據結構進行的運算。
數據結構是指相互有關聯的數據元素的集合。
數據的邏輯結構包含：
（1）表示數據元素的信息；
（2）表示各數據元素之間的前後件關系。
數據的存儲結構有順序、鏈接、索引等。
線性結構條件：
（1）有且只有一個根結點；
（2）每一個結點最多有一個前件，也最多有一個後件。
非線性結構：不滿足線性結構條件的數據結構。
3 線性表及其順序存儲結構
線性表由一組數據元素構成，數據元素的位置只取決於自己的序號，元素之間的相對位置是線性的。
在復雜線性表中，由若干項數據元素組成的數據元素稱為記錄，而由多個記錄構成的線性表又稱為文件。
非空線性表的結構特徵：
（1）且只有一個根結點a1，它無前件；
（2）有且只有一個終端結點an，它無後件；
（3）除根結點與終端結點外，其他所有結點有且只有一個前件，也有且只有一個後件。結點個數n稱為線性表的長度，當n=0時，稱為空表。
線性表的順序存儲結構具有以下兩個基本特點：
（1）線性表中所有元素的所佔的存儲空間是連續的；
（2）線性表中各數據元素在存儲空間中是按邏輯順序依次存放的。
ai的存儲地址為：adr(ai)=adr(a1)+(i-1)k,，adr(a1)為第一個元素的地址，k代表每個元素占的位元組數。
順序表的運算：插入、刪除。 （詳見14--16頁）
4 棧和隊列
棧是限定在一端進行插入與刪除的線性表，允許插入與刪除的一端稱為棧頂，不允許插入與刪除的另一端稱為棧底。
棧按照「先進後出」（filo）或「後進先出」（lifo）組織數據，棧具有記憶作用。用top表示棧頂位置，用bottom表示棧底。
棧的基本運算：（1）插入元素稱為入棧運算；（2）刪除元素稱為退棧運算；（3）讀棧頂元素是將棧頂元素賦給一個指定的變數，此時指針無變化。
隊列是指允許在一端（隊尾）進入插入，而在另一端（隊頭）進行刪除的線性表。rear指針指向隊尾，front指針指向隊頭。
隊列是「先進行出」（fifo）或「後進後出」（lilo）的線性表。
隊列運算包括（1）入隊運算：從隊尾插入一個元素；（2）退隊運算：從隊頭刪除一個元素。
循環隊列：s=0表示隊列空，s=1且front=rear表示隊列滿
5 線性鏈表
數據結構中的每一個結點對應於一個存儲單元，這種存儲單元稱為存儲結點，簡稱結點。
結點由兩部分組成：（1）用於存儲數據元素值，稱為數據域；（2）用於存放指針，稱為指針域，用於指向前一個或後一個結點。
2008-2-21 10:07 回復 鬥牛士 黛石Sara 2樓在鏈式存儲結構中，存儲數據結構的存儲空間可以不連續，各數據結點的存儲順序與數據元素之間的邏輯關系可以不一致，而數據元素之間的邏輯關系是由指針域來確定的。
鏈式存儲方式即可用於表示線性結構，也可用於表示非線性結構。
線性鏈表，head稱為頭指針，head=null（或0）稱為空表，如果是兩指針：左指針（llink）指向前件結點，右指針（rlink）指向後件結點。
線性鏈表的基本運算：查找、插入、刪除。
6 樹與二叉樹
樹是一種簡單的非線性結構，所有元素之間具有明顯的層次特性。
在樹結構中，每一個結點只有一個前件，稱為父結點，沒有前件的結點只有一個，稱為樹的根結點，簡稱樹的根。每一個結點可以有多個後件，稱為該結點的子結點。沒有後件的結點稱為葉子結點。
在樹結構中，一個結點所擁有的後件的個數稱為該結點的度，所有結點中最大的度稱為樹的度。樹的最大層次稱為樹的深度。
二叉樹的特點：（1）非空二叉樹只有一個根結點；（2）每一個結點最多有兩棵子樹，且分別稱為該結點的左子樹與右子樹。
二叉樹的基本性質：
（1）在二叉樹的第k層上，最多有2k-1(k≥1)個結點；
（2）深度為m的二叉樹最多有2m-1個結點；
（3）度為0的結點（即葉子結點）總是比度為2的結點多一個；
（4）具有n個結點的二叉樹，其深度至少為[log2n]+1,其中[log2n]表示取log2n的整數部分；
（5）具有n個結點的完全二叉樹的深度為[log2n]+1；
（6）設完全二叉樹共有n個結點。如果從根結點開始，按層序（每一層從左到右）用自然數1，2，….n給結點進行編號（k=1,2….n），有以下結論：
①若k=1，則該結點為根結點，它沒有父結點；若k>1，則該結點的父結點編號為int(k/2)；
②若2k≤n，則編號為k的結點的左子結點編號為2k；否則該結點無左子結點（也無右子結點）；
③若2k+1≤n，則編號為k的結點的右子結點編號為2k+1；否則該結點無右子結點。
滿二叉樹是指除最後一層外，每一層上的所有結點有兩個子結點，則k層上有2k-1個結點深度為m的滿二叉樹有2m-1個結點。
完全二叉樹是指除最後一層外，每一層上的結點數均達到最大值，在最後一層上只缺少右邊的若干結點。
二叉樹存儲結構採用鏈式存儲結構，對於滿二叉樹與完全二叉樹可以按層序進行順序存儲。
二叉樹的遍歷：
（1）前序遍歷（dlr），首先訪問根結點，然後遍歷左子樹，最後遍歷右子樹；
（2）中序遍歷（ldr），首先遍歷左子樹，然後訪問根結點，最後遍歷右子樹；
（3）後序遍歷（lrd）首先遍歷左子樹，然後訪問遍歷右子樹，最後訪問根結點。
7 查找技術
順序查找的使用情況：
（1）線性表為無序表；
（2）表採用鏈式存儲結構。
二分法查找只適用於順序存儲的有序表，對於長度為n的有序線性表，最壞情況只需比較log2n次。
8 排序技術
排序是指將一個無序序列整理成按值非遞減順序排列的有序序列。
交換類排序法：（1）冒泡排序法，需要比較的次數為n(n-1)/2； （2）快速排序法。
插入類排序法：（1）簡單插入排序法，最壞情況需要n(n-1)/2次比較；（2）希爾排序法，最壞情況需要o(n1.5)次比較。
選擇類排序法：（1）簡單選擇排序法,
最壞情況需要n(n-1)/2次比較；（2）堆排序法，最壞情況需要o(nlog2n)次比較。
⑹ C語言新手 做作業急...! C語言中 *adr 和*str表示的什麼
*adr 和*str你說的拷貝字元串的函數參數吧，其實只是參數的名字，沒什麼特別的，只不過系統函數這么寫，你只管用就行了
檢查頭字元不能為0，後面的只能是『0』——『9』之間的，你可以自己寫
⑺ c語言中& *的用法
for
(int
i=1;i<=3;++i)這種寫法完全沒問題，只不過是c99之後才支持的，而之前的c語言標准中變數申明必須放在語句塊的開頭。有些比較老的編譯器不支持新的標准，所以會報錯。你可以換個比較新的編譯器，比如vc2005、2008等等都可以。這樣的寫法現在是提倡的。
⑻ 請問430單片機中p0 = (unsigned char *)adr是什麼意思啊
沒用過這個單片機，從c語言的角度看。第一個表達式是把adr臨時轉換成uchar型變數然後賦予p0。如果adr是uint型，這段的作用就是把adr的低八位賦予p0。第二個表達式，*號一般用作乘號或者指針運算，作指針運算時*號的意思為指針變數所指向的變數。比如p存有變數a的地址，那麼*p等效於a。單片機的p0應該不算是指針變數，所以第二個我也不懂。
⑼ C語言課程設計
/******頭文件（.h）***********/
#include "stdio.h" /*I/O函數*/
#include "stdlib.h" /*標准庫函數*/
#include "string.h"/*字元串函數*/
#include "ctype.h" /*字元操作函數*/
#include "conio.h" /*控制台輸入輸出函數 */
#define M 50 /*定義常數表示記錄數*/
typedef struct /*定義數據結構*/
{
char name[20]; /*姓名*/
char units[30]; /*單位*/
char tele[20]; /*電話*/
char m_ph[20]; //手機
char rela[20]; //關系
char email[50]; //郵箱
char qq[20]; //qq
}ADDRESS;
/******以下是函數原型*******/
int enter(ADDRESS t[]); /*輸入記錄*/
void list(ADDRESS t[],int n); /*顯示記錄*/
void search(ADDRESS t[],int n); /*按姓名查找顯示記錄*/
int Delete(ADDRESS t[],int n); /*刪除記錄*/
int add(ADDRESS t[],int n); /*插入記錄*/
void save(ADDRESS t[],int n); /*記錄保存為文件*/
int load(ADDRESS t[]); /*從文件中讀記錄*/
void display(ADDRESS t[]); /*按序號查找顯示記錄*/
void sort(ADDRESS t[],int n); /*按姓名排序*/
void qseek(ADDRESS t[],int n); /*快速查找記錄*/
void print(ADDRESS temp); /*顯示單條記錄*/
int find(ADDRESS t[],int n,char *s) ; /*查找函數*/
int menu_select(); /*主菜單函數*/
/******主函數開始*******/
main()
{
system("color 37");//背景色為淺綠，前景色為白色
printf(" 歡迎使用通訊錄管理系統\n");//歡迎界面
int i;
ADDRESS adr[M]; /*定義結構體數組*/
int length; /*保存記錄長度*/
for(;;)/*無限循環*/
{
switch(menu_select()) /*調用主菜單函數，返回值整數作開關語句的條件*/
{
case 0:length=enter(adr);break;/*輸入記錄*/
case 1:list(adr,length);break; /*顯示全部記錄*/
case 2:search(adr,length);break; /*查找記錄*/
case 3:length=Delete(adr,length);break; /*刪除記錄*/
case 4:length=add(adr,length); break; /*插入記錄*/
case 5:save(adr,length);break; /*保存文件*/
case 6:length=load(adr); break; /*讀文件*/
case 7:display(adr);break; /*按序號顯示記錄*/
case 8:sort(adr,length);break; /*按姓名排序*/
case 9:qseek(adr,length);break; /*快速查找記錄*/
case 10:exit(0); /*如返回值為10則程序結束*/
}
}
}
/*菜單函數，函數返回值為整數，代表所選的菜單項*/
int menu_select()
{
char s[80];
int c;
printf("按任意鍵進入菜單......\n");/*提示按任意鍵繼續*/
getch(); /*讀入任意字元*/
system("cls"); /*清屏*/
printf(" ********************菜單***********************\n\n");
printf(" 0. 輸入記錄\n");
printf(" 1. 顯示所有記錄\n");
printf(" 2. 按姓名查找記錄\n");
printf(" 3. 刪除記錄\n");
printf(" 4. 添加記錄\n");
printf(" 5. 保存文件\n");
printf(" 6. 載入文件\n");
printf(" 7. 按序號顯示記錄\n");
printf(" 8. 記錄排序\n");
printf(" 9. 查找記錄\n");
printf(" 10. 退出\n");
printf(" ***********************************************\n");
do
{
printf("\n 請輸入選項(0~10):"); /*提示輸入選項*/
scanf("%d",&c);/*輸入選擇項*/
fflush(stdin);
}while(c<0 || c>10);/*選擇項不在0~10之間重輸*/
return c; /*返回選擇項，主程序根據該數調用相應的函數*/
}
/***輸入記錄，形參為結構體數組，函數值返回類型為整型表示記錄長度*/
int enter(ADDRESS t[])
{
int i,n;
char num[30];
system("cls"); /*清屏*/
int flag=1;
for(;;)
{
flag = 1;
system("cls"); /*清屏*/
printf("\n請輸入記錄數：\n"); /*提示信息*/
scanf("%s", &num); /*輸入記錄數*/
fflush(stdin);
for(int nima = 0; num[nima]; nima++)
{
if (num[nima] < 48 || num[nima] > 57)
{
flag = 0;
break;
}
}
if(flag==1)
break;
}
n=atoi(num);
printf("請輸入記錄：\n"); /*提示輸入記錄*/
printf("姓名 單位 電話 手機 關系 郵箱 QQ\n");
printf("--------------------------------------------------------------------------\n");
for(i=0;i<n;i++)
{
scanf("%s%s%s%s%s%s%s",t[i].name,t[i].units,t[i].tele,t[i].m_ph,t[i].rela,t[i].email,t[i].qq); /*輸入記錄*/
fflush(stdin);
for(int k=0;k<=19;k++)
{
if((t[i].tele[k]>='a' && t[i].tele[k]<='z' )|| (t[i].tele[k]>='A' && t[i].tele[k]<='Z'))
{
printf("電話輸入錯誤！請重新輸入聯系人信息\n");
i--;
break;
}
if((t[i].m_ph[k]>='a' && t[i].m_ph[k]<='z' )|| (t[i].m_ph[k]>='A' && t[i].m_ph[k]<='Z'))
{
printf("手機輸入錯誤！請重新輸入聯系人信息\n");
i--;
break;
}
if((t[i].qq[k]>='a' && t[i].qq[k]<='z' )|| (t[i].qq[k]>='A' && t[i].qq[k]<='Z'))
{
printf("QQ輸入錯誤！請重新輸入聯系人信息\n");
i--;
break;
}
}
printf("--------------------------------------------------------------------------\n");
}
return n; /*返回記錄條數*/
}
/*顯示記錄，參數為記錄數組和記錄條數*/
void list(ADDRESS t[],int n)
{
int i;
system("cls"); /*清屏*/
printf("\n\n************************************************************************\n");
printf("姓名 單位 電話 手機 關系 郵箱 QQ\n");
printf("--------------------------------------------------------------------------\n");
for(i=0;i<n;i++)
printf("%-10s%-14s%-12s%-12s%-10s%-12s%-14s\n",t[i].name,t[i].units,t[i].tele,t[i].m_ph,t[i].rela,t[i].email,t[i].qq);
if((i+1)%10==0) /*判斷輸出是否達到10條記錄*/
{
printf("按任意鍵顯示下一頁\n"); /*提示信息*/
getch(); /*按任意鍵繼續*/
}
printf("*********************************結束***********************************\n");
}
/*查找記錄*/
void search(ADDRESS t[],int n)
{
char s[20]; /*保存待查找姓名字元串*/
int i; /*保存查找到結點的序號*/
system("cls"); /*清屏*/
printf("請輸入待查找姓名：\n");
scanf("%s",s); /*輸入待查找姓名*/
i=find(t,n,s); /*調用find函數，得到一個整數*/
if(i>n-1) /*如果整數i值大於n-1，說明沒找到*/
{
printf("未找到!!!\n");
getch();
}
else
print(t[i]); /*找到，調用顯示函數顯示記錄*/
}
/*顯示指定的一條記錄*/
void print(ADDRESS temp)
{
system("cls"); /*清屏*/
printf("\n\n************************************************************************\n");
printf("姓名 單位 電話 手機 關系 郵箱 QQ\n");
printf("--------------------------------------------------------------------------\n");
printf("%-10s%-14s%-12s%-12s%-10s%-12s%-14s\n",temp.name,temp.units,temp.tele,temp.m_ph,temp.rela,temp.email,temp.qq);
printf("*********************************結束***********************************\n");
getchar();
}
/*查找函數，參數為記錄數組和記錄條數以及姓名s */
int find(ADDRESS t[],int n,char *s)
{
int i;
system("cls"); /*清屏*/
for(i=0;i<n;i++)/*從第一條記錄開始，直到最後一條*/
{
if(strcmp(s,t[i].name)==0) /*記錄中的姓名和待比較的姓名是否相等*/
return i; /*相等，則返回該記錄的下標號，程序提前結結束*/
}
return i; /*返回i值*/
getch();
}
/*刪除函數，參數為記錄數組和記錄條數*/
int Delete(ADDRESS t[],int n)
{
char s[20]; /*要刪除記錄的姓名*/
char ch;
int i,j;
system("cls"); /*清屏*/
printf("請輸入待刪除的姓名：\n"); /*提示信息*/
scanf("%s",s);/*輸入姓名*/
i=find(t,n,s); /*調用find函數*/
if(i>n-1) /*如果i>n-1超過了數組的長度*/
printf("未找到!!!\n"); /*顯示沒找到要刪除的記錄*/
else
{
print(t[i]); /*調用輸出函數顯示該條記錄信息*/
printf("確定刪除？(Y/N)\n"); /*確認是否要刪除*/
scanf("%c",&ch); /*輸入一個整數0或1*/
if(ch=='y' || ch=='Y') /*如果確認刪除輸入y*/
{
for(j=i+1;j<n;j++) /*刪除該記錄，實際後續記錄前移*/
{
strcpy(t[j-1].name,t[j].name); /*將後一條記錄的姓名拷貝到前一條*/
strcpy(t[j-1].units,t[j].units); /*將後一條記錄的單位拷貝到前一條*/
strcpy(t[j-1].tele,t[j].tele); /*將後一條記錄的電話拷貝到前一條*/
strcpy(t[j-1].m_ph,t[j].m_ph); /*將後一條記錄的手機拷貝到前一條*/
strcpy(t[j-1].rela,t[j].rela); /*將後一條記錄的關系拷貝到前一條*/
strcpy(t[j-1].email,t[j].email); /*將後一條記錄的郵箱拷貝到前一條*/
strcpy(t[j-1].qq,t[j].qq); /*將後一條記錄的qq拷貝到前一條*/
}
printf("刪除成功！\n");
n--; /*記錄數減1*/
}
}
getch();
return n; /*返回記錄數*/
}
/*插入記錄函數，參數為結構體數組和記錄數*/
int add(ADDRESS t[],int n)/*插入函數，參數為結構體數組和記錄數*/
{
ADDRESS temp; /*新插入記錄信息*/
int i,j,flag;
char s[30]; /*確定插入在哪個記錄之前*/
system("cls"); /*清屏*/
printf("請輸入記錄：\n");
printf("************************************************************************\n");
printf("姓名 單位 電話 手機 關系 郵箱 QQ\n");
printf("--------------------------------------------------------------------------\n");
scanf("%s%s%s%s%s%s%s",temp.name,temp.units,temp.tele,temp.m_ph,temp.rela,temp.email,temp.qq); /*輸入插入信息*/
fflush(stdin);
printf("請輸入插入位置的姓名： \n");
scanf("%s",s); /*輸入插入位置的姓名*/
i=find(t,n,s); /*調用find，確定插入位置*/
for(j=n-1;j>=i;j--) /*從最後一個結點開始向後移動一條*/
{
strcpy(t[j+1].name,t[j].name); /*當前記錄的姓名拷貝到後一條*/
strcpy(t[j+1].units,t[j].units); /*當前記錄的單位拷貝到後一條*/
strcpy(t[j+1].tele,t[j].tele); /*當前記錄的電話拷貝到後一條*/
strcpy(t[j+1].m_ph,t[j].m_ph); /*當前記錄的手機拷貝到後一條*/
strcpy(t[j+1].rela,t[j].rela); /*當前記錄的關系拷貝到後一條*/
strcpy(t[j+1].email,t[j].email); /*當前記錄的郵箱拷貝到後一條*/
strcpy(t[j+1].qq,t[j].qq); /*當前記錄的qq拷貝到後一條*/
}
strcpy(t[i].name,temp.name); /*將新插入記錄的姓名拷貝到第i個位置*/
strcpy(t[i].units,temp.units); /*將新插入記錄的單位拷貝到第i個位置*/
strcpy(t[i].tele,temp.tele); /*將新插入記錄的電話拷貝到第i個位置*/
strcpy(t[i].m_ph,temp.m_ph); /*將新插入記錄的手機拷貝到第i個位置*/
strcpy(t[i].rela,temp.rela); /*將新插入記錄的關系拷貝到第i個位置*/
strcpy(t[i].email,temp.email); /*將新插入記錄的郵箱拷貝到第i個位置*/
strcpy(t[i].qq,temp.qq); /*將新插入記錄的qq拷貝到第i個位置*/
n++; /*記錄數加1*/
printf("添加成功!!!\n");
getch();
return n; /*返回記錄數*/
}
/*保存函數，參數為結構體數組和記錄數*/
void save(ADDRESS t[],int n)
{
int i;
char outfile[30];
FILE *fp; /*指向文件的指針*/
system("cls"); /*清屏*/
printf("請輸入待保存的文件名：\n");
scanf("%s",outfile);
if((fp=fopen(outfile,"wb"))==NULL) /*打開文件，並判斷打開是否正常*/
{
printf("無法打開文件！\n");/*無法打開*/
exit(1); /*退出*/
}
printf("\n保存文件...\n"); /*輸出提示信息*/
fprintf(fp,"%d",n); /*將記錄數寫入文件*/
fprintf(fp,"\r\n"); /*將換行符號寫入文件*/
for(i=0;i<n;i++)
{
fprintf(fp,"%-10s%-14s%-12s%-12s%-10s%-12s%-14s\n",t[i].name,t[i].units,t[i].tele,t[i].m_ph,t[i].rela,t[i].email,t[i].qq);/*格式寫入記錄*/
fprintf(fp,"\r\n"); /*將換行符號寫入文件*/
}
fclose(fp);/*關閉文件*/
printf("****保存成功！****\n"); /*顯示保存成功*/
getch();
}
/*載入函數，參數為結構體數組*/
int load(ADDRESS t[])
{
int i,n;
char outfile[30];
FILE *fp; /*指向文件的指針*/
system("cls"); /*清屏*/
printf("請輸入待載入的文件名：\n");
scanf("%s",outfile);
if((fp=fopen(outfile,"rb"))==NULL)/*打開文件*/
{
printf("無法打開文件！\n"); /*不能打開*/
exit(1); /*退出*/
}
fscanf(fp,"%d",&n); /*讀入記錄數*/
for(i=0;i<n;i++)
fscanf(fp,"%10s%14s%12s%12s%10s%12s%14s",t[i].name,t[i].units,t[i].tele,
t[i].m_ph,t[i].rela,t[i].email,t[i].qq); /*按格式讀入記錄*/
fclose(fp); /*關閉文件*/
printf("從文件讀入數據成功!!!\n"); /*顯示保存成功*/
getch();
return n; /*返回記錄數*/
}
/*按序號顯示記錄函數*/
void display(ADDRESS t[])
{
int id,n;
char outfile[30];
FILE *fp; /*指向文件的指針*/
system("cls"); /*清屏*/
printf("請輸入待載入的文件名：");
scanf("%s",outfile);
if((fp=fopen(outfile,"rb"))==NULL) /*打開文件*/
{
printf("無法打開文件！\n"); /*不能打開文件*/
exit(1); /*退出*/
}
printf("請輸入記錄序號：\n"); /*顯示信息*/
scanf("%d",&id); /*輸入序號*/
fscanf(fp,"%d",&n); /*從文件讀入記錄數*/
if(id>=0&&id<n) /*判斷序號是否在記錄范圍內*/
{
fseek(fp,(id-1)*sizeof(ADDRESS),1); /*移動文件指針到該記錄位置*/
print(t[id]); /*調用輸出函數顯示該記錄*/
printf("\r\n");
}
else
{
printf(" %d號記錄不存在!!!\n ",id); /*如果序號不合理顯示信息*/
getch();
}
fclose(fp); /*關閉文件*/
}
/*排序函數，參數為結構體數組和記錄數*/
void sort(ADDRESS t[],int n)
{
int i,j,flag;
system("cls"); /*清屏*/
ADDRESS temp; /*臨時變數做交換數據用*/
for(i=0;i<n;i++)
{
flag=0; /*設標志判斷是否發生過交換*/
for(j=0;j<n-1;j++)
if((strcmp(t[j].name,t[j+1].name))>0) /*比較大小*/
{
flag=1;
strcpy(temp.name,t[j].name); /*交換記錄*/
strcpy(temp.units,t[j].units);
strcpy(temp.tele,t[j].tele);
strcpy(temp.m_ph,t[j].m_ph);
strcpy(temp.rela,t[j].rela);
strcpy(temp.email,t[j].email);
strcpy(temp.qq,t[j].qq);
strcpy(t[j].name,t[j+1].name);
strcpy(t[j].units,t[j+1].units);
strcpy(t[j].tele,t[j+1].tele);
strcpy(t[j].m_ph,t[j+1].m_ph);
strcpy(t[j].rela,t[j+1].rela);
strcpy(t[j].email,t[j+1].email);
strcpy(t[j].qq,t[j+1].qq);
strcpy(t[j+1].name,temp.name);
strcpy(t[j+1].units,temp.units);
strcpy(t[j+1].tele,temp.tele);
strcpy(t[j+1].m_ph,temp.m_ph);
strcpy(t[j+1].rela,temp.rela);
strcpy(t[j+1].email,temp.email);
strcpy(t[j+1].qq,temp.qq);
}
if(flag==0)break; /*如果標志為0，說明沒有發生過交換循環結束*/
}
printf("排序成功!!!\n"); /*顯示排序成功*/
}
/*快速查找，參數為結構體數組和記錄數*/
void qseek(ADDRESS t[],int n)
{
char s[20];
int l,r,m;
system("cls"); /*清屏*/
printf("\n請在查找前排序!\n"); /*提示確認在查找之前，記錄是否已排序*/
printf("請輸入待查找的姓名：\n"); /*提示輸入*/
scanf("%s",s); /*輸入待查找的姓名*/
l=0;r=n-1; /*設置左邊界與右邊界的初值*/
while(l<=r) /*當左邊界<=右邊界時*/
{
m=(l+r)/2; /*計算中間位置*/
if(strcmp(t[m].name,s)==0) /*與中間結點姓名欄位做比較判是否相等*/
{
print(t[m]); /*如果相等，則調用print函數顯示記錄信息*/
return ; /*返回*/
}
if(strcmp(t[m].name,s)<0) /*如果中間結點小*/
l=m+1; /*修改左邊界*/
else
r=m-1; /*否則，中間結點大，修改右邊界*/
}
if(l>r) /*如果左邊界大於右邊界時*/
printf("未找到！\n"); /*顯示沒找到*/
getch();
}
⑽ C語言實現哈希表的相關運算演算法 編寫程序實現哈希表的構造過程。
#define MaxSize 100 //定義最大哈希表長度
#define NULLKEY -1 //定義空關鍵字值
#define DELKEY -2 //定義被刪關鍵字值
typedef int KeyType; //關鍵字類型
typedef char * InfoType; //其他數據類型
typedef struct
{
KeyType key; //關鍵字域
InfoType data; //其他數據域
int count; //探查次數域
} HashData;
typedef HashData HashTable[MaxSize]; //哈希表類型
void InsertHT(HashTable ha,int &n,KeyType k,int p) //將關鍵字k插入到哈希表中
{
int i,adr;
adr=k % p;
if (ha[adr].key==NULLKEY || ha[adr].key==DELKEY) //x[j]可以直接放在哈希表中
{
ha[adr].key=k;
ha[adr].count=1;
}
else //發生沖突時採用線性探查法解決沖突
{
i=1; //i記錄x[j]發生沖突的次數
do
{
adr=(adr+1) % p;
i++;
}
while (ha[adr].key!=NULLKEY && ha[adr].key!=DELKEY);
ha[adr].key=k;
ha[adr].count=i;
}
n++;
}
void CreateHT(HashTable ha,KeyType x[],int n,