浅谈5道面试题

1.合并单链表

SListNode *MergeOrderedList(SListNode*p1First, SListNode*p2First)
{
	SListNode*p1 = p1First;
	SListNode*p2 = p2First;
	SListNode*pNewNode = NULL;
	if (p1 == NULL)
	{
		return p2;
	}
	if (p2 == NULL)
	{
		return p1;
	}
	while ((p1 != NULL) && (p2 != NULL))
	{
		if ((p1->data) > (p2->data))
		{
			SListPushBack(&pNewNode, p2->data);
			p2 = p2->pNext;
		}
		if ((p1->data) <= (p2->data))
		{
			SListPushBack(&pNewNode, p1->data);
			p1 = p1->pNext;
		}
	}
	while (p1)
	{
		SListPushBack(&pNewNode, p1->data);
		p1 = p1->pNext;
	}
	while (p2)
	{
		SListPushBack(&pNewNode, p2->data);
		p2 = p2->pNext;	
	}
	//SListPrint(pNewNode);
	return pNewNode;
}

 

2.约瑟夫环

//约瑟夫环
SListNode * JocephCircle(SListNode*pFirst, int k)
{
	assert(pFirst);
	SListNode* pCur = NULL;
	pCur = pFirst;
	//1成环
	while (pCur->pNext != NULL)
	{
		pCur = pCur->pNext;
	}
	pCur->pNext = pFirst;
//2什么时候约瑟夫环停止(pFirst->pNext = pFirst);
	while (pFirst->pNext != pFirst)
	{
		int i;
		SListNode *pDel = NULL;
		for (i = 1; i < k; i++)
		{
			pCur = pCur->pNext;
		}
		pDel = pCur->pNext;
		pCur->pNext = pDel->pNext;
		free(pDel);
		pFirst = pCur->pNext;
	}
	printf("%d\n", pFirst->data);
	pFirst->pNext = NULL;
	SListPrint(pFirst);
	return NULL;
}

3.逆置反转单链表

//逆置链表
SListNode *ReverseList(SListNode *pFirst)
{
	if (NULL == pFirst)
	{
		return NULL;
	}
	SListNode *pResult;
	SListInit(&pResult);

#if 0
	while (pFirst != NULL)
	{
		//头删
		SListNode *pDel;
		pDel = pFirst;
		pFirst = pFirst->pNext;
		//头插
		pDel->pNext = pResult;
		pResult = pDel;
	}

	SListPrint(pResult);
	return NULL;

#endif
	SListNode *p1, *p2, *p3;
	p1 = NULL; p2 = NULL; p3 = NULL;
	p2 = pFirst;
	while (p2)
	{
		p3 = p2->pNext;
		p2->pNext = p1;
		p1 = p2;
		p2 = p3;
	}
	pFirst = p1;
	SListPrint(pFirst);
	return NULL;
}

4.复杂链表的复制

复杂链表结构体
struct ComplexNode
{
	int data; // 数据 
	struct ComplexNode * next; // 指向下一个节点的指针 
	struct ComplexNode * random; // 指向随机节点（可以是链表中的任意节点 or 空） 
};

ComplexNode* BuyNode(int data)
{
	ComplexNode* p = (ComplexNode*)malloc(sizeof(ComplexNode));
	p->data = data;
	p->next = NULL;
	p->random = NULL;
	return p;
}

ComplexNode* CopyComplexNode(ComplexNode* plist)
{
	ComplexNode* cur = plist;

	if (plist == NULL)
	{
		return NULL;
	}

	else if (plist->next == NULL)
	{
		return BuyNode(plist->data);
	}

	else
	{
		//每个节点后面插入相同的节点
		while (cur)
		{
			ComplexNode* tmp = BuyNode(cur->data);
			tmp->next = cur->next;
			cur->next = tmp;

			//cur每次往后移2个，因为整个链表是偶数个节点所以不会跳到NULL后面
			cur = tmp->next;
		}

		//求复制品的random
		//*注意：分类讨论，random为空或不为空
		cur = plist;
		while (cur)
		{
			//如果当前random为空，复制品的random也是空
			//否则复制品的random，指向当前节点random的下一个节点（这里忘了分类会挂掉）
			if (cur->random == NULL)
			{
				cur->next->random = NULL;
			}
			else
			{
				cur->next->random = cur->random->next;
			}
			cur = cur->next->next;
		}

		//复制品提取构成新链表
		ComplexNode* newlist = plist->next;
		cur = plist->next;
		while (cur->next)
		{
			cur->next = cur->next->next;	//前面的节点指向他后面第二个节点
			cur = cur->next;
		}
		cur->next = NULL;	//最后一个节点指向空
		return newlist;
	}
}

void Print(ComplexNode* plist)
{
	ComplexNode* cur = plist;
	while (cur)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

5.判断出入栈合法性

int is_legal(int in[], int out[], int size)
{
	stack;
	stack.top = 0;
	int ii = 0; int io = 0;
	while (ii < size)
	{
		if (in[ii] == out[io])
		{
			ii++; io++;
		}
		else if (stack.top>0 && stack.array[stack.top - 1] == out[io])
		{
			stack.top--; io++;
		}
		else (stack.array[stack.top++] == in[ii])
		{
			ii++;
		}
		while (io < size)
		{
			if (stack.array[stack.top - 1] != out[io])
				return -1;//非法
		}
		stack.top--;
		io++;
		return 1;
	}
}
int main()
{
	int in[] = { 1, 2, 3, 4, 5 };
	int out[] = { 4, 5, 3, 2, 1 };
	//int out[]={1,5,3,2,4};
	int ret = is_legal(in, out, sizeof(in) / sizeof(in[0]));
	if (ret == -1)
		printf("不合法\n");
	else
		printf("合法\n");
	return 0;
}