11-散列3 QQ帐户的申请与登陆 (25 分)

实现QQ新帐户申请和老帐户登陆的简化版功能。最大挑战是：据说现在的QQ号码已经有10位数了。

输入格式:

输入首先给出一个正整数N（≤），随后给出N行指令。每行指令的格式为：“命令符（空格）QQ号码（空格）密码”。其中命令符为“N”（代表New）时表示要新申请一个QQ号，后面是新帐户的号码和密码；命令符为“L”（代表Login）时表示是老帐户登陆，后面是登陆信息。QQ号码为一个不超过10位、但大于1000（据说QQ老总的号码是1001）的整数。密码为不小于6位、不超过16位、且不包含空格的字符串。

输出格式:

针对每条指令，给出相应的信息：

1）若新申请帐户成功，则输出“New: OK”；
2）若新申请的号码已经存在，则输出“ERROR: Exist”；
3）若老帐户登陆成功，则输出“Login: OK”；
4）若老帐户QQ号码不存在，则输出“ERROR: Not Exist”；
5）若老帐户密码错误，则输出“ERROR: Wrong PW”。

输入样例:

5
L 1234567890 myQQ@qq.com
N 1234567890 myQQ@qq.com
N 1234567890 myQQ@qq.com
L 1234567890 myQQ@qq
L 1234567890 myQQ@qq.com

输出样例:

ERROR: Not Exist
New: OK
ERROR: Exist
ERROR: Wrong PW
Login: OK

#include "cstdio"
#include <stdlib.h>
#include <cstring>
#include <math.h>
#define KEYLENGTH 15 /* 关键词字符串的最大长度 */
#define UPPERBOUND 1e6
typedef struct Accounts {char ID[KEYLENGTH]; char PW[KEYLENGTH]; } ElementType;

typedef int Index;                     /* 散列地址类型 */

/******** 以下是单链表的定义 ********/
typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;
/******** 以上是单链表的定义 ********/



typedef struct TblNode *HashTable; /* 散列表类型 */
struct TblNode {   /* 散列表结点定义 */
    int TableSize; /* 表的最大长度 */
    List Heads;    /* 指向链表头结点的数组 */
};

bool isPrime( int N )
{
    if (N == 1) {
        return false;
    }
    
    int i;
    for ( i=(int) sqrt(N); i>=2; i--) {
        if (N % i == 0) {
            break;
        }
    }
    if( i == 1) return true;
    else return false;
}
int NextPrime( int N )
{
    int P;
    P = N % 2 ? N + 2: N + 1;
    
    while (P < UPPERBOUND) {
        if( isPrime(P) ) break;
        P += 2;
    }
    
    return P;
}
int Hash( ElementType Key, int P )
{
    return atoi(Key.ID+5) % P;
    
}
HashTable CreateTable( int TableSize )
{
    HashTable H;
    int i;
    
    H = (HashTable)malloc( sizeof(struct TblNode) );
    /* 保证散列表最大长度是素数，具体见代码5.3 */
    H->TableSize = NextPrime(TableSize);
    
    /* 以下分配链表头结点数组 */
    H->Heads = (List)malloc(H->TableSize*sizeof(struct LNode));
    /* 初始化表头结点 */
    for( i=0; i<H->TableSize; i++ ) {
        H->Heads[i].Data.ID[0] = '\0';
        H->Heads[i].Next = NULL;
        
    }
    
    return H;
}

Position Find( HashTable H, ElementType Key )
{
    Position P;
    Index Pos;
    
    Pos = Hash( Key, H->TableSize ); /* 初始散列位置 */
    P = H->Heads[Pos].Next; /* 从该链表的第1个结点开始 */
    /* 当未到表尾，并且Key未找到时 */
    while( P && strcmp(P->Data.ID, Key.ID) )
        P = P->Next;
    
    return P; /* 此时P或者指向找到的结点，或者为NULL */
}

bool Insert( HashTable H, ElementType Key )
{
    Position P, NewCell;
    Index Pos;
    
    P = Find( H, Key );
    if ( !P ) { /* 关键词未找到，可以插入 */
        NewCell = (Position)malloc(sizeof(struct LNode));
        strcpy(NewCell->Data.ID, Key.ID);
        strcpy(NewCell->Data.PW, Key.PW);
        
        Pos = Hash( Key, H->TableSize ); /* 初始散列位置 */
        /* 将NewCell插入为H->Heads[Pos]链表的第1个结点 */
        NewCell->Next = H->Heads[Pos].Next;
        H->Heads[Pos].Next = NewCell;
        return true;
    }
    else { /* 关键词已存在 */
        
        return false;
    }
}

void DestroyTable( HashTable H )
{
    int i;
    Position P, Tmp;
    
    /* 释放每个链表的结点 */
    for( i=0; i<H->TableSize; i++ ) {
        P = H->Heads[i].Next;
        while( P ) {
            Tmp = P->Next;
            free( P );
            P = Tmp;
        }
    }
    free( H->Heads ); /* 释放头结点数组 */
    free( H );        /* 释放散列表结点 */
}

/*void ScanAndOutput( HashTable H )
{
    int i, MaxCnt, Pct;
    ElementType MinPhone;
    LNode * Ptr;
    
    Pct = MaxCnt = 0;
    MinPhone[0] = 0;
    
    for (i = 0 ; i<H->TableSize; i++) {
        Ptr = H->Heads[i].Next;
        
        while (Ptr) {
            if (Ptr->Count > MaxCnt) {
                MaxCnt  = Ptr->Count;
                strcpy(MinPhone, Ptr->Data);
                Pct = 1;
            }
            else if (Ptr->Count == MaxCnt) {
                Pct++;
                if ( strcmp(Ptr->Data, MinPhone) < 0 ) {
                    strcpy(MinPhone, Ptr->Data);
                }
                
            }
            
            
            Ptr = Ptr->Next;
        }
    }
    
    printf("%s %d", MinPhone, MaxCnt);
    if (Pct > 1) {
        printf(" %d", Pct);
    }
    
    printf("\n");
    
    
    
}
 */




int main()
{
    int N;
    ElementType UserInfo;
    char Instruction;
    Position P;
    HashTable H;
    
    scanf("%d", &N);
    H = CreateTable( N );
    
    
    for (int i=0; i<N; i++) {
        getchar();
        scanf("%c %s %s", &Instruction, UserInfo.ID, UserInfo.PW);
        if (Instruction == 'N') {
            if (Insert(H, UserInfo)) {
                printf("New: OK\n");
            }
            else printf("ERROR: Exist\n");
        }
        else {
            P = Find(H, UserInfo);
            if (P) {
                if ( strcmp(P->Data.PW, UserInfo.PW) == 0 ) {
                    printf("Login: OK\n");
                }
                else printf("ERROR: Wrong PW\n");
            }
            else {
                printf("ERROR: Not Exist\n");
            }
        }
        
    }
    
    
    
    
    
    
    return 0;
}

思路

用动态链接法散列QQ账号与密码

细节处理：

ElementType 设为 struct 型变量同时维护ID和PASSWORD；

命令符N对应的是插入操作，如果账号已存在，对应insertion函数的false返回值。

命令符L对应查找操作，如果账号（1）存在，核对密码；（2）不存在P（NULL）