C/C++面试编程题

1、排序

/***选择法排序***/
/*
在10个数中找出最小的数，与第1个数交换 
在9个数中找出最小的数，与第2个数交换
.......
在2个数中找出最小的数，与第9个数交换
*/
void Select_Sort(int num[], const int n)
{
	int i, j, index, temp;
	for(i=0; i<n-1; i++)
	{
		index = i;
		for(j=i+1; j<n; j++)
		{
			if(num[j] < num[index])
				index = j;
		}
		
		if(index != i) 
		{
			temp = num[i];
			num[i] = num[index];
			num[index] = temp; 
		} 
	}
}

/***冒泡法排序***/
/*
10个数两两比较，如果后面的数小于前面的则将两个数互换，最后最大的数被排到了第10位
9个数两两比较，如果后面的数小于前面的则将两个数互换，最后最大的数被排到了第9位
.......
2个数两两比较，如果后面的数小于前面的则将两个数互换，最后最大的数被排到了第2位
*/
void Bubble_Sort(int num[], const int n)
{
	int i, j, temp;
	for(i=0; i<n-1; i++)
	{
		for(j=0; j<n-1-i; j++)
		{
			if(num[j+1] < num[j])
			{
				temp = num[j];
				num[j] = num[j+1];
				num[j+1] = temp;
			}
		}
	}
}

2、字符串处理函数的实现

//strcat():把src所指的字符串添加到dest结尾处,返回指向dest的指针(覆盖原dest结尾的'\0',并在新的dest结尾自动添加'\0')
char *mystrcat(char *dest, const char *src)
{
        assert(dest&&src);

        char *p = dest;
	while(*p)
		p++;	

	while(*src)
		*p++ = *src++;
	*p = '\0';

	return dest;
}

//strcpy():复制src所指字符串到dest,返回指向dest的指针(新的dest结尾处要添加'\0')
char *mystrcpy(char *dest, const char *src)
{
	assert(dest&&src);
	
	char *p = dest;
	while(*src)
		*p++ = *src++;	
	*p = '\0';

	return dest;
}

//strstr():在字符串str1中查找是否有字符串str2,如果有返回其位置,没有返回NULL
char *mystrstr(char *str1, char *str2)
{
	assert(str1&&str2);

	char *p, *q;
	while(*str1 != '\0')
	{
		p = str1;
		q = str2;

		while(*p == *q)
		{
			p++;
			q++;

			if(*q == '\0')
				return str1;
		}

		str1++;
	}

	return NULL;
}

//memcpy():从src开始拷贝n个字节到dest中,返回指向dest的指针
void *mymemcpy(void *dest, const void *src, unsigned int n)
{
	assert(dest&&src);

	byte *p = (byte*)dest;
	const byte *q = (const byte*)src;
	while(n--)
		*p++ = *q++;

	return dest;
}

3、数组问题

//合并两个有序数组为一个有序数组
void UnionArray(int ary1[], int ary2[], int n1, int n2)
{
	int n = n1 + n2;
	int *ary = new int[n];//开辟空间用来存放合并后的序列
	int *ptr = ary;
	int *ptr1 = ary1;
	int *ptr2 = ary2;

	
	while(n1>0 && n2>0)
	{
		if(*ptr1 <= *ptr2)
		{
			*ptr++ = *ptr1++;
			n1--;
		}
		else
		{
			*ptr++ = *ptr2++;
			n2--;
		}
	}

	if(n1 == 0)
	{
		while(n2 > 0)
		{
			*ptr++ = *ptr2++;
			n2--;
		}
	}
	else
	{
		while(n1 > 0)
		{
			*ptr++ = *ptr1++;
			n1--;
		}
	}

	int i;
	for(i=0; i<n; i++)
		cout << *ary++ << ",";
	cout << endl;
}

//判断一个数组中元素是否为递增
bool IncreArray(int ary[], const int n)
{
	if(n == 2)//递归终止的条件,一般都放在前面
		return ary[1] >= ary[0];

	if(ary[n-1] >= ary[n-2])
		return IncreArray(ary, n-1);
	else 
		return false;
}

4、链表

//链表的结点结构
typedef struct node
{
	int data;
	struct node *next;
}Node, *PNode;

/***链表逆序***/
void TurnList(PNode &ptr_head)
{
	PNode ptr_front = ptr_head->next;//指向第一个结点
	PNode ptr_node = ptr_head->next->next;//指向第二个结点
	PNode ptr_temp = NULL;

	while(ptr_node != NULL)
	{
		ptr_temp = ptr_node->next;//保存第三个结点的指针
		ptr_node->next = ptr_front;//第二个结点的指针指向第一个结点
		
		ptr_front = ptr_node;//第二个结点变成第一个结点
		ptr_node = ptr_temp;//第三个结点变成第二个结点
	}

	ptr_head->next->next = NULL;//第一个结点变成尾结点
	ptr_head->next = ptr_front;//头结点指向最后一个结点
}

/***链表排序***/
void SortList(PNode &ptr_head)
{
	/********链表为空或只有一个结点直接返回********/
	if(ptr_head->next == NULL || ptr_head->next->next == NULL)
		exit(0);

	/********利用选择法排序思想给链表排序********/

	PNode ptr_node = ptr_head->next;
	PNode ptr_min;
	PNode ptr_temp;

	while(ptr_node->next != NULL)//找出最小的数
	{
		ptr_temp = ptr_node;
		ptr_min = ptr_node;

		while(ptr_temp->next != NULL)
		{
			if(ptr_temp->next->data < ptr_temp->data)
				ptr_min = ptr_temp->next;

			ptr_temp = ptr_temp->next;
		}

		int temp;
		if(ptr_min != ptr_node)//与第一个结点的值交换
		{
			temp = ptr_min->data;
			ptr_min->data = ptr_node->data;
			ptr_node->data = temp;
		}
		
		ptr_node = ptr_node->next;//第一个结点变成第二个结点
	}
}

/***合并两个有序链表为一个有序链表***/
void UnionList(PNode &ptr_head1, PNode &ptr_head2, PNode &ptr_head)
{
    PNode ptr_node1    = ptr_head1->next;//指向第一个链表中第一个结点
    PNode ptr_node2 = ptr_head2->next;//指向第二个链表中第一个结点
    ptr_head = ptr_head1;
    PNode ptr_front = ptr_head;//指向第三个链表中头结点

    while(ptr_node1 && ptr_node2)
    {
        if(ptr_node1->data <= ptr_node2->data)//第一个链表中结点小于或等于第二个链表中结点则将第一个链表中结点插入到第三个链表中去
        {
            ptr_front->next = ptr_node1;
            ptr_front = ptr_node1;
            ptr_node1 = ptr_node1->next;
        }
        else//第二个链表中结点小于或等于第一个链表中结点则将第二个链表中结点插入到第三个链表中去
        {
            ptr_front->next = ptr_node2;
            ptr_front = ptr_node2;
            ptr_node2 = ptr_node2->next;
        }
    }

    ptr_front->next = ptr_node1?ptr_node1:ptr_node2;//插入剩余段
}

5、其它

判断一个数是2的几次方

//将2的n次方写成二进制形式后，很容易就会发现有一个特点：二进制中只有一个1，并且1后面跟了n个0,
//因此问题可以转化为判断1后面跟了几个0就可以了。
void log2(int value)
{
	int n = value, count = 0;

	if(n & (n-1))//先判断是否是2的幂次方
	{
		cout << n << "不是2的幂次方" << endl;
		return;
	}

	while(n > 1)
	{
		n >>= 1;
		count++;
	}
	
	cout << value << "是2的" << count << "次方" << endl;
}