C++ में लिंक्ड लिस्ट में फ्रैक्शनल (या n/k-वां) नोड ढूंढें

मान लीजिए हमारे पास एक सिंगली लिंक्ड लिस्ट और संख्या k है। हमें एक फंक्शन लिखना है जो (n/k)वां एलिमेंट ढूंढे, जहां n लिस्ट में एलिमेंट्स की संख्या है। दशमलव के लिए, हम सीलिंग मान चुनेंगे। तो यदि लिस्ट 1, 2, 3, 4, 5, 6 जैसी है, और k = 2, तो आउटपुट 3 होगा, क्योंकि n = 6 और k = 2, तो हम n/k वां नोड प्रिंट करेंगे तो 6/2 वां नोड = तीसरा नोड जो 3 है।

इसे हल करने के लिए हमें नीचे दिए गए चरणों का पालन करना होगा -

• temp और fracPoint नाम के दो पॉइंटर्स लें, फिर उन्हें क्रमशः null और start से प्रारंभ करें।
• temp पॉइंटर के हर k जंप के लिए, fracPoint पॉइंटर का एक जंप करें।

उदाहरण

#include 
using namespace std;

class Node {
public:
    int data;
    Node* next;
};

Node* getNode(int data) {
    Node* new_node = new Node;
    new_node->data = data;
    new_node->next = NULL;
    return new_node;
}

Node* fractionalNodes(Node* start, int k) {
    if (k <= 0 || start == NULL)
        return NULL;
    Node* fracPoint = NULL;
    int i = 0;
    for (Node* temp = start; temp != NULL; temp = temp->next) {
        if (i % k == 0) {
            if (fracPoint == NULL)
                fracPoint = start;
            else
                fracPoint = fracPoint->next;
        }
        i++;
    }
    return fracPoint;
}

void printList(Node* node) {
    while (node != NULL) {
        cout << node->data << " ";
        node = node->next;
    }
    cout << endl;
}

int main(void) {
    Node* start = getNode(1);
    start->next = getNode(2);
    start->next->next = getNode(3);
    start->next->next->next = getNode(4);
    start->next->next->next->next = getNode(5);
    int k = 2;
    cout << "List is: ";
    printList(start);
    Node* answer = fractionalNodes(start, k);
    cout << "\nFractional node is " << answer->data;
}

आउटपुट

List is: 1 2 3 4 5
Fractional node is 3