В этой задаче достаточно ввести два указателя. Первый будет увеличиваться при прохождении одного узла списка, второй – при прохождении двух узлов. В момент, когда второй указатель дойдёт до конца списка (наткнётся на NULL), первый будет указывать на середину списка.

public class Central {	 	 
 	public static void main(String args[]) {	 	 
 		LinkedList linkedList = new LinkedList();	 	 
		LinkedList.Node head = linkedList.head();	 	 
		linkedList.add( new LinkedList.Node("1"));	 	 
		linkedList.add( new LinkedList.Node("2"));	 	 
		linkedList.add( new LinkedList.Node("3"));	 	 
		linkedList.add( new LinkedList.Node("4"));	 	 
		linkedList.add( new LinkedList.Node("5"));	 	 
		linkedList.add( new LinkedList.Node("6"));	 	 
		linkedList.add( new LinkedList.Node("7"));	 	 
		linkedList.add( new LinkedList.Node("8"));	 	 
		linkedList.add( new LinkedList.Node("9"));	 	 
		linkedList.add( new LinkedList.Node("10"));	 	 
 		LinkedList.Node current = head;	 	 
 		int length = 0;	 	 
 		LinkedList.Node middle = head;	 	 
 		while(current.next() != null){	 	 
 			length++;	 	 
 			if(length%2 ==0){	 	 
 				middle = middle.next();	 	 
 			}	 	 
 			current = current.next();	 	 
 		}	 	 
 		if(length%2 == 1){	 	 
 			middle = middle.next();	 	 
 		}	 	 
 		System.out.println("length of LinkedList: " + length);	 	 
 		System.out.println("middle element of LinkedList : " + middle);	 
	}	 	 
}	 	 
class LinkedList{	 	 
 	private Node head;	 	 
	private Node tail;	 	 
	public LinkedList(){	 	 
	this.head = new Node("head");	 	 
		tail = head;	 	 
	}	 	 
 	public Node head(){	 	 
 		return head;	 	 
 	}	 	 
 	public void add(Node node){	 	 
 		tail.next = node;	 	 
 		tail = node;	 	 
 	}	 	 
 	public static class Node{	 	 
 		private Node next;	 	 
 		private String data;	 	 
 		public Node(String data){	 	 
 			this.data = data;	 	 
		}	 	 
	 	public String data() {	 	 
			 return data;	 	 
		}	 	 
 		public void setData(String data) {	 	 
 			this.data = data;	 	 
 		}	 	 
 		public Node next() {	 	 
 			return next;	 	 
 		}	 	 
 		public void setNext(Node next) {	 	 
 			this.next = next;	 	 
 		}	 	 
 		public String toString(){	 	 
 			return this.data;	 	 
 		}	 	 
 	}	 	 
}

Если в списке есть цикл, то в какой-то момент оба указателя будут показывать на один и тот же узел списка.

Можно использовать ту же схему решения. Первый указатель показывает на первый узел в связанном списке, второй на i-тый сначала. Когда второй указатель достигнет конца списка (дойдёт до NULL), первый будет указывать на i-тый элемент с конца.

1. Считаем сумму всех чисел от 1 до 100 любым удобным для Вас методом.
2. Считаем сумму элементов массива.
3. Вычитаем первое из второго. Получаем… Правильно, получаем значение дублирующегося элемента.
4. Если надо, находим номера искомых элементов в массиве.

package Javatest.company;
public class Reverse {
    public static String reverseByArray(String s) {
        char[] a = s.toCharArray();
        char[] b = new char[a.length];
        for (int i = 0; i < a.length; i++) {
            b[(a.length - 1) - i] = a[i];
        }
        return new String(b);
    }
    public static void main(String[] args) {
        String string = "Java test";
        System.out.println(reverseByArray(string));
    }
}

package Javatest.company;
import java.util.Arrays;
public class Bubble {
    public static void main(String args[]) {
        int[] unsorted = {32, 39,21, 45, 23, 3};
        bubbleSort(unsorted);
        int[] test = { 5, 3, 2, 1};
        bubbleSort(test);
    }
    public static void bubbleSort(int[] unsorted){
        System.out.println("unsorted array before sorting : " + Arrays.toString(unsorted));
        for(int i=0; i<unsorted.length -1; i++){
            for(int j= 1; j unsorted[j]){
                    int temp = unsorted[j];
                    unsorted[j] = unsorted[j-1];
                    unsorted[j-1] = temp;
                }
            }
            System.out.printf("unsorted array after %d pass %s: %n", i+1, Arrays.toString(unsorted));
        }
    }
}

