链表系列之单链表常见面试题

创建单链表

typedef struct node
{
	int data;
	node *next;
}Node, *LinkList;
//建立链表
Node* createList1(const int a[], int n)
{
	Node *head, *endPtr;
	head = endPtr = NULL;
	
	for(int i=0;i<n;i++)
	{
		Node *temp = new Node;
		temp->data = a[i];
		temp->next = NULL;

		if(i==0)
		{
			head = endPtr = temp;
//			endPtr->next = NULL;
		}
		else
		{
			endPtr->next = temp;
			endPtr = temp;
		}
	}

	return head;
}
/*建立链表2*/
Node* createList2(int a[],int n)
{
	Node *ListHead = new Node;
	ListHead->data = a[0];
	ListHead->next = NULL;

	for(int i=n-1;i>0;i--)
	{
		Node *tmp = new Node;
		tmp->data = a[i];
		tmp->next = ListHead->next;
		ListHead->next = tmp;
	}

	return ListHead;
}

1、从一个单链表中返回倒数第n个元素

维护两个指针，保持两个指针距离为n，当后面的指针为NULL时，前面的指针即为所求

实现：

Node *findNthToLast(Node *head, int n)
{
	Node *ptr1 = head, *ptr2 = head;

	if(head==NULL)   //如果链表为空
		return NULL;
	//保证ptr2与ptr1间隔n-1
	if(n<=0)
		return NULL;
	else
	{
		for(int i=1;i<=n-1;i++)
		{
			ptr2 = ptr2->next;
			if(ptr2==NULL)   //如果链表长度小于n
				return NULL;
		}
	}

	while(ptr2->next!=NULL)
	{
		ptr1 = ptr1->next;
		ptr2 = ptr2->next;
	}

	return ptr1;
}

2、 给出单链表的头指针和一个结点指针，在O(1)时间删除该结点。

把下一个节点的data复制到需要删除的节点覆盖原来的内容，再把下一个节点删除，最后将该节点的next指针指向下下个节点。有两个特殊情况需要单独处理：要删除节点位于链表的尾部；链表只有一个节点。

实现

bool deleteNode(Node *head,Node *node)
{
	if(head==NULL)
		return false;

	//要删除节点不是尾节点
	if(node->next!=NULL)
	{
		Node *tmpPtr = node->next;
		node->data = tmpPtr->data;
		node->next = tmpPtr->next;

		delete tmpPtr;
	}
	else 
	{
		if(head==node)   //链表只有一个节点
		{
			delete node;
			head = NULL;
		}
		else   //删除节点为尾节点
		{
			Node *tmp = head;
			while(tmp->next!=node)
			{
				tmp = tmp->next;
			}

			tmp->next = NULL;
			delete node;
		}
	}
	
	return true;
}

3、单链表逆置

3.1递归实现：

void reverse(Node *pCur,LinkList &ListHead)
{
	if(NULL==pCur||NULL==pCur->next)
	{
		ListHead = pCur;
	}
	else
	{
		Node *pNext = pCur->next;   //保存后继节点的指针
		reverse(pNext,ListHead);
		pNext->next = pCur;
		pCur->next = NULL;
	}
}

3.2非递归实现

void reverseList(LinkList &head)
{
	if(head==NULL||head->next==NULL)   //边界检查
		return NULL;

	Node *pPre = head;   //用来指向前驱节点
	Node *pCur = pPre->next;   //用来指向当前节点
	Node *pNext = NULL;   //用来指向后继节点
	while(pCur!=NULL)
	{
		pNext = pCur->next;   //保存后继节点的指针
		pCur->next = pPre;   //将当前节点的指针域指向前驱节点
		pPre = pCur;
		pCur = pNext;
	}

	head->next = NULL;
	head = pPre;   //新的头节点
}

4、从尾到头打印链表，要求不改变链表结构

4.1、借助栈来实现

void PrintListReversing(LinkList pHead)
{
	stack<Node*> nodes;
	Node* pNode = pHead;
	
	if(pNode==NULL)
		return;

	while(pNode!=NULL)   //将节点依次入栈
	{
		nodes.push(pNode);
		pNode = pNode->next;
	}

	while(!nodes.empty())   //出栈
	{
		pNode = nodes.top();
		cout<<pNode->data<<endl;
		nodes.pop();
	}
}

4.2由于递归本质就是栈结构，因此也可以用递归实现

void PrintListReversing2(Node* pHead)
{
	if(pHead==NULL)
		return;

	if(pHead!=NULL)
	{
		if(pHead->next!=NULL)
		{
			PrintListReversing2(pHead->next);
		}
		cout<<pHead->data<<endl;
	}
}

5、使用单链表实现大数的加法

/*有两个由单链表表示的数。每个结点代表其中的一位数字。
数字的存储是逆序的， 也就是说个位位于链表的表头。
写一函数使这两个数相加并返回结果，结果也由链表表示。*/
//eg. Input:(3->9->6), (4->7->8->3)
//    Output:(7->6->5->4)
Node *ListAdd(Node* L1, Node* L2)
{
	if(L1==NULL)
		return L2;
	if(L2==NULL)
		return L1;

	Node *ptr1 = L1, *ptr2 = L2, *ResultPtr=NULL, *TmpPtr=NULL;
	int carry = 0;

	Node *p_node = new Node();
	p_node->data = (L1->data+L2->data)%10;
	p_node->next = NULL;
	carry = (L1->data+L2->data)/10;
	ResultPtr = TmpPtr = p_node;
	TmpPtr->next = NULL;
	L1 = L1->next;
	L2 = L2->next;

	while(L1 && L2)
	{
		Node *pNode = new Node();
		TmpPtr->next = pNode;

		int tmp = L1->data+L2->data+carry;
		carry = tmp/10;
		pNode->data = tmp%10;
		pNode->next = NULL;

		TmpPtr = TmpPtr->next;
		L1 = L1->next;
		L2 = L2->next;
	}

	while(L1)
	{
		Node *pNode = new Node();
		TmpPtr->next = pNode;

		int tmp = L1->data+carry;
		carry = tmp/10;
		pNode->data = tmp%10;
		pNode->next = NULL;

		TmpPtr = TmpPtr->next;
		L1 = L1->next;
	}
	while(L2)
	{
		Node *pNode = new Node();
		TmpPtr->next = pNode;

		int tmp = L2->data+carry;
		carry = tmp/10;
		pNode->data = tmp%10;
		pNode->next = NULL;

		TmpPtr = TmpPtr->next;
		L2 = L2->next;
	}

	if(carry)
	{
		Node *pNode = new Node();
		TmpPtr->next = pNode;

		pNode->data = carry;
		pNode->next = NULL;
	}

	return ResultPtr;
}