数据结构之小算法

1、给定一个整数N，那么N的阶乘N！末尾有多少个0呢？例如：N＝10，N！＝3 628 800，N！的末尾有两个0。

int ZeroNumber(int num)
{
	int ret = 0;
	while (num)
	{
		ret += num / 5;
		num /= 5;
	}
	return ret;
}
int main()
{
	int N = 0;
	cin >> N;
	cout<<"零的个数是："<<ZeroNumber(N)<<endl;
	system("pause");
	return 0;
}

2、 计算一个整数二进制位中1的个数。要求效率尽可能的高。且能正确求正数和负数的二进制中1的个数。

int Number(int num)
{
	int count = 0;
	while(num)
	{
		count++;
		num = (num - 1) & num;
	}
	return count;
}

3、 查找一个字符串中第一个只出现两次的字符。比如：“abcdefabcdefabc”中第一个只出现两次为‘d’，要求时间复杂度为O(N)，空间复杂度为O(1)。

char FistNotRepeat(char *string)
{
	if (*string == NULL)
		return '\0';
	//创建一个哈希表，并初始化
	char *pHash = string;
	const int tableSize = 256;
	int hashTable[tableSize];
	for (int idx = 0; idx < tableSize; ++idx)
		hashTable[idx] = 0;
	//统计每个字符出现的个数
	while (*pHash != '\0')
		hashTable[*(pHash++)]++;
	//判断第一次出现次数为2的字符 
	pHash = string;
	while (*pHash != '\0')
	{
		if (hashTable[*pHash] == 2)
			return *pHash;
		pHash++;
	}
	return '\0';
}

4、一个数组中有一个数字的次数超过了数组的一半，求出这个字符。

#include<iostream>
using namespace std;

int numGreaterThanHalf(int* numbers,int length)
{
	if (numbers == NULL || length <= 0)
		return 0;

	//找到数组中次数最多的元素
	//遍历数组保存两个值，一个是数字，一个是次数，遍历下一个数字和之前保存的一样，次数加1，如果不一样次数减1，
	//如果次数减到0，保存下一个数字，并把次数设为1，继续寻找次数最多的数字。
	int result = numbers[0];
	int times = 1;
	for (int idx = 1; idx < length; ++idx)
	{
		if (times == 0)
		{
			result = numbers[idx];
			times = 1;
		}
		else if (result == numbers[idx])
			times++;
		else
			times--;
	}
	times = 0;
	//计算次数最多的元素的个数是多少
	for (int index = 0; index < length; ++index)
	{
		if (result == numbers[index])
			times++;
	}
	//判断该元素的次数是否超过数组的一半
	if (times * 2 <= length)
		result = 0;
	return result;
}
int main()
{
	int array[] = { 1, 1, 1, 2, 3, 4, 1 };
	int len = sizeof(array) / sizeof(array[0]);
	int key = numGreaterThanHalf(array, len);
	if (key != 0)
		cout << "出现一半的数字是：" << key << endl;
	else
		cout << "没有超过数组一半的元素！" << endl;
	system("pause");
	return 0;
}

6、实现一个Add函数，让两个数相加，但是不能使用+、-、*、/等四则运算符；也不能用++、--等等。

int Add(int a, int b)//求两个数的和，不用+-*/
{
	if (b == 0)
		return a;
	int sum = a^b;//先计算不进位
	int carry = (a & b) << 1;//再计算进位，结果左移一位
	return Add(sum, carry);//递归相加前两位的值。
}

7、一个m*n的矩阵，从左到右从上到下都是递增的，给一个数x，判断x是否在矩阵中。要求效率尽可能的高。

bool Find(int *array, int rows, int columns, int number)
{
	if (array == NULL || rows <= 0 || columns <= 0)
		return false;
	int row = 0;//行号
	int column = columns - 1;//列号
	while (row < rows && column >= 0)
	{
		if (array[row * columns + column] == number)
			return true;
		else if (array[row * columns + column] > number)
			column--;
		else
			row++;
	}
	return false;
}

8、已知集合A和B的元素分别用不含头结点的单链表存储，函数difference()用于求解集合A与B的差集，并将结果保存在集合A的单链表中。

void difference(ListNode** pHead1, ListNode* pHead2)
{
	ListNode* pa = *pHead1;//pa指向集合pHead1的元素
	ListNode* pb = NULL;
	ListNode* pre = NULL;
	ListNode * pTemp = NULL;
	while (pa){
		pb = pHead2;//pb指向集合B的元素
		while (pb && pa->_value != pb->_value) //在链表pHead2中寻找与pa所指元素相等的节点
			pb = pb->Next;
		//pa所指元素与pb所指元素相等
		if (pb)
		{ 
			if (!pre)
				*pHead1 = pa->Next;
			else
				pre->Next = pa->Next;
			pTemp = pa;//求差集 所以要删除pa节点
			pa = pa->Next;
			free(pTemp);
		}
		else{
			pre = pa;
			pa = pa->Next;
		}
	}
}