package circularlinkedlist; import java.util.Iterator; public class CircularLinkedList implements Iterable { // Your variables Node head; Node tail; int size; // BE SURE TO KEEP TRACK OF THE SIZE // implement this constructor public CircularLinkedList() { }
package circularlinkedlist;
import java.util.Iterator;
public class CircularLinkedList<E> implements Iterable<E> {
// Your variables
Node<E> head;
Node<E> tail;
int size; // BE SURE TO KEEP TRACK OF THE SIZE
// implement this constructor
public CircularLinkedList() {
}
// I highly recommend using this helper method
// Return Node<E> found at the specified index
// be sure to handle out of bounds cases
private Node<E> getNode(int index ) {
return null;
}
// attach a node to the end of the list
public boolean add(E item) {
this.add(size,item);
return false;
}
// Cases to handle
// out of bounds
// adding to empty list
// adding to front
// adding to "end"
// adding anywhere else
// REMEMBER TO INCREMENT THE SIZE
public void add(int index, E item){
}
// remove must handle the following cases
// out of bounds
// removing the only thing in the list
// removing the first thing in the list (need to adjust the last thing in the list to point to the beginning)
// removing the last thing
// removing any other node
// REMEMBER TO DECREMENT THE SIZE
public E remove(int index) {
return null;
}
// Turns your list into a string
// Useful for debugging
public String toString(){
Node<E> current = head;
StringBuilder result = new StringBuilder();
if(size == 0){
return "";
}
if(size == 1) {
return head.item.toString();
}
else{
do{
result.append(current.item);
result.append(" ==> ");
current = current.next;
} while(current != head);
}
return result.toString();
}
public Iterator<E> iterator() {
return new ListIterator<E>();
}
// provided code for different assignment
// you should not have to change this
// change at your own risk!
// this class is not static because it needs the class it's inside of to survive!
private class ListIterator<E> implements Iterator<E>{
Node<E> nextItem;
Node<E> prev;
int index;
@SuppressWarnings("unchecked")
//Creates a new iterator that starts at the head of the list
public ListIterator(){
nextItem = (Node<E>) head;
index = 0;
}
// returns true if there is a next node
// this is always should return true if the list has something in it
public boolean hasNext() {
// TODO Auto-generated method stub
return size != 0;
}
// advances the iterator to the next item
// handles wrapping around back to the head automatically for you
public E next() {
// TODO Auto-generated method stub
prev = nextItem;
nextItem = nextItem.next;
index = (index + 1) % size;
return prev.item;
}
// removed the last node was visted by the .next() call
// for example if we had just created a iterator
// the following calls would remove the item at index 1 (the second person in the ring)
// next() next() remove()
public void remove() {
int target;
if(nextItem == head) {
target = size - 1;
} else{
target = index - 1;
index--;
}
CircularLinkedList.this.remove(target); //calls the above class
}
this is SolitaireEncryption.java
public class SolitaireEncryption {
public static char encryptChar(char letter, int key) {
int value = letter - 'a';
int encryptedValue = (value + key) % 26;
char encryptedChar = (char) (encryptedValue+'a');
return encryptedChar;
}
public static char decryptChar(char letter, int key) {
int value = letter - 'a';
int decryptedValue = (value + (26-key)) % 26;
char decryptedChar = (char) (decryptedValue+'a');
return decryptedChar;
}
public int getKey(CircularLinkedList<Integer> deck){ // calls the steps methods
return -1;
}
private static void step1(CircularLinkedList<Integer> deck){
}
private static void step2(CircularLinkedList<Integer> deck){
}
private static void step3(CircularLinkedList<Integer> deck){
}
private static void step4(CircularLinkedList<Integer> deck){
}
private static int step5(CircularLinkedList<Integer> deck){
return -1;
}
public static void main(String[] args) {
CircularLinkedList<Integer> deck = new CircularLinkedList<>();
}
}
}
// It's easiest if you keep it a singly linked list
// SO DON'T CHANGE IT UNLESS YOU WANT TO MAKE IT HARDER
private static class Node<E>{
E item;
Node<E> next;
public Node(E item) {
this.item = item;
}
}
public static void main(String[] args){
}
}
Trending now
This is a popular solution!
Step by step
Solved in 2 steps