Задавая такие вопросы, ваш собеседник, понятное дело, хочет услышать не заученное определение из учебника или получить ссылку из Википедии, а оценить ваше собственное понимание различия этих двух типов структур данных.
Стек и очередь похожи отсутствием свободного доступа ко всем элементам структуры данных. Главное же отличие заключается в том, что стек – это структура типа LIFO(Last In First Out), где свободный доступ возможен только к последнему добавленному элементу, а при его удалении методом «pop» к элементу, добавленному перед ним. Когда же в стек добавляется новый элемент, доступен становится только он.
Очередь относится к типу FIFO(First In First Out), то есть доступен в ней только первый добавленный элемент. В случае его удаления доступен второй и т.д.

Этот вопрос довольно часто на собеседовании слышат те, кто сумели быстро найти 1 дублирующийся элемент в массиве. Для решения этой задачи можно использовать HashMap. Как Вы, несомненно, знаете, HashMap хранит данные парами – ключ/значение, и создав нужное количество карточек, Вы легко найдёте все повторы и их номера.

В обоих списках узлы связаны посредством указателей. Только в односвязном списке указатель от каждого узла ведёт исключительно к следующему, и переход возможен только к нему, то есть исключительно в одном направлении. А в двусвязном от каждого узла, кроме первого и последнего, есть возможность перейти как к следующему, так и к предыдущему узлу, то есть двигаться в обоих направлениях.

package javatest.company;
import java.util.Scanner;
public class Main {
    public static void main(String args[]) {
        System.out.println("Enter number upto which Fibonacci series to print: ");
        int number = new Scanner(System.in).nextInt();
        System.out.println("Fibonacci series upto " + number +" numbers : ");
        for(int i=1; i<=number; i++){
            System.out.print(fibonacci2(i) +" ");
        }
    }
    public static int fibonacci(int number){
        if(number == 1 || number == 2){
            return 1;
        }
        return fibonacci(number-1) + fibonacci(number -2); 
    }
    public static int fibonacci2(int number){
        if(number == 1 || number == 2){
            return 1;
        }
        int fibo1=1, fibo2=1, fibonacci=1;
        for(int i= 3; i<= number; i++){
            fibonacci = fibo1 + fibo2; 
            fibo1 = fibo2;
            fibo2 = fibonacci;
        }
        return fibonacci;
    }
}

1. Для определения значения каждого символа в числе можно использовать оператор /. Например: 66/10 вернёт 6.
2. А для нахождения последнего символа в числе оператор %.
   66%10=6
   123%10=3
3. Сравниваем полученные значения и делаем выводы.

Можно пойти другим путём и развернуть число, используя рекурсию.

Например, так:

package com.Javatest;
public class Palindrome {
    public static int recursion(int n) {
        if (n < 10) {
            return n;
        }
        else {
            System.out.print(n % 10 + " ");
            return recursion(n / 10);
        }
    }
    public static void main(String[] args) {
        System.out.println(recursion(123)); 
    }
}

package Javatest.com;
public class Palword {
    public static String recursion(String s) {
        if (s.length() == 1) {
            return "YES";
        } else {
            if (s.substring(0, 1).equals(s.substring(s.length() - 1, s.length()))) {
                if (s.length() == 2) {
                    return "YES";
                }
                return recursion(s.substring(1, s.length() - 1));
            } else {
                return "NO";
            }
        }
    }
    public static void main(String[] args) {
        System.out.println(recursion("ABBA")); 
    }
}

Бинарное, или двоичное дерево поиска – это структура данных, каждый узел в которой может иметь от 1 до 2 подузлов (детей) или не иметь их вовсе.

Расположение данных в бинарном дереве имеет ряд ограничений:

1. Как и во всех деревьях, любой узел бинарного дерева не может иметь более одного родителя.
2. Данные в дереве распределяются в зависимости от их значений. Если значение подузла (ребёнка) меньше, чем значение узла (родителя), этот подузел становиться левым или ребёнком левого подузла, если левый подузел уже существует. Соответственно, если значение подузла больше значения узла, то он становится правым или ребёнком правого.

Применяются бинарные деревья в реализации ассоциативных массивов и множеств, например TreeMap или TreeSet, в некоторых алгоритмах вычислительной геометрии.