+1 (315) 557-6473 

Implement Nodes and Lists in C Language Assignment Solution.


Instructions

Objective
Write a C assignment program to implement nodes and lists.

Requirements and Specifications

Program to implement nodes and lists in C language
Program to implement nodes and lists in C language 1
Program to implement nodes and lists in C language 2
Program to implement nodes and lists in C language 3

Source Code

package tests;

public class ListUtilities {

 public Node getAllPrefixes(Node node, int minLength, int maxLength) {

  // result list head and cursor nodes

  Node result = null;

  Node resultCurrNode = null;

  // string for building prefixes

  String current = "[";

  // source list cursor node

  Node currNode = node;

  // processed nodes counter

  int count = 0;

  // processing all nodes in the list

  while(currNode != null) {

   if (current.length() == 1) {

    // if current string is empty, adding only int

    current += currNode.getElement().toString();

   }

   else {

    // otherwise adding comma and int

    current += ", " + currNode.getElement().toString();

   }

   // increasing counter

   count++;

   // if counter is between bounds, adding it to result list

   if (count >= minLength && count <= maxLength) {

    if (result == null) {

     // result list is empty now, we have to intitialize head node and cursor

     result = new Node<>(current + "]", null);

     resultCurrNode = result;

    }

    else {

     // adding new node to the end and moving cursor forward

     resultCurrNode.setNext(new Node<>(current + "]", null));

     resultCurrNode = resultCurrNode.getNext();

    }

   }

   // moving forward through source list

   currNode = currNode.getNext();

  }

  // returning result list

  return result;

 }

 public Node getMergedChain(Node nodeA, Node nodeB) {

  // result list head and cursor nodes

  Node result = null;

  Node resultCurrNode = null;

  // cursor node for list A

  Node currNodeA = nodeA;

  // cursor node for list B

  Node currNodeB = nodeB;

  // keep iterating until all nodes from both strings are processed

  while (currNodeA != null || currNodeB != null) {

   // this variable will store element which needed to be added to the result list on current step

   int toAdd;

   if (currNodeA != null && currNodeB != null) {

    // if list A and list B both not processed yet,

    // we must choose the least element among two cursor elements

    int valA = currNodeA.getElement();

    int valB = currNodeB.getElement();

    // selecting min element

    if (valA < valB) {

     toAdd = valA;

     // value from A will be added to the result, shifting A cursor

     currNodeA = currNodeA.getNext();

    }

    else {

     toAdd = valB;

     // value from B will be added to the result, shifting A cursor

     currNodeB = currNodeB.getNext();

    }

   }

   else if (currNodeB == null) {

    // only A list is not processed

    toAdd = currNodeA.getElement();

    // value from A will be added to the result, shifting A cursor

    currNodeA = currNodeA.getNext();

   }

   else {

    // only B list is not processed

    toAdd = currNodeB.getElement();

    // value from B will be added to the result, shifting B cursor

    currNodeB = currNodeB.getNext();

   }

   if (result == null) {

    // result list is empty now, we have to intitialize head node and cursor

    result = new Node<>(toAdd, null);

    resultCurrNode = result;

   }

   else {

    // adding new node to the end and moving cursor forward

    resultCurrNode.setNext(new Node<>(toAdd, null));

    resultCurrNode = resultCurrNode.getNext();

   }

  }

  // returning result list

  return result;

 }

 public Node getInterleavedArithmeticFibonacciSequences(int arithStart, int arithDif, int arithSize, int fibSize) {

  // arithmetic list head and cursor nodes

  Node arithmetic = null;

  Node arithmeticCurrNode = null;

  for (int i = 0; i

   if (arithmetic == null) {

    // if arithmetic list is empty, only intializing nodes and inserting start value

    arithmetic = new Node<>(arithStart, null);

    arithmeticCurrNode = arithmetic;

   }

   else {

    // inserting appropriate value to the end of the list

    arithmeticCurrNode.setNext(new Node<>(arithStart + i * arithDif, null));

    arithmeticCurrNode = arithmeticCurrNode.getNext();

   }

  }

  // fibbonacci list head and cursor nodes

  Node fib = null;

  Node fibCurrNode = null;

  // fib_0

  int prevPrev = 1;

  // fib_!

  int prev = 1;

  // inserting required number of fibbonacci sequence

  for (int i = 0; i

   if (i == 0) {

    // inserting fib_0 into fib list

    fib = new Node<>(prevPrev, null);

    fibCurrNode = fib;

   }

   else if (i == 1) {

    // inserting fib_1 into fib list

    fibCurrNode.setNext(new Node<>(prev, null));

    fibCurrNode = fibCurrNode.getNext();

   }

   else {

    // calculating current fib value

    int curr = prevPrev + prev;

    // inserting it to the list

    fibCurrNode.setNext(new Node<>(curr, null));

    fibCurrNode = fibCurrNode.getNext();

    // reassigning previous fib values

    prevPrev = prev;

    prev = curr;

   }

  }

  // now we will merge obtained two lists into the result list, by interleaving

  arithmeticCurrNode = arithmetic;

  fibCurrNode = fib;

  // result list head and cursor nodes

  Node result = null;

  Node resultCurrNode = null;

  // for interleaving, we need a flag, which shows, from which list was previous entry

  boolean prevFib = true;

  while(arithmeticCurrNode != null || fibCurrNode != null) {

   // variable for value to add

   int toAdd;

   if (arithmeticCurrNode != null && fibCurrNode != null) {

    // both lists are not processed yet

    if (prevFib) {

     // previous node was from fib list

     // inserting value from arithmetic list

     toAdd = arithmeticCurrNode.getElement();

     arithmeticCurrNode = arithmeticCurrNode.getNext();

     prevFib = false;

    }

    else {

     // previous node was from arithmetic list

     // inserting value from fib list

     toAdd = fibCurrNode.getElement();

     fibCurrNode = fibCurrNode.getNext();

     prevFib = true;

    }

   }

   else if (fibCurrNode == null) {

    // fib list is processed

    // inserting value from arithmetic list

    toAdd = arithmeticCurrNode.getElement();

    arithmeticCurrNode = arithmeticCurrNode.getNext();

   }

   else {

    // arithmetic list is processed

    // inserting value from fib list

    toAdd = fibCurrNode.getElement();

    fibCurrNode = fibCurrNode.getNext();

   }

   if (result == null) {

    // if arithmetic list is empty, only intializing nodes and inserting start value

    result = new Node<>(toAdd, null);

    resultCurrNode = result;

   }

   else {

    // adding new node to the end and moving cursor forward

    resultCurrNode.setNext(new Node<>(toAdd, null));

    resultCurrNode = resultCurrNode.getNext();

   }

  }

  // returning result list

  return result;

 }

 public Node getGroupedStrings(Node node, int m, int n) {

  // group 1 list head and cursor nodes

  Node group1 = null;

  Node group1CurrNode = null;

  // group 2 list head and cursor nodes

  Node group2 = null;

  Node group2CurrNode = null;

  // group 3 list head and cursor nodes

  Node group3 = null;

  Node group3CurrNode = null;

  // iterating through source list and inserting each value to one of three lists

  // value order inside group will be preserved

  Node currNode = node;

  while(currNode != null) {

   String val = currNode.getElement();

   if (val.length() < m) {

    if (group1 == null) {

     group1 = new Node<>(val, null);

     group1CurrNode = group1;

    }

    else {

     group1CurrNode.setNext(new Node<>(val, null));

     group1CurrNode = group1CurrNode.getNext();

    }

   }

   else if (val.length() < n) {

    if (group2 == null) {

     group2 = new Node<>(val, null);

     group2CurrNode = group2;

    }

    else {

     group2CurrNode.setNext(new Node<>(val, null));

     group2CurrNode = group2CurrNode.getNext();

    }

   }

   else {

    if (group3 == null) {

     group3 = new Node<>(val, null);

     group3CurrNode = group3;

    }

    else {

     group3CurrNode.setNext(new Node<>(val, null));

     group3CurrNode = group3CurrNode.getNext();

    }

   }

   currNode = currNode.getNext();

  }

  // now we just need to concatenate 3 obtained list

  // doing it by correctly checking nulls

  Node result = group1;

  Node last = group1CurrNode;

  if (last == null) {

   result = group2;

  }

  else {

   last.setNext(group2);

  }

  if (group2 != null) {

   last = group2CurrNode;

  }

  if (last == null) {

   result = group3;

  }

  else {

   last.setNext(group3);

  }

  return result;

 }

}

NODE

package tests;

/*

 * This Node class is provided to you,

 * and you must use it to implement the required class(es) and method(s) in the model package.

 * The StarterTests class in the `tests` package suggests what you need to create in the `model` package.

 * Where the Node class is needed, you must:

 * + Only use the public methods given here.

 * + Not add any additional attributes or methods in this Node class.

 */

public class Node {

 /*

  * Do not modify this class.

  * When your submission is graded, the same starter version of the Node class will be used,

  * meaning that if you made any changes to this class, they would be wiped out

  * and your submitted classes may just stop compiling.

  */

 private E element;

 private Node next;

 /*

  * Constructor

  */

 public Node(E e, Node n) {

  element = e;

  next = n;

 }

 /*

  * Accessors

  */

 public E getElement() {

  return element;

 }

 public Node getNext() {

  return next;

 }

 /*

  * Mutators

  */

 public void setElement(E e) {

  element = e;

 }

 public void setNext(Node n) {

  next = n;

 }

}