这次依然是两道算法题,复制单链表,及复制图。先后对其加以分析,最后会给出一些粗浅总结。
题目一,复制一个单链表(SLL - single linked list), 其节点除了一个基本的后向指针(next), 还有一个指向链表中任意一个节点的随机指针(random)。
struct ranSLLNode{
char* cValue;
ranSLLNode* pNext;
ranSLLNode* pRandom;
ranSLLNode(): pNext(0), pRandom(0){
cValue = new char[CSIZE];
memset(cValue, 0, CSIZE);
}
~ranSLLNode(){
delete cValue;
cValue=0;
pNext=0;
pRandom=0;
}
};
如果是普通单链表,很简单:遍历原始链表,同时逐个创建节点拷贝,总共一次遍历;现在每个节点多了一个随机指针,假设对于原节点pnode, 其复制拷贝节点cpnode, 问题在于如果pnode中的random指向的是之后的节点px, 则由于px的拷贝节点尚未创建,cpnode的random目前无法赋值。
解法一:利用map, 存放每个原节点和其复制节点的关联。这样,当遍历走到某个节点时,如果随机指针指向的节点还未创建,那就直接创建它!反正在map中,每个节点和其拷贝只会存在一份。恩,是个办法。
ranSLLNode* clone_01(ranSLLNode* phead){
map<ranSLLNode*, ranSLLNode*> mnodes;
ranSLLNode *curr = phead;
while(1){
if(mnodes.find(curr) == mnodes.end()){
ranSLLNode *p = new ranSLLNode;
p->cValue = curr->cValue;
mnodes[curr] = p;
}
if(mnodes.find(curr->pRandom) == mnodes.end()){
ranSLLNode *p = new ranSLLNode;
p->cValue = curr->pRandom->cValue;
mnodes[curr->pRandom] = p;
mnodes[curr]->pRandom = p;
}else{
mnodes[curr]->pRandom = mnodes[curr->pRandom];
}
if(curr->pNext != 0){
if(mnodes.find(curr->pNext) == mnodes.end()){
ranSLLNode *p = new ranSLLNode();
p->cValue = curr->pNext->cValue;
mnodes[curr->pNext] = p;
mnodes[curr]->pNext = p;
}else{
mnodes[curr]->pNext = mnodes[curr->pNext];
}
}else{ //reach tail, exit
mnodes[curr]->pNext = 0;
break;
}
}
return mnodes[phead];
}
遍历到每一个节点时,分别检查本节点、next指向节点、random指向节点等三个节点的拷贝,如果尚无,创建它,保证在这一步结束前,本节点和其完整拷贝在map里有存在。
空间上,使用一个map;时间上,总计只有一次遍历链表。
另:如果要求不使用额外空间map,怎么办?
本着时间和空间互换的思想,显然我们只能设法利用原单链表,在本题中,可选项是两个指针:random指针无序,没法用;next指针有序并支持遍历,可以使用。
解法二:我们在原链表中每一个原始节点后,插入其相应的拷贝节点,这时,对random指针不赋值;然后重新遍历整个链表,将每个新拷贝节点的random指针,赋值为其前任节点(也就是其原节点)random指针指向节点的新拷贝节点;最后,解开原节点和新拷贝节点,得到原单链表和复制后的拷贝链表。
ranSLLNode* clone_02(ranSLLNode* srcHeader){
ranSLLNode* curr = srcHeader;
while(curr != 0){ //create new node one after each source node
ranSLLNode* nNode = new ranSLLNode();
strcpy(nNode->cValue, curr->cValue);
nNode->cValue[strlen(curr->cValue)]='\0';
nNode->pRandom = curr->pRandom;
nNode->pNext = curr->pNext;
curr->pNext = nNode;
curr = nNode->pNext;
nNode = 0;
}
curr=srcHeader;
while(curr != 0){ //set pRandom of new node be new node
curr->pNext->pRandom = curr->pRandom->pNext;
curr = curr->pNext->pNext;
}
curr = srcHeader;
ranSLLNode* next = curr->pNext;
ranSLLNode* nHeader = next;
while(next != 0){ //unplug new node and source node
curr->pNext = next->pNext;
curr = next;
next = curr->pNext;
}
curr=0;
next = 0;
return nHeader;
}
该解法空间上没有使用额外结构,时间上总共遍历三次链表。
-------------------------------------------------我是分隔线-----------------------------------------------------
题目二,复制一个图(graph),图中的顶点由以下结构表示,输入为一个顶点,输出其相应的拷贝顶点。(来自leetcode)
struct Node{
int val;
vector<Node*> neighbors;
};
解法一:该解法来自leetcode上原题的作者,这里作个简单转载。
首先提示读者注意这个图是有向还是无向?根据该图的数据结构,只有顶点的数据结构,每条边由一个顶点P和其一个相邻顶点中Q表示,Q会出现在P的neighbors中,这符合有向图的特征。如果是无向图,每条边的两个顶点应该是地位平等的,但我们这道题中,顶点相邻关系显然仅仅取决于某个顶点的neighbours。所以,这是个有向图。
其次,直观的方法是对所有节点作有序遍历,那么选择队列queue, 使用广度优先BFS进行遍历。需要注意的是,如果图中存在回路,我们应力求避免回路中的某个节点重复进入队列,即程序出现死循环!!对策是使用一个map存放原节点和相应拷贝节点的对应,保证每个原节点只被复制一次。
Node* clonegraph_02(Node *graph){
if(!graph)
return NULL;
map<Node*, Node*> gmap; //[initial, copy]
queue<Node*> q;
q.push(graph);
Node *graphCopy = new Node;
graphCopy->val = graph->val;
gmap[graph] = graphCopy;
while(!q.empty()){
Node *node = q.front();
q.pop();
int n = node->neighbors.size();
for(int i=0;i<n;++i){
Node *neighbor = node->neighbors[i];
if(gmap.find(neighbor) == gmap.end()){ //no copy exist in map
Node *p = new Node;
p->val = neighbor->val;
gmap[node]->neighbors.push_back(p);
gmap[neighbor] = p;
}else{
gmap[node]->neighbors.push_back(gmap[neighbor]);
}
}
}
return graphCopy;
}
与题目一类似, 如果不用额外空间map,怎么做?
解法二:这个解法是我受题目一的解法二启发而得。既然不能使用map记录原顶点和拷贝顶点的对应,那么只能在原顶点上做文章。
首先,遍历每个顶点V[i],将V[i]的拷贝顶点存入V[i]的neighbors列尾;然后,再次遍历每个顶点V[i], 为它的拷贝顶点的neighbors都填充上相应的拷贝顶点。
在代码实现中,由于要作遍历(BFS),queue的使用不可避免。另外同样需要避免在回路存在时,顶点重复进入队列的问题,这里额外使用一个set来处理。以下是一份实现代码:
Node* clonegraph_01(Node* pnode){
set<Node*> snodes;
queue<Node*> qnodes;
qnodes.push(pnode);
snodes.insert(pnode);
while(!qnodes.empty()){ //1st iteration to append cloned A' to neighbors of A
Node* curr = qnodes.front();
qnodes.pop();
vector<Node*>::const_iterator iter = curr->neighbors.begin();
for(;iter != curr->neighbors.end();++iter){
if(snodes.find(*iter) == snodes.end()){ //Node* not pushed yet
qnodes.push(*iter);
snodes.insert(*iter);
}
}
Node* clone = new Node;
clone->val = curr->val;
curr->neighbors.push_back(clone); //append clone at tail
}
snodes.clear();
qnodes.push(pnode);
snodes.insert(pnode);
Node* npnode = pnode->neighbors.back(); //pointer to return
while(!qnodes.empty()){
Node* curr = qnodes.front();
qnodes.pop();
Node* clone = curr->neighbors.back();
vector<Node*>::iterator iter = curr->neighbors.begin();
for(;iter != curr->neighbors.end()-1;++iter){
if(snodes.find(*iter) == snodes.end()){
qnodes.push(*iter);
snodes.insert(*iter);
}
clone->neighbors.push_back((*iter)->neighbors.back()); //push clone to neighbors of clone
}
curr->neighbors.erase(iter); //now iter points to A' of A
}
snodes.clear();
return npnode;
}
相对于解法一,该解法空间上少使用一个map,不过多了一个set,扯平了;时间上多了一次全图遍历(BFS),所以似乎没什么优势。。。
总结:
1. 对于这类复制容器的问题,时间复杂度一般均为O(n), 提升余地表现在遍历的次数; 空间上的优化一般包括关联容器的使用(map)与否。
2. 算法的基本哲学“空间和时间可以互换”在这里的两种不同思路中得到了很好的展示。
3. 对于图的处理,一定要小心回路的情况,因为如果存在回路,普通的遍历会出现死循环!