For a linked version of insertion sort, since there is no movement of data, there is no need to start searching at the end of the sorted sublist. Instead, we shall traverse the original list, taking one entry at a time and inserting it in the proper position in the sorted list. The pointer variable last_sorted will reference the end of algorithm the sorted part of the list, and last_sorted->next will reference the first entry that has not yet been inserted into the sorted sublist. We shall let first_unsorted also point to this entry and use a pointer current to search the sorted part of the list to find where to insert *first_unsorted. If *first_unsorted belongs before the current head of the list, then we insert it there. Otherwise, we move current down the list until first_unsorted->entry <= current->entry and then insert *first_unsorted before *current. To enable insertion before *current we keep a second pointer trailing in lock step one position closer to the head than current. implement given statements

For a linked version of insertion sort, since there is no movement of data, there is no need to start searching at the end of the sorted sublist. Instead, we shall traverse the original list, taking one entry at a time and inserting it in the proper position in the sorted list. The pointer variable last_sorted will reference the end of algorithm the sorted part of the list, and last_sorted->next will reference the first entry that has not yet been inserted into the sorted sublist. We shall let first_unsorted also point to this entry and use a pointer current to search the sorted part of the list to find where to insert first_unsorted. If first_unsorted belongs before the current head of the list, then we insert it there. Otherwise, we move current down the list until first_unsorted->entry <= current->entry and then insert first_unsorted before current. To enable insertion before *current we keep a second pointer trailing in lock step one position closer to the head than current. implement given statements

C++ Programming: From Problem Analysis to Program Design

8th Edition

ISBN:9781337102087

Author:D. S. Malik

Publisher:D. S. Malik

Chapter17: Linked Lists

Section: Chapter Questions

Problem 18PE

See similar textbooks

Similar questions

You are given the pointer to the head node of a linked list and an integer to add to the list. Create a new node with the given integer. Insert this node at the tail of the linked list and return the head node of the linked list formed after inserting this new node. The given head pointer may be null, meaning that the initial list is empty. Function Description Complete the insertNodeAtTail function in the editor below. insertNodeAtTail has the following parameters: SinglyLinkedListNode pointer head: a reference to the head of a list int data: the data value for the node to insert Returns SinglyLinkedListNode pointer: reference to the head of the modified linked list Input Format The first line contains an integer , the number of elements in the linked list.The next lines contain an integer each, the value that needs to be inserted at tail. Constraints Sample Input STDIN Function ----- -------- 5 size of linked list n = 5 141 linked list data values…
True/False Select true or false for the statements below. Explain your answers if you like to receive partial credit. 3) Which of the following is true about the insertBeforeCurrent function for a CircularLinked List (CLL) like you did in programming exercise 1?a. If the CLL is empty, you need to create the new node, set it to current, andhave its next pointer refer to itselfb. The worst case performance of the function is O(n)c. If you insert a new element with the same data value as the current node, theperformance improves to O(log n)
in c++ Create a single linked list that contains the data (age) of your friends. Perform basic operations including insertion, deletion, searching and display. The insertion operation should only allow a friend’s data to be inserted in sorted order only.
The function interleave_lists in python takes two parameters, L1 and L2, both lists. Notice that the lists may have different lengths. The function accumulates a new list by appending alternating items from L1 and L2 until one list has been exhausted. The remaining items from the other list are then appended to the end of the new list, and the new list is returned. For example, if L1 = ["hop", "skip", "jump", "rest"] and L2 = ["up", "down"], then the function would return the list: ["hop", "up", "skip", "down", "jump", "rest"]. HINT: Python has a built-in function min() which is helpful here. Initialize accumulator variable newlist to be an empty list Set min_length = min(len(L1), len(L2)), the smaller of the two list lengths Use a for loop to iterate k over range(min_length) to do the first part of this function's work. On each iteration, append to newlist the item from index k in L1, and then append the item from index k in L2 (two appends on each iteration). AFTER the loop…
Introduction For this assignment, you are to write a program which implements a Sorted List data structure using a circular array-based implementation and a driver program that will test this implementation. The Sorted List ADT is a linear collection of data in which all elements are stored in sorted order. Your implementation has to store a single int value as each element of the list and support the following operations: 1. add(x) – adds the integer x to the list. The resulting list should remain sorted in increasing order. The time complexity of this operation should be 0(N), where N is the size of the list. 2. removefirst() - deletes the first integer from the list and returns its value. The remaining list should remain sorted. Time complexity of this operation should be 0(1). 3. removelast() – deletes the last integer from the list and returns its value. The remaining list should remain sorted. Time complexity of this operation should be 0(1). 4. exists(x) – returns true if the…
InterpolationAssignment DescriptionMeike, our climate scientist, was very happy with the program you wrote to calculate the maximum temperature drop. Now she has the following problem; in a series of measurements shediscovers one data point is missing, but not which one. She does know that the measurementsshow a constant increase.Write a function, interpolate(list), that completes a given series. Provide as output the indexbehind which the element should be inserted and the value. You can assume that the measurements are natural numbers and that the input consists of at least 3 measurements. You can assumethat both the first and the last data point have not been droppedP.S. Meike is in a hurry; your algorithm must run in O(log n) time.ExampleInput Output 1 Output 2[1, 2, 4] 1 3[3, 7, 11, 19] 2 15NotesMake sure to turn in your code with the filename “Interpolation.py”. If you turn it in withany other name it will fail the tests. This is due to instead of this assignment giving you an…
C++ ONLY Add the following functions to the linked list. int getSize() -> This function will return the number of elements in the linked-list. This function should work in O(1). For this keep track of a size variable and update it when we insert a new value in the linked-list. int getValue(index) -> This function will return the value present in the input index. If the index is greater or equal to the size of the linked-list return -1. void printReverse() -> This function will print the linked list in reverse order. You don’t need to reverse the linked list. Just need to print it in reverse order. You need to do this recursively. You cannot just take the elements in an array or vector and then print them in reverse order. void swapFirst() -> This function will swap the first two nodes in the linked list. If the linked-list contains less than 2 elements then just do nothing and return. To check your code add the following code in your main function. LinkedList l;…
There are many differences between array and linked list, one of these differences: a. In a linked list insertion and deletion takes more time b. Array supports random access while linked List supports sequential access c. in linked list, elements are stored in contiguous memory location while in array are stored anywhere in the memory d. None of the above
Merge2AscListsRecur that combines the nodes in X-list and Y-list into Z-list such that, after calling the function, Z-list is a sorted list (in non-decreasing order) containing all the nodes initially contained in X-list and Y-list – X-list and Y-list should both be empty after the call. The function should: ► Have only three parameters (each a pointer-to-Node) and no return value (be a void function). ► Not use any global variables or static local variables. ► Not use any looping constructs (for, while, do-while, ...). ► Be directly (not indirectly) recursive. ► Not create any new nodes, destroy any existing nodes or copy/replace the data item of any node. ► Not make temporary copies of the data involved using any other storage structures (arrays, stacks, queues, etc.). ► Use (if ever needed) no more than a small number of pointers to hold certain link addresses. ○ Not make temporary copies of the…
Write the following function that partitions the list using the first element, called a pivot:def partition(lst): After the partition, the elements in the list are rearranged so that all the elements before the pivot are less than or equal to the pivot and the element after the pivot are greater than the pivot. The function also returns the index where the pivot is located in the new list. For example, suppose the list is [5, 2, 9, 3, 6, 8]. After the partition, the list becomes [3, 2, 5, 9, 6, 8]. Implement the function in a way that takes len(lst) comparisons. Write a test program that prompts the user to enter a list and displays the list after the partition.
Recamán's sequence def recaman_item(n):Compute and return the n:th term of the Recamán's sequence. See the linked definition for this sequence on Wolfram Mathworld. Note how the definition for the current element in this sequence depends on whether some particular number can be found in the previously generated prefix of the sequence. To allow your function to execute in a sure and speedy fashion even for millions of elements, you should use a set to keep track of which elements are already part of the prefix of the sequence generated so far. This way you can generate each element in constant time, instead of having to iterate through the entire previously generated list the way some "Shlemiel" might approach this problem. n Expected result 1 1 8 12 13 23 57 87 395743 258330 The previous version of this problem, simply called recaman in the very first versions of this problem collection,…
Computer Science In c++ (There should be three different files, "main.cpp", "sourcefile.cpp" and "header.cpp" your solution must have those three different files): Write a function that checks if the nodes in a linked list is sorted in ascending order. The function should return true if the values are sorted, otherwise false. Take user input. Call the funciton in the main function to show it is working.