List Delete(List L, ElementType minD, ElementType maxD){
int i, p =0;for(i =0; i <= L->Last; i++){
if(L->Data[i]<= minD || L->Data[i]>= maxD){
L->Data[p++]= L->Data[i];}}
L->Last = p -1;return L;}
void merge(int *a, int m, int *b, int n, int *c) {
int i, j, k;
while (i < m && j < n) {
if (a[i] < b[j])
c[k++] = a[i++];
else
c[k++] = b[j++];
}
while (i < m) {
c[k++] = a[i++];
}
while (j < n) {
c[k++] = b[j++];
}
}
6-4 顺序表操作集
List MakeEmpty(){
List list;
list =(List)malloc(sizeof(structLNode));
list->Last =-1;return list;}
Position Find(List L, ElementType X){
int i;for(i =0; i < MAXSIZE; i++){
if(L->Data[i]== X)return i;}return ERROR;}
bool Insert(List L, ElementType X, Position P){
int i;if(L->Last == MAXSIZE -1){
printf("FULL");return false;}if(P <0|| P > L->Last +1){
printf("ILLEGAL POSITION");return false;}for(i = L->Last; i >= P; i--){
L->Data[i +1]= L->Data[i];}
L->Data[P]= X;
L->Last++;return true;}
bool Delete(List L, Position P){
int i;if(P <0|| P > L->Last){
printf("POSITION %d EMPTY", P);return false;}for(i = P; i < L->Last; i++){
L->Data[i]= L->Data[i +1];}
L->Last--;return true;}
6-5 递增的整数序列链表的插入
List Insert(List L, ElementType X){
List p, s;
p = L;
s =(List)malloc(sizeof(structNode));
s->Data = X;while(p->Next && p->Next->Data < X){
p = p->Next;}
s->Next = p->Next;
p->Next = s;return L;}
6-6 删除单链表偶数节点
structListNode*createlist(){
int m;structListNode*p,*s,*l;
p =(structListNode*)malloc(sizeof(structListNode));scanf("%d",&m);if(m ==-1)returnNULL;
p->data = m;
p->next =NULL;
s = p;while(1){
scanf("%d",&m);if(m ==-1)break;
l =(structListNode*)malloc(sizeof(structListNode));
l->data = m;
l->next =NULL;
s->next = l;
s = l;}return p;}structListNode*deleteeven(structListNode*head){
structListNode*p =NULL,*s =NULL;while(head && head->data %2==0){
p = head;
head = head->next;free(p);}if(head ==NULL)returnNULL;
s = head;while(s->next){
if(s->next->data %2==0)
s->next = s->next->next;else
s = s->next;}return head;}
6-7 逆序数据建立链表
structListNode*createlist(){
int m;structListNode*head,*p;
head =(structListNode*)malloc(sizeof(structListNode));
head->next =NULL;while(1){
scanf("%d",&m);if(m ==-1)break;
p =(structListNode*)malloc(sizeof(structListNode));
p->next = head->next;
p->data = m;
head->next = p;}return head->next;}
6-8 求链表的倒数第m个元素
ElementType Find(List L,int m){
int i;
PtrToNode p, s;
p = s = L;for(i =0; i < m; i++){
p = p->Next;if(!p)return ERROR;}while(p){
s = s->Next;
p = p->Next;}return s->Data;}
6-9 两个有序链表序列的合并
List Merge( List L1, List L2 )
{
List pa,pb,pc;
pa=L1->Next;
pb=L2->Next;
List L=(List)malloc(sizeof(List));
pc=L;
while(pa&&pb)
{
if(pa->Data>pb->Data)
{
pc->Next=pb;
pb=pb->Next;
}
else{
pc->Next=pa;
pa=pa->Next;
}
pc=pc->Next;
}
if(pa)
pc->Next = pa;
if(pb)
pc->Next = pb;
L1->Next=NULL;
L2->Next=NULL;
return L;
}
#include <stdio.h>
#include <stdlib.h>
typedef int ElementType;
typedef struct LNode *List;
struct LNode {
ElementType coe;//系数
ElementType exp;//指数
List Next;//下一个节点
};
void Insert(List L, ElementType coe, ElementType exp);//插入
List Multi(List p1, List p2);//乘法
List Plus(List p1, List p2);//加法
int compare(List p1, List p2);//比较系数大小
int main() {
List p1, p2;
List p;
int num1, num2, coe, exp;
int i;
p1 = (List) malloc(sizeof(struct LNode));
p2 = (List) malloc(sizeof(struct LNode));
p1->Next = NULL;
p2->Next = NULL;
scanf("%d", &num1);
for (i = 0; i < num1; i++) {
scanf("%d %d", &coe, &exp);
Insert(p1, coe, exp);
}
scanf("%d", &num2);
for (i = 0; i < num2; i++) {
scanf("%d %d", &coe, &exp);
Insert(p2, coe, exp);
}
//乘法运算
p = Multi(p1->Next, p2->Next);
while (p) {
if (p->Next != NULL) {
printf("%d %d ", p->coe, p->exp);//非最后一个节点,不换行打印,后接空格
} else {
printf("%d %d\n", p->coe, p->exp);//最后一个节点,换行打印
}
p = p->Next;
}
//加法运算
p = Plus(p1->Next, p2->Next);
if (p) {
while (p) {
if (p->Next != NULL) {
printf("%d %d ", p->coe, p->exp);
} else {
printf("%d %d\n", p->coe, p->exp);
}
p = p->Next;
}
} else {//防止出现p1,p2抵消为零的情况
printf("0 0\n");
}
return 0;
}
/**
* 向链表中添加元素
* @param L 需要添加的链表
* @param coefficient 系数
* @param exponent 指数
*/
void Insert(List L, ElementType coe, ElementType exp) {
List s, p;
p = L;
while (p->Next)//找到最后一个节点
p = p->Next;
s = (List) malloc(sizeof(struct LNode));
s->Next = NULL;
s->coe = coe;
s->exp = exp;
p->Next = s;
}
/**
* 两个多项式相乘
* @param p1 代表多项式1的链表
* @param p2 代表多项式2的链表
* @return p 相乘后生成的新链表
*/
List Multi(List p1, List p2) {
List p, p1a, p2a, s;
int flag = 1;
p = (List) malloc(sizeof(struct LNode));
p->Next = NULL;
p1a = p1;
while (p1a) {
p2a = p2;//确保p1多项式中的每一项可以与p2多项式中的每一项分别相乘
s = (List) malloc(sizeof(struct LNode));
s->Next = NULL;
while (p2a) {//与p2多项式中的每一项分别相乘
Insert(s, p1a->coe * p2a->coe, p1a->exp + p2a->exp);
p2a = p2a->Next;
}
s = s->Next;
if (flag == 1) {
p = p->Next;
/*
* 如果是p1第一项与p2每一项相乘,那么先将链表p向后移一位,将头结点屏蔽
* 因为默认初始化的P1头结点有默认的exp = 0,coe = 0,这两个数据是多余的
* 如果不后移,那么头结点默认的数值0将会一直尾随整个乘法运算,导致最后的结果后面多两个0 0
*/
flag = 0;
}
p = Plus(p, s);//相加,确保同类项合并
p1a = p1a->Next;
free(s);
}
return p;
}
/**
* 比较两多项式指数大小
* @param p1 代表多项式1的链表
* @param p2 代表多项式2的链表
* @return 返回值为0时表示两指数相同,可以进行加法运算
*/
int compare(List p1, List p2) {
if (p1->exp > p2->exp)
return 1;//p1指数大
else if (p1->exp < p2->exp)
return -1;//p1指数小
else
return 0;//指数相同
}
/**
* 两个多项式相加
* @param p1 代表多项式1的链表
* @param p2 代表多项式2的链表
* @return p 相加后生成的新链表
*/
List Plus(List p1, List p2) {
List p, p1a, p2a;
int temp;
p = (List) malloc(sizeof(struct LNode));
p->Next = NULL;
p1a = p1;
p2a = p2;
while (p1a && p2a) {
temp = compare(p1a, p2a);
//判断指数大小,同指数才可以运算
switch (temp) {
case 1:
//当前p1a的指数大,将当前p1a的数据放入新链表
Insert(p, p1a->coe, p1a->exp);
p1a = p1a->Next;//p1a向后移动,p2a不改变
break;
case -1:
//当前p2a的指数大,将当前p2a的数据放入新链表
Insert(p, p2a->coe, p2a->exp);
p2a = p2a->Next;//p2a向后移动,p1a不改变
break;
case 0:
//指数相同,进行运算
if ((p1a->coe + p2a->coe) == 0) {
//系数为0,数据不放入新链表,直接将p1a和p2a后移
p1a = p1a->Next;
p2a = p2a->Next;
} else {
//数据放入新链表,p1a和p2a后移
Insert(p, p1a->coe + p2a->coe, p2a->exp);
p1a = p1a->Next;
p2a = p2a->Next;
}
break;
default:
break;
}
}
while (p1a) {
//p1a的项数多,将剩余项放入链表
Insert(p, p1a->coe, p1a->exp);
p1a = p1a->Next;
}
while (p2a) {
//p2a的项数多,将剩余项放入链表
Insert(p, p2a->coe, p2a->exp);
p2a = p2a->Next;
}
p = p->Next;
return p;
}
7-2 符号配对
#include <stdio.h>
#include <stdlib.h>
#define Maxsize 105
typedef struct StackRecord *Stack;
struct StackRecord {
int top;
char *array;
};
Stack creat();//创建空栈
int cheekEmpty(Stack s);//判断栈是否为空
void push(Stack s, char x);//添加新元素
void pop(Stack s);//删除
char top(Stack s);//取出
char a[100];
char str[200];
int main() {
int i, j = 0, flag = 0;
char ch;
Stack s = creat();
while (gets(str)) {
if (str[0] == '.' && !str[1])
break;
for( i=0; str[i]; i++){
if(str[i]=='('||str[i]=='['||str[i]=='{'||str[i]==')'||str[i]=='}' ||str[i]==']')
a[j++]=str[i];
else if(str[i]=='/'&&str[i+1]=='*'){
a[j++]='<';
i++;
}else if(str[i]=='*'&&str[i+1]=='/'){
a[j++]='>';
i++;
}
}
}
for (i = 0; i < j; i++) {
if (a[i] == '(' || a[i] == '[' || a[i] == '{' || a[i] == '<') {
push(s, a[i]);
} else if (a[i] == ')') {
if (s->top != -1 && top(s) == '(') {
pop(s);
} else {
ch = a[i];
flag = 1;
break;
}
} else if (a[i] == ']') {
if (s->top != -1 && top(s) == '[') pop(s);
else {
ch = a[i];
flag = 1;
break;
}
} else if (a[i] == '}') {
if (s->top != -1 && top(s) == '{') pop(s);
else {
ch = a[i];
flag = 1;
break;
}
} else if (a[i] == '>') {
if (s->top != -1 && top(s) == '<') pop(s);
else {
ch = a[i];
flag = 1;
break;
}
}
}
if (!flag && cheekEmpty(s)) {
printf("YES\n");
} else {
printf("NO\n");
if (!cheekEmpty(s)) {
if (top(s) == '<') printf("/*-?\n");
else printf("%c-?\n", top(s));
} else {
if (ch == '>') printf("?-*/\n");
else printf("?-%c\n", ch);
}
}
return 0;
}
/**
* 创建新栈
* @return
*/
Stack creat() {
Stack s = (Stack) malloc(sizeof(struct StackRecord));
s->top = -1;
s->array = (char *) malloc(sizeof(char) * Maxsize);
return s;
}
/**
* 判断是否为空栈
* @param s
* @return
*/
int cheekEmpty(Stack s) {
if (s->top == -1)
return 1;
else
return 0;
}
/**
*添加元素
* @param s
* @param x
*/
void push(Stack s, char x) {
s->array[++(s->top)] = x;
}
/**
*删除
* @param s
*/
void pop(Stack s) {
s->top--;
}
/**
*取出
* @param s
*/
char top(Stack s) {
return s->array[s->top];
}
7-3 银行业务队列简单模拟
#include <stdio.h>
const int MAX = 1010;
int main() {
int a[MAX], b[MAX], cnta, cntb;
cnta = cntb = 0;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int temp;
scanf("%d", &temp);
if (temp % 2) a[++cnta] = temp;
else b[++cntb] = temp;
}
int flag = 0, x = 1, y = 1;
while (x <= cnta || y <= cntb) {
if (x <= cnta) {
if (flag++) printf(" ");
printf("%d", a[x++]);
}
if (x <= cnta) {
if (flag++) printf(" ");
printf("%d", a[x++]);
}
if (y <= cntb) {
if (flag++) printf(" ");
printf("%d", b[y++]);
}
}
return 0;
}
7-4 顺序存储的二叉树的最近的公共祖先问题
#include<stdio.h>intfind(int i,int j);intmain(){
int n, i, j, m;int a[1000];scanf("%d",&n);for(i =1; i <= n; i++){
scanf("%d",&a[i]);}scanf("%d %d",&i,&j);if(a[i]==0)//查错{
printf("ERROR: T[%d] is NULL\n", i);return0;}if(a[j]==0)//查错{
printf("ERROR: T[%d] is NULL\n", j);return0;}
m =find(i, j);printf("%d %d", m, a[m]);return0;}/**
* 查找公共祖先,二分查找
* @param i
* @param j
* @return
*/intfind(int i,int j){
if(i == j){
return i;}elseif(i > j){
returnfind(i /2, j);}elseif(i < j){
returnfind(i, j /2);}}
#include<stdio.h>#include<stdlib.h>int fa[1005];typedefstruct{
int l;int r;int weight;} Node;
Node p[3005];int n, m, sum, cnt;intcmp(constvoid*a,constvoid*b){
Node *p1 =(Node *) a;
Node *p2 =(Node *) b;return p1->weight - p2->weight;}intFind(int x){
return(x == fa[x])?(x):(fa[x]=Find(fa[x]));}voidUnion(int x,int y){
fa[Find(x)]=Find(y);}intmain(){
scanf("%d %d",&n,&m);for(int i =1; i <= n; i++)
fa[i]= i;for(int i =0; i < m; i++)scanf("%d %d %d",&p[i].l,&p[i].r,&p[i].weight);qsort(p, m,sizeof(Node), cmp);for(int i =0; i < m; i++){
if(Find(p[i].l)!=Find(p[i].r)){
sum += p[i].weight;Union(p[i].l, p[i].r);
cnt++;}if(cnt == n -1)break;}if(cnt == n -1)printf("%d\n", sum);elseprintf("-1\n");return0;}
7-7 畅通工程之最低成本建设问题
#include<stdio.h>#include<stdlib.h>structpath{
int a, b, c;} p[3000];int f[1001], n, m;voidinit(){
for(int i =1; i <= n; i++) f[i]= i;}intgetf(int k){
if(f[k]== k)return f[k];return f[k]=getf(f[k]);}intcmp(constvoid*a,constvoid*b){
return((structpath*) a)->c -((structpath*) b)->c;}intmain(){
scanf("%d%d",&n,&m);init();for(int i =0; i < m; i++){
scanf("%d%d%d",&p[i].a,&p[i].b,&p[i].c);}qsort(p, m,sizeof(p[0]), cmp);int c =0, ans =0;for(int i =0; i < m; i++){
if(getf(p[i].a)!=getf(p[i].b)){
ans += p[i].c;
c++;
f[getf(p[i].a)]=getf(p[i].b);}}if(c < n -1)printf("Impossible\n");elseprintf("%d\n", ans);return0;}
7-8 最短工期
#include<stdio.h>#include<stdlib.h>#include<string.h>int n, m, ans;int mp[100][100];int l[100], q[100], t[100];intmain(){
int a, b, c, head =0, tail =0;scanf("%d%d",&n,&m);memset(mp,-1,sizeof(mp));for(int i =0; i < m; i++){
scanf("%d%d%d",&a,&b,&c);
mp[a][b]= c;
l[b]++;}for(int i =0; i < n; i++){
if(!l[i]){
q[tail++]= i;}}while(head < tail){
int temp = q[head++];if(t[temp]> ans) ans = t[temp];for(int i =0; i < n; i++){
if(mp[temp][i]!=-1){
l[i]--;if(!l[i]) q[tail++]= i;if(t[i]< t[temp]+ mp[temp][i]){
t[i]= t[temp]+ mp[temp][i];}}}}if(tail < n)printf("Impossible");elseprintf("%d", ans);}
7-9 哈利·波特的考试
/**
* 7-9 哈利·波特的考试
* 最短路径 迪杰斯特拉算法
*/#include<stdio.h>#include<string.h>#definemaxInt2147483647typedefstruct{
int arcs[102][102];int vexnum, arcnum;} MGraph;int final[102];//final[w]=1表示求得顶点v0至vw的最短路径 int D[102];//记录v0到vi的当前最短路径长度int P[102];//记录v0到vi的当前最短路径vi的前驱int i, u, j, m, v, min, w, k, a, b, c, min1 =999999, max =-991111, p =0;voidDijkstra(MGraph G,int v0){
for(v =0; v < G.vexnum; v++)//初始化数据{
final[v]=0;//全部顶点初始化为未知最短路径状态
D[v]= G.arcs[v0][v];// 将与v0点有连线的顶点加上权值
P[v]=-1;//初始化路径数组P为-1}
D[v0]=0;//v0至v0路径为0
final[v0]=1;// v0至v0不需要求路径// 开始主循环,每次求得v0到某个v顶点的最短路径for(v =1; v < G.vexnum; v++){
min = maxInt;// 当前所知离v0顶点的最近距离for(w =0; w < G.vexnum; w++)// 寻找离v0最近的顶点{
if(!final[w]&& D[w]< min){
k = w;
min = D[w];// w顶点离v0顶点更近}}
final[k]=1;// 将目前找到的最近的顶点置为1for(w =0; w < G.vexnum; w++)// 修正当前最短路径及距离{
// 如果经过v顶点的路径比现在这条路径的长度短的话if(!final[w]&&(min + G.arcs[k][w]< D[w])){
// 说明找到了更短的路径,修改D[w]和P[w]
D[w]= min + G.arcs[k][w];// 修改当前路径长度
P[w]= k;}}}}intmain(){
MGraph G;memset(final,0,sizeof(final));memset(D,0x3f3f3f3f,sizeof(D));memset(G.arcs,0x3f3f3f3f,sizeof(G.arcs));//邻接矩阵一定要初始化scanf("%d %d",&G.vexnum,&m);for(i =0; i < m; i++){
scanf("%d %d %d",&a,&b,&c);
G.arcs[a -1][b -1]= c;
G.arcs[b -1][a -1]= c;}for(u =0; u < G.vexnum; u++){
max =-9999999;Dijkstra(G, u);for(j =0; j < G.vexnum; j++){
if(D[j]> max)
max = D[j];}if(max < min1){
min1 = max;
p = u +1;}}if(p ==0)printf("0");elseprintf("%d %d\n", p, min1);return0;}
7-10 旅游规划
/**
* 7-10 旅游规划
* 最短路径 弗洛伊德算法
*/#include<stdio.h>#defineMAXN500#defineERROR-1#defineInfinite65534int N, M, S, D;//城市的个数 高速公路的条数 出发地 目的地int Dist[MAXN][MAXN], Cost[MAXN][MAXN];//距离与花费矩阵int dist[MAXN], cost[MAXN], visit[MAXN];//最短距离与花费 标记数组voidInicialization(void);voidFindTheWay(void);intFindMinWay(void);intmain(){
scanf("%d %d %d %d",&N,&M,&S,&D);//城市的个数 高速公路的条数 出发地 目的地Inicialization();//初始化FindTheWay();printf("%d %d", dist[D], cost[D]);return0;}voidInicialization(void){
for(int i =0; i < N; i++)for(int j =0; j < N; j++)
Dist[i][j]= Cost[i][j]= Infinite;//矩阵初始化为无限值int v1, v2, d, c;for(int i =0; i < M; i++){
scanf("%d %d %d %d",&v1,&v2,&d,&c);
Dist[v1][v2]= Dist[v2][v1]= d;//输入距离路径
Cost[v1][v2]= Cost[v2][v1]= c;//输入花费路径}for(int i =0; i < N; i++)
dist[i]= cost[i]= Infinite;//矩阵初始化为无限值}voidFindTheWay(void){
dist[S]= cost[S]=0;//出发地为0
visit[S]=1;//出发地访问标记int v;for(int i =0; i < N; i++)//记录出发地直达的路径if(!visit[i]&& Dist[S][i]< Infinite)//如果没访问 且有路径{
dist[i]= Dist[S][i];
cost[i]= Cost[S][i];}while(1){
v =FindMinWay();//找出最短出发地直达且未访问的城市if(v == ERROR)break;
visit[v]=1;//找出城市的访问标记for(int i =0; i < N; i++)//循环每个城市if(!visit[i]&& Dist[v][i]< Infinite)//如果未访问且有路径if((dist[v]+ Dist[v][i]< dist[i])||(dist[v]+ Dist[v][i]== dist[i]&& cost[v]+ Cost[v][i]< cost[i])){
//如果从先到该城市再到另一城市距离小于直接到另一城市//或者从先到该城市再到另一城市距离等于直接到另一城市,且花费少
dist[i]= dist[v]+ Dist[v][i];//更新最短路径
cost[i]= cost[v]+ Cost[v][i];}}}intFindMinWay(void){
int min = Infinite;int temp;for(int i =0; i < N; i++)//循环每个城市 找出最短的路径if(!visit[i]&& dist[i]< min){
min = dist[i];
temp = i;}if(min == Infinite)return ERROR;return temp;}
7-11 QQ帐户的申请与登陆
/**
* 7-11 QQ帐户的申请与登陆
* 哈希表 分离链接法
*/#include<stdio.h>#include<stdlib.h>#include<string.h>#include<math.h>/*账号与密码最大长度的定义
它们的最大长度需要比题目所给的大一位
这是因为还需要一个位置来储存'\0'来判断字符串的结尾*/#defineMax_Password_Len17#defineMax_Account_Len11#defineMaxTableSize1000000/*各种状态的定义
最好用正数表示成功的状态
用负数或0表示失败的状态
这样会让强迫症看了舒服一点*/#defineERROR_WrongPW-2#defineERROR_Exist-1#defineERROR_NOTExist0#defineNew_OK1#defineLogin_OK2typedefchar AccountType[Max_Account_Len];//账号类型定义typedefchar PasswordType[Max_Password_Len];//密码类型定义typedefint Index;typedefenum{
New, Log
} Pattern;//两种模式,新建账号与登入账号typedefstruct{
AccountType Account;
PasswordType Password;} ElemType;//数据类型的定义,每个对应一个用户,内含用户的账号和密码//链表指针的定义typedefstructLNode*PtrToLNode;//链表结点的定义typedefstructLNode{
PtrToLNode Next;
ElemType Data;} LNode;typedef PtrToLNode List;//链表的定义typedef PtrToLNode Position;//哈希表中结点位置的定义//哈希表的定义typedefstructTblNode*HashTable;typedefstructTblNode{
int TableSize;//哈希表的大小
List Heads;//储存各个列表头节点的数组} TblNode;intNextPrime(int N)//返回N的下一个素数{
int i, P;
P = N %2? N +2: N +1;//P为N之后的第一个奇数while(P < MaxTableSize){
for(i =(int)sqrt(P); i >2; i--)//因为只考虑奇数,所以i为2时就结束了if(P % i ==0)break;if(i ==2)break;//i为2说明P为素数else
P +=2;//i!=2说明P不是素数,则P指向下一个奇数}return P;}intHash(int Key,int TableSize){
//返回Key值相对应的哈希值,即其在哈希表中的储存下标return Key % TableSize;}
HashTable CreateTable(int TableSize){
//构造空的哈希表
HashTable H;int i;
H =(HashTable)malloc(sizeof(TblNode));
H->TableSize =NextPrime(TableSize);
H->Heads =(List)malloc(sizeof(LNode)* H->TableSize);for(i =0; i < H->TableSize; i++){
H->Heads[i].Data.Account[0]='\0';
H->Heads[i].Data.Password[0]='\0';
H->Heads[i].Next =NULL;}return H;}
Position Find(HashTable H, ElemType Key){
Position Pos;
Index p;if(strlen(Key.Account)>5)//账号大于5位时取最后5位
p =Hash(atoi(Key.Account +strlen(Key.Account)-5), H->TableSize);else//账号不大于5位则等于它本身
p =Hash(atoi(Key.Account), H->TableSize);
Pos = H->Heads[p].Next;while(Pos &&strcmp(Key.Account, Pos->Data.Account))
Pos = Pos->Next;return Pos;//Pos指向用户数据的位置,没有注册就返回NULL}intNewOrLog(HashTable H, ElemType Key, Pattern P){
//返回状态参数
Position Pos, NewPos;
Index p;
Pos =Find(H, Key);switch(P){
case Log:if(Pos ==NULL)return ERROR_NOTExist;//登陆时不存在账号elseif(strcmp(Pos->Data.Password, Key.Password)||(strlen(Key.Password)>16||strlen(Key.Password)<6))return ERROR_WrongPW;//密码错误或格式错误elsereturn Login_OK;//账号和密码均正确,可以登录case New:if(Pos !=NULL)return ERROR_Exist;//新建账号时发现已经存在这样的账号了else{
NewPos =(Position)malloc(sizeof(LNode));strcpy(NewPos->Data.Account, Key.Account);strcpy(NewPos->Data.Password, Key.Password);if(strlen(Key.Account)>5)
p =Hash(atoi(Key.Account +strlen(Key.Account)-5), H->TableSize);else
p =Hash(atoi(Key.Account), H->TableSize);
NewPos->Next = H->Heads[p].Next;
H->Heads[p].Next = NewPos;return New_OK;//插入新值并返回插入成功}}}voidDestroyTable(HashTable H){
//销毁哈希表
PtrToLNode p, q;int i;for(i =0; i < H->TableSize; i++){
q = H->Heads[i].Next;while(q){
p = q->Next;free(q);
q = p;}}free(H);}intmain(void){
int N, i;
ElemType Key;char Input;
Pattern P;
HashTable H;scanf("%d",&N);
H =CreateTable(2* N);for(i =0; i < N; i++){
scanf("\n%c %s %s",&Input, Key.Account, Key.Password);
P =(Input =='L')? Log : New;switch(NewOrLog(H, Key, P)){
//最后根据不同返回值输出对应状态即可case ERROR_Exist:printf("ERROR: Exist\n");break;case ERROR_NOTExist:printf("ERROR: Not Exist\n");break;case ERROR_WrongPW:printf("ERROR: Wrong PW\n");break;case Login_OK:printf("Login: OK\n");break;case New_OK:printf("New: OK\n");break;}}DestroyTable(H);return0;}