Question

Please rewrite this function using recursive function

#include using

namespace std;

struct Node { char ch; Node* next; };

class LinkedList {

Node* head;

public:

LinkedList();

~LinkedList();

void add(char ch);

bool find(char ch);

bool del(char ch);

friend std::ostream& operator<<(std::ostream& out, LinkedList& list);

};

LinkedList::LinkedList() {

head = NULL;

}

LinkedList::~LinkedList() {

Node* cur = head, * tmp;

while (cur != NULL) {

tmp = cur->next; delete cur; cur = tmp;

}

}

void LinkedList::add(char ch) {

Node* cur = head, * newNode;

newNode = new Node;

newNode->ch = ch; newNode->next = NULL;

if (head == NULL) {

head = newNode;

} else {

while (cur->next != NULL)

cur = cur->next;

cur->next = newNode;

} }

bool LinkedList::find(char ch) {

Node* cur = head;

bool found = false;

while (cur != NULL) {

if (cur->ch == ch) {

found = true; break;

} cur = cur->next;

} return found;

}

bool LinkedList::del(char ch) {

Node* cur = head, * prev, * next = NULL, * tmp; int found = 0;

if (head->ch == ch) {

tmp = head;

head = head->next;

delete tmp;

return true;

} prev = cur;

while (cur->next != NULL) {

prev = cur;

next = cur->next->next;

if (cur->next->ch == ch) {

found = 1;

break;

}

cur = cur->next;

} if (!found)

{ cout << "Given ch is not in the list" << endl; return false;

} else { tmp = prev->next;

prev->next = next;

free(tmp);

} }

std::ostream& operator<<(std::ostream& out, LinkedList& list) {

Node* cur = list.head;

out << "List contains: ";

while (cur != NULL) { out << cur->ch << " "; cur = cur->next;

} out << "\n";

return out;

}

void find(LinkedList& list, char ch) {

if (list.find(ch)) cout << "found ";

else cout << "did not find ";

cout << ch << endl;

}

int main() {

LinkedList list;

list.add('x');

list.add('y');

list.add('z');

cout << list;

find(list, 'y');

list.del('y');

cout << list;

find(list, 'y');

list.del('x');

cout << list;

find(list, 'y');

list.del('z');

cout << list; find(list, 'y');

return 0;

}

Answer 1

#include <bits/stdc++.h>
using namespace std;

struct Node {
   char ch;
   Node* next;
};

Node *newNode(char ch);
{
   Node *new_node = new Node;
   new_node->ch = ch;
   new_node->next = NULL;
   return new_node;
}

Node* insertRecursive(Node* head, char ch)
{
   if(head == NULL)
       return newNode(ch);

   else
       head->next = insertRecursive(head->next, ch);
   return head;
}

void deleteRecursive(struct Node* head)
{
   if(head == NULL)
       return;
   deleteRecursive(head->next);
   free(head);
}

bool findRecursive(struct Node* head, char ch)
{
   if(head == NULL)
       return false;

   if(head->ch == ch)
       return true;

   return searchRecursive(head->next, ch);
}

int main()
{
   Node* head = NULL;
  
   head = insertRecursive(head, 'w');
   head = insertRecursive(head, 'x');
   head = insertRecursive(head, 'y');
   head = insertRecursive(head, 'z');
   findRecursive(head, 'x')? cout<<"Yes" : cout<<"No";
   deleteRecursive(head);

   return 0;
}