Question

C++ and leave comments explaining. Thank you

You are given two STL lists X and P where n P is already in sorted order. Write a valid C++ function

printPositions(X,P) that prints the elements in X specified by P. For example, if P = 0, 3, 7, 8, the elements in positions 0 (head of the list), 3, 7, and 8 in

X are printed. You may use only the public STL container operations. Also specify the running time of your algorithm using Big-Oh notation.

Hint: You may wish to use iterators while keeping track of the position of items being iterated through.

Answer 1

Ans:-

Maybe you are as of now utilizing C++ as your principle programming dialect to take care of TopCoder issues. This implies you have effectively utilized STL just, on the grounds that exhibits and strings are passed to your capacity as STL articles. You may have seen, however, that numerous coders figure out how to compose their code substantially more rapidly and succinctly than you.

Alternately maybe you are not a C++ software engineer, but rather need to end up distinctly one in view of the colossal usefulness of this dialect and its libraries.

Despite what kind of opinion you're maintaining, this article can offer assistance. In it, we will audit a portion of the capable components of the Standard Template Library (STL) – an extraordinary device that, occasionally, can spare you a ton of time in a calculation rivalry.

The least difficult approach to get acquainted with STL is to start from its holders.

Holders

At whatever time you have to work with numerous components you require some sort of compartment. In local C however not C++ there was just a single kind of compartment: the cluster.

The issue is not that exhibits are constrained Instead, the principle issue is that numerous issues require a holder with more prominent usefulness.

Add some string to a compartment.

Expel a string from a compartment.

Figure out if a string is available in the compartment.

Give back various particular components in a holder.

Emphasize through a compartment and get a rundown of included strings in some request.

Obviously, one can execute this usefulness in an ordinal exhibit. Be that as it may, the insignificant execution would be extremely wasteful. You can make the tree-of hash-structure to fathom it fasterly, yet think a bit: does the execution of such a compartment rely on upon components we will store? Do we need to re-execute the module to make it useful, for instance, for focuses on a plane yet not strings?

If not, we can build up the interface for such a compartment once, and after that utilization wherever for information of any sort. That, to put it plainly, is the possibility of STL holders.

Before we start

At the point when the program is utilizing STL, it ought to #include the proper standard headers. For most holders the title of standard header coordinates the name of the compartment, and no expansion is required. For instance, in the event that you will utilize stack, simply include the accompanying line toward the start of your program:

#include <stdio.h>

int product(int an, int b, int file, int measure)

{ int temp = 0;

for (file = 0; record < estimate; index++)

temp += a * b;

return temp;

}

principle()

{ int a[10];/* instate somehow */

int b[10];/* instate somehow */

int i;

printf("%d\n",product(a[i],b[i],i,10));

return 0;

}

STL Lists

A few focuses about the STL list holder: •implements a great rundown information structure

•supports an element bidirectional straight rundown

•unlike a C++ exhibit, the items the STL list contains can't be gotten to specifically.

•is characterized as a format class, implying that it can be altered to hold objects of any sort.

•responds like an unsorted rundown . Be that as it may, there are capacities accessible for sorting the rundown

Programm:-

#include<stdio.h>

#include<stdlib.h>

/* Link list node */

struct node

{

    int data;

    struct node* next;

};

/* capacity to embed a new_node in a rundown. Take note of that this

work anticipates that a pointer will head_ref as this can change the

leader of the information connected rundown (like push())*/

void sortedInsert(struct node** head_ref, struct node* new_node)

{

struct node* current;

/* Special case for the head end */

in the event that (*head_ref == NULL || (*head_ref)- >data >= new_node->data)

{

new_node->next = *head_ref;

*head_ref = new_node;

}

else

{

/* Locate the hub before the purpose of addition */

current = *head_ref;

while (current->next!=NULL &&

current->next->data < new_node->data)

{

current = current->next;

}

new_node->next = current->next;

current->next = new_node;

}

}

/* An utility capacity to make another hub */

struct hub *newNode(int new_data)

{

/* allot hub */

struct node* new_node =

(struct node*) malloc(sizeof(struct hub));

/* put in the information */

new_node->data = new_data;

new_node->next = NULL;

return new_node;

}

/* Function to print connected rundown */

void printList(struct hub *head)

{

struct hub *temp = head;

while(temp != NULL)

{

printf("%d ", temp->data);
}