有效的数独

//有效的数独
#define SIZE 9      //九宫格尺寸

typedef struct LNode {        //链表结点
	char *data;
}LNode;
typedef struct {              //表头
	LNode chap[SIZE];
}Chapter;


bool isValidSudoku(char** board, int boardRowSize, int boardColSize) {
	//检查每行是否有重复数字
	for (int i = 0; i < boardRowSize; i++)            
	{
		for (int j = 0; j < boardColSize; j++)
		{
			for (int p = j + 1; p < boardColSize; p++)
			{
				if (board[i][j] == board[i][p] && board[i][j] != '.')
					return 0;
			}
		}
	}

	//检查每列是否有重复数字
	for (int i = 0; i < boardColSize; i++)
	{
		for (int j = 0; j < boardRowSize; j++)
		{
			for (int p = j + 1; p < boardRowSize; p++)
			{
				if (board[j][i] == board[p][i] && board[j][i] != '.')
					return 0;
			}
		}
	}




	Chapter *c = (Chapter *)malloc(sizeof(Chapter));     //创建一个数组，数组每个元素是含9个元素的链表（每个链表存储一个3*3表格的数字
	for (int i = 0; i < SIZE; i++)
		c->chap[i].data = (char *)malloc(sizeof(char)*SIZE);

	int r1 = 0, r2 = 0, r3 = 0, r4 = 0, r5 = 0, r6 = 0, r7 = 0, r8 = 0, r9 = 0;        //每个链表存储时单度设置一个指示变量
	for (int i = 0; i < boardRowSize; i++)
	{
		for (int j = 0; j < boardColSize; j++)
		{
			if (0 <= i&&i <= 2)          //1 至 3 行
			{
				if (0 <= j&&j <= 2)       //1 至 3 列 -- 第一块
				{
					c->chap[0].data[r1] = board[i][j];
					r1++;
				}
				else if (3 <= j&&j <= 5)   //第4至6列  第二块
				{
					c->chap[1].data[r2] = board[i][j];
					r2++;
				}
				else                      //第三块
				{
					c->chap[2].data[r3] = board[i][j];
					r3++;
				}
			}
			else if (3 <= i&&i <= 5)
			{
				if (0 <= j&&j <= 2)
				{
					c->chap[3].data[r4] = board[i][j];
					r4++;
				}
				else if (3 <= j&&j <= 5)
				{
					c->chap[4].data[r5] = board[i][j];
					r5++;
				}
				else
				{
					c->chap[5].data[r6] = board[i][j];
					r6++;
				}
			}
			else if (6 <= i&&i <= 8)
			{
				if (0 <= j&&j <= 2)
				{
					c->chap[6].data[r7] = board[i][j];
					r7++;
				}
				else if (3 <= j&&j <= 5)
				{
					c->chap[7].data[r8] = board[i][j];
					r8++;
				}
				else
				{
					c->chap[8].data[r9] = board[i][j];
					r9++;
				}
			}

		}
	}

	//检查每3*3个表格里是否有相同的元素
	for (int i = 0; i < SIZE; i++)
	{
		for (int p = 0; p<SIZE; p++)
			for (int j = p + 1; j < SIZE; j++)
			{
				if (c->chap[i].data[p] == c->chap[i].data[j] && c->chap[i].data[p] != '.')
					return 0;
			}
	}

	return 1;

}




//优秀代码 1
bool isValidSudoku(char** board, int boardRowSize, int boardColSize) {
	int i, j, tmp, l;
	int flag[27][9];
	for (i = 0; i<27; i++) {
		for (j = 0; j<9; j++) {
			flag[i][j] = 0;
		}
	}
	for (i = 0; i<boardRowSize; i++) {
		for (j = 0; j<boardColSize; j++) {
			if (board[i][j] != '.') {
				tmp = board[i][j] - 48 - 1;
				if (flag[i][tmp] != 0) {
					return false;
				}
				flag[i][tmp] = 1;
				if (flag[j + 9][tmp] != 0) {
					return false;
				}
				flag[j + 9][tmp] = 1;
				l = (i / 3) * 3 + j / 3 + 18;
				if (flag[l][tmp] != 0) {
					return false;
				}
				flag[l][tmp] = 1;
			}
		}
	}
	return true;
}




//优秀代码2
bool containsDuplicate(int* nums) {
	int number, i, j;
	int numsSize = 9;
	if (numsSize == 1)
		return false;
	for (i = 0; i<numsSize; i++)
	{
		number = nums[i];
		for (j = i + 1; j<numsSize; j++)
			if (number == nums[j] && number != -1)
				return true;
	}
	return false;
}
int chtoi(char c) {
	if (c == '.')
		return -1;
	else
		return (int)c - 48;
}
bool isValidSudoku(char** board, int boardRowSize, int boardColSize) {
	int i = 0, j = 0;
	int nums[9];
	for (i; i<9; i += 3)
		for (j = 0; j<9; j += 3)
		{
			int i2, j2;
			for (i2 = 0; i2<3; i2++)
				for (j2 = 0; j2<3; j2++)
					nums[i2 * 3 + j2] = chtoi(board[i2 + i][j2 + j]);
			if (containsDuplicate(nums))
				return false;
		}
	for (i = 0; i<9; i++)
	{
		for (int i2 = 0; i2<9; i2++)
			nums[i2] = chtoi(board[i2][i]);
		if (containsDuplicate(nums))
			return false;
	}
	for (i = 0; i<9; i++)
	{
		for (int i2 = 0; i2<9; i2++)
			nums[i2] = chtoi(board[i][i2]);
		if (containsDuplicate(nums))
			return false;
	}
	return true;
}