BastterCode semana 13 - 206. Reverse Linked List
comentada em 15/05/2023 15:48

Faz o mensal também, @FlyCavok ! 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
      if (head == nullptr) return head;
      if (head->next == nullptr) return head;
      ListNode* tail = head->next;
      head->next = nullptr;
      while (tail->next) {
        ListNode* mid = tail;
        tail = tail->next;
        mid->next = head;
        head = mid;
      }
      tail->next = head;
      head = tail;
      return head;
    }
};

como postar uma resposta com formatação do codigo?

@gummybear
 
Clica nesse símbolo aqui embaixo do campo para mensagem. Aí escolhe tua linguagem de programação na tela que abre. Se não tiver, escolhe qualquer uma cuja formatação fique legal.
 
Aqui no celular esse símbolo só aparece se eu coloco pra abrir o tópico no modo desktop. 

Ver mais

@gustavo, usando Firefox, no Linux, esta opção não aparece, tenho que ativar algo?


Ver mais

Obrigado @oxe, @gustavo, pelo link do topico funciona.

type LinkedList struct { 
	V interface{}
	N *LinkedList
}

func Reverse(l *LinkedList) (ret *LinkedList) { 

	if l == nil { 
		return nil
	}

	ret = l
	for n := l.N; n != nil; { 
		t := ret
		ret = n		
		n = n.N
		ret.N = t
	}
	
	l.N = nil

	return ret
}

func ReverseR(l *LinkedList) (ret *LinkedList) { 

	_, last := reverseR(l)

	return last 
}

func reverseR(l *LinkedList) (ret *LinkedList, last *LinkedList) { 

	if l == nil { 
		return nil, nil
	}

	v, last := reverseR(l.N)
	if v == nil { 
		return l, l
	}

	l.N = nil
	v.N = l

	return l, last
}

Não conhecia este desafio!!!

achei bem legal
deixando uma sugestão de roadmap de questões é o grind 75

aqui ta configurado para mostrar 169 questões e já tem o link do leetcode
Grind 75 - A better Blind 75 you can customize, by the author of Blind 75

Cara, eu apanhei pra caramba tentando implementar uma versão recursiva, que na teoria deveria ser mais intuitiva.

Eu já tinha feito quase tudo, mas ainda não conseguia descobrir uma forma de retornar a cabeça da lista revertida. A recursão sempre ia de trás pra frente da lista original e a frente da lista original é a traseira da lista revertida.

Tentei salvar a traseira da lista original, que é a cabeça da lista revertida, numa variável global. Mas ficou faltando uma condição para poder retornar a variável global, e não a local, quando a recursão chegasse à frente da lista original.

Aí, depois de muito tentar, fui pesquisar. E descobri que dá simplesmente pra fazer "head->next->next" e  preservar a cabeça da lista revertida sem mexer.

Eu gosto de ser iniciante nas coisas porque tem dessas que a gente passa kkkkk

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == nullptr || head->next == nullptr) return head;
        ListNode* curr = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return curr;
    }
};?