查找兄弟单词

描述:

题目描述

代码：

#include <stdlib.h>
#include <string.h> 
#include <iostream>
#include <algorithm>
using namespace std;
/******************************************************************************

  Copyright (C), 2001-2012, Huawei Tech. Co., Ltd.

 ******************************************************************************
  File Name     : FindSimilarWord.cpp
  Version       :
  Author        :
  Created       : 2012/09
  Last Modified :
  Description   :
  Function List :

  History       :
  1.Date        : 2012/09
    Author      :
    Modification: Created file

******************************************************************************/

//字典和兄弟单词的数据结构

struct BWord
{
	char value[100];
	struct BWord *pnext;
};	//这是兄弟单词的链表，即链表上的每个结点的单词都是兄弟单词

struct BDict
{
	char key[100];
	struct BWord *next;
} head[1050];	//这个数组中每个结点是一个排序的单词，next指向这个单词的兄弟单词的链表

int size=0;	//非兄弟单词个数，初始值为0

/******************************************************************************
原    型：int AddOneWord (char* Word);
功    能：在字典中增加一个单词
输入参数： 
          Word 单词字符串，调用者保证Word指针不为空，指向的是合法单词
输出参数：
          无
返回值：
        -1 失败（单词在字典中已存在等情况）
        0  成功
********************************************************************************/


//添加单词:先判断这个单词的有序形式是否在字典中存在，如果存在，则在兄弟单词链表中添加进去
int AddOneWord (char* Word)
{
    /* 在这里实现功能 */
	if(Word == NULL || strlen(Word) < 1 || strlen(Word) > 50)
		return -1;

	char tWord[100] = {0};	//存储当前word的有序形式
	strcpy(tWord , Word);
	sort(tWord , tWord + strlen(tWord));

	int i;
	struct BWord *p , *q , *t;
	for(i = 0 ; i < size ; i++)
	{
		if(strcmp(tWord, head[i].key) !=0)	//如果当前单词不是兄弟单词，则继续遍历
			continue;

		p = head[i].next;	//兄弟单词链表头部
		q = NULL;

		//下面把Word按字典序序插入链表中，如果已经存在，则返回-1
		while(p != NULL)
		{
			//找到插入位置，插入p之前。
			if(strcmp(p->value , Word) > 0)
			{
				//根据当前单词构造一个链表结点
				t = (struct BWord*)malloc(sizeof(struct BWord));
				strcpy(t->value,Word);
				t->pnext = NULL;

				//如果当前单词最小，则插入到头之前，否则插入到q后面p之前
				if(q == NULL)
				{
					head[i].next = t;
				}
				else
				{
					q->pnext = t;
				}
				t->pnext = p;
				break;
			}
			else
				if(strcmp(p->value,Word) == 0)
					return -1;
			q = p;
			p = p->pnext;
		}
		//如果插入的单词最大
		if(p == NULL)
		{
			t = (struct BWord*)malloc(sizeof(struct BWord));
			strcpy(t->value,Word);
			t->pnext = NULL;
			q->pnext = t;
		}
		break;
	}

	//如果i遍历到数组最后，即没有找到
	if(i == size)
	{
		strcpy(head[size].key , tWord);	//把head[size].key置为有序单词

		t = (struct BWord*)malloc(sizeof(struct BWord));
		strcpy(t->value,Word);
		t->pnext = NULL;
		head[size].next = t;
		size++;
	}
    return 0;
}

/******************************************************************************
原    型：int FindSimilarWordNum (char* Word);
功    能：查找指定单词在字典中的兄弟单词个数
输入参数：
          Word 指定单词字符串，调用者保证Word指针不为空，指向的是合法单词
输出参数：
          无
返回值：
          返回指定单词在字典中的兄弟单词总个数。如果不存在兄弟单词，返回0
*******************************************************************************/
int FindSimilarWordNum (char* Word)
{
    /* 在这里实现功能 */
	if(Word == NULL)
		return 0;
	char iWord[100] = {0};
	strcpy(iWord , Word);
	sort(iWord , iWord + strlen(iWord));

	int i = 0 , num = 0;
	struct BWord *p;
	for(i = 0 ; i < size ; i++)
	{
		if(strcmp(iWord, head[i].key)!=0)
			continue;
		p = head[i].next;

		//统计兄弟单词的个数，不包括自己
		while( p != NULL)
		{
			if(strcmp(Word,p->value) != 0)
				num++;
			
			p=p->pnext;
		}
		break;
	}		
	if(i == size)
		return 0;
	
    return num;
}

/******************************************************************************
原    型：int FindOneSimilarWord (char* Word, int Seq, char* SimilarWord);
功    能：查找指定单词的指定序号的兄弟单词，指定序号指字典中兄弟单词按字典顺序
          排序后的序号（从1开始）
输入参数：
          Word 指定单词字符串，调用者保证Word指针不为空，指向的是合法单词
          Seq 指定序号（大于等于1）
输出参数：
          SimilarWord 返回兄弟单词字符串，指针不为空，指向的内存由调用者预先分配，
          占51个字节长度，输出的兄弟单词必须紧跟’\0’结束。如果不存在指定序号的
          兄弟单词，输出空串。
返回值：
          -1 失败（如果不存在指定序号的兄弟单词，返回失败）
          0  成功
*******************************************************************************/
int FindOneSimilarWord (char* Word, int Seq, char* SimilarWord)
{
    /* 在这里实现功能 */
	if ( !Word || !SimilarWord) 
		return 0;

	char iWord[100];
	strcpy(iWord,Word);
	sort(iWord,iWord+strlen(iWord));

	int i = 0 , num = 0;
	struct BWord *p;
	for(i=0; i<size; i++)
	{
		if(strcmp(iWord, head[i].key)!=0)
			continue;		

		p = head[i].next;
		while( p != NULL)
		{
			if(strcmp(Word,p->value) != 0)
				num++;
			
			if(num == Seq)
			{
				strcpy(SimilarWord,p->value);
				return 0;
			}
			p=p->pnext;
		}
		break;
	}
	strcpy(SimilarWord,"");
    return -1;
}

/******************************************************************************
原    型：void ClearAllWords(void);
功    能：清空字典中所有单词
输入参数： 
          无
输出参数：
          无
返回值：
          无

*******************************************************************************/
void ClearAllWords(void)
{
    /* 在这里实现功能 */
	int i;
	struct BWord *p,*t;

	for(i=0; i<size; i++)
	{
		p = head[i].next;
		while(p != NULL)
		{
			t = p;
			p=p->pnext;
			free(t);
		}
	}
	size = 0;
}