Recursion

`class SLL
{
	struct Node {
		int key;
		Node* next;
	};
	Node* head;
	
	void reversePrint(Node *curr) const;
	bool removeLastOdd(Node *curr);
	bool odd(Node *curr) const;
public:
	void reversePrint() const;
	bool removeLastOdd();
}

Reverse print

void SLL::reversePrint(Node* curr) const;
{
	if (!curr)
		return;
	
	reversePrint(curr -> next);
	cout << curr -> key << ' ';
}

void SLL::reversePrint() const
{
	if (head != nullptr)
		reversePrint(head);
}

Remove last odd node

// 1st solution
SLL::Node* findLastOdd(Node* curr)
{
	if (!curr)
		return nullptr;
		
	Node* later = findLastOdd(Node* curr);
	if (later)
		return later;
	
	if (curr -> key % 2 == 1)
		return curr;
		
	return nullptr;
}

bool SSL::removeLastOdd()
{
	Node* target = findLastOdd(Node* head)
	if (!target)
		return 0;
		
	if (target == head)
	{
		head = head -> next;
		delete target;
		return 1;
	}
	
	Node* curr = head;
	while (curr -> next != target)
		curr = curr -> next;
		
	curr -> next = target -> next;
	delete target;
	return 1;
}

bool removeLastOdd(Node* curr, Node* prev)
{
	if (!curr)
		return 0;
	
	res = removeLastOdd(curr -> next, curr);
	if (res)
		return res;
		
	// node has not been found yet
	if (curr -> key % 2 == 1)
	{
		if (!prev)
			head = curr -> next;
		else
			prev -> next = curr -> next;
		delete curr;
		return 1;
	}
	return 0;
}

bool removeLastNode()
{
	return removeLastNode(head, nullptr);
}

The best way

bool removeLastOdd(Node*& curr)
{
	if (!curr)
		return 0;
		
	if (!curr -> next)
	{
		delete curr;
		curr = nullptr;
		return 1;
	}
	return removeLastNode(curr -> next);
}

Remove last x nodes with given key

bool removeExactLast(int key, int number, int& counter)
{
	static int count = 0;
	static int key = key;
}