Question

我需要编写一个名为reverseNodes的算法，它将RefToNode作为参数，recuriveley将列出我想出的标题的列表

算法反向（rList）

在列表中反映元素

Pre：rList ::对要反转的列表的依据

发布：rList中的元素是颠倒的

if（rList！= NULL） reverseNodes（rList - ＆gt; head）返回

我需要找到一种方法来写这个是psuedocode并找到时间复杂度

Answer 1

如果你开始，有时会更容易创建一些非正式的算法乱码这个想法表达清楚。然后，混淆和语言化，直到你有东西，你的教授会高兴地接受。

所以，让我们从算法的一般概念开始：

let rec fold folder acc l = 
    match l with
    | [] -> acc
    | x::xs -> fold folder (folder acc x) xs

let prepend l e = e :: l

let revlist l = fold prepend [] l

...并开始用语言表达：

让结果=空列表
让l =我们要反转的列表
如果l是空列表，请转到7
让head = l.front，l = l.pop_front（）
result.push_front head
转到3
l =结果

步骤3..6可以很容易地表示为递归函数：

void loop(list& l, list& result)
{
    if( l.is_empty()) return;
    auto head = l.front();
    l.pop_front();
    result.push_front(head);
    loop(l,result);
}

由于我们想要创建in-place.reversal的幻觉，我们的reverse_list函数是

void reverse_list( list& l )
{
    list result;
    loop( l, result);
    l = result;
}

替代解决方案

我们也可以用另一种方式来做：

let rec revlist1 l =
    match l with
    | [] -> l
    | x::xs -> (revlist1 xs) @ [x]

这基本上表明，反向列表是附加到其余部分的原始列表的前面元素。

将算法翻译成乱码形式：

Node* reverse_list1( Node* list )
{
    if( list == NULL) return NULL; // reverse of empty list is empty list.
    if( list->next == NULL ) // last element in list?
        return list; // the reverse of a list with 1 element is the same.
    else
    {
        Node* head = list;
        Node* tail = list->next;
        head->next = NULL;
        Node* end_of_reverse_tail = tail; // the first will be the last...
        Node * result = reverse_list1(tail);
        end_of_reverse_tail->next = head;
        return result;
    }
}

注意，这不是尾递归解决方案。

递归反向列表

1 个答案: