zadanieelementylisty

public class ElemOne<T> {

    private T data;
    private ElemOne next;

    public ElemOne(T data) {
        this.data = data;
    }

    public ElemOne(T data, ElemOne next) {
        this.data = data;
        this.next = next;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public ElemOne getNext() {
        return next;
    }

    public void setNext(ElemOne next) {
        this.next = next;
    }

    public boolean hasNext(){
        return next != null;
    }
}








public class ListOne<T> implements IList<T> {

    ElemOne<T> pierwszy;
    ElemOne<T> ostatni;
    int licznik;

    public ListOne() {
        pierwszy = null;
        ostatni = null;
        licznik = 0;
    }

    @Override
    public void addFirst(T newData) {
        ElemOne<T> eo = new ElemOne(newData, null);
        if (pierwszy == null) {
            pierwszy = eo;
            ostatni = eo;
        } else {
            ElemOne<T> tmp = pierwszy;
            pierwszy = eo;
            pierwszy.setNext(tmp);
        }
        licznik++;
    }

    @Override
    public void addLast(T newData) {
        ElemOne<T> last = new ElemOne(newData, null);
        ElemOne<T> tmp = ostatni;
        ostatni = last;
        tmp.setNext(ostatni);
        licznik ++;
    }

    @Override
    public void addAtPosition(T newData, int position) throws ListException {
        if (position == licznik + 1){
            addLast(newData);
            return;
        }

        ElemOne<T> ee = new ElemOne(newData,null);
        System.out.println("if position > licznik " + position + " > " + licznik);
        if (position > licznik){
            //dupa nie da sie - wywalic wyjatek
        } else {
            ElemOne<T> elementAtPosition = getElementAtPosition(position);
            ElemOne<T> prev = getPrev(pierwszy, elementAtPosition);
            if (prev == null){
                //dodanie jako pierwszy
                ElemOne<T> tmp = pierwszy;
                pierwszy = ee;
                pierwszy.setNext(tmp);
            } else {
                System.out.println("prev = " + prev.getData().toString());
                prev.setNext(ee);
                ee.setNext(elementAtPosition);
            }
            licznik ++;
        }
    }

    @Override
    public int size() {
        return licznik-1;
    }

    @Override
    public T removeFirst() throws ListException {
        ElemOne<T> elementAtPosition = getElementAtPosition(1);
        ElemOne<T> prev = getPrev(pierwszy, elementAtPosition);
        prev.setNext(elementAtPosition.getNext());
        return elementAtPosition.getData();
    }

    @Override
    public T removeLast() throws ListException {
        ElemOne<T> eo = new ElemOne(ostatni);
        ElemOne<T> prev = getPrev(pierwszy, ostatni);
        ostatni = prev;
        ostatni.setNext(null);
        return eo.getData();
    }

    @Override
    public T remove(int position) throws ListException {
        ElemOne<T> elementAtPosition = getElementAtPosition(position);
        ElemOne<T> prev = getPrev(pierwszy, elementAtPosition);
        prev.setNext(elementAtPosition.getNext());
        return elementAtPosition.getData();
    }

    @Override
    public int find(T dataToFind) {
        int index = 1;
        ElemOne<T> tmp = pierwszy;
        while(index != licznik){
            if (tmp.getData().equals(dataToFind)){
                return index;
            } else {
                tmp = tmp.getNext();
                index ++;
            }
        }
        //brak oczekiwanej wartosci
        return -1;
    }

    @Override
    public boolean contains(T data) {
        ElemOne<T> tmp = pierwszy;
        int index = 0;
        while(index != licznik){
            if (tmp.getData().equals(data)){
                return true;
            } else {
                index ++;
                tmp = tmp.getNext();
            }
        }
        //brak oczekiwanej wartosci
        return false;
    }

    @Override
    public void print() {
        ElemOne<T> tmp = pierwszy;
        int index = 1;

        System.out.println("element [" + index + "] = " + tmp.getData().toString());
        while(tmp.hasNext()){
            index ++;
            tmp = tmp.getNext();
            System.out.println("element [" + index + "] = " + tmp.getData().toString());
        }
    }
    private ElemOne<T> getPrev(ElemOne<T> iterator, ElemOne<T> tmp) {
        if (iterator.equals(tmp)){
            return null; //pierweszy element nie ma poprzedniego - nalezy obsluzyc zwracanego nulla
        } else{
            if(iterator.getNext() != null){
                while(!iterator.getNext().equals(tmp)){
                    if(iterator.getNext() != null){
                        iterator = iterator.getNext();
                    }
                }
            }
            return iterator;
        }
    }

    private ElemOne<T> getElementAtPosition(int position) {

        int index = 1;
        ElemOne<T> iterator = pierwszy;
        while(index != position){
            iterator = iterator.getNext();
            index ++;
        }
        return iterator;

    }



}









public class Main {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws ListException {

        ListOne l = new ListOne();
        l.addFirst(5);
        l.addLast(3);
        l.addLast(4);
        l.addLast(11);
        l.addLast(2);
        l.addLast(1);
        l.addLast(7);
        System.out.println("Pierwszy element: "+l.pierwszy.getData().toString());
        System.out.println("Ostatni element: "+l.ostatni.getData().toString());

        l.print();

        System.out.println("Gdzie jest 11?: "+l.find(11));
        System.out.println("Czy zawiera 2?: "+l.contains(2));
        System.out.println("Rozmiar listy: "+l.size());
        System.out.println("Usuwam element z pozycji 3: ");
        l.remove(3);
        l.print();

        System.out.println("Usuwam ostatni element: ");
        l.removeLast();
        l.print();

        System.out.println("Usuwam pierwszy element: ");
        l.removeFirst();
        l.print();
    }

}












public class ListException extends Exception {

    public ListException(String message) {
        super(message);
    }

}





public interface IList<T> {

    /**
     * Dodaje dane na poczatek listy.
     *
     * @param newData dane do dodania
     */
    public void addFirst(T newData);

    /**
     * Dodaje dane na koniec listy.
     *
     * @param newData dane do dodania
     */
    public void addLast(T newData);

    /**
     * Dodaje dane do listy we wskazanym miejscu.
     *
     * @param newData dane do dodania
     * @param position pozycja w liscie, na ktorej maja znajdowac sie nowe dane
     * po pomyslnym wykonaniu operacji. Wartosc zero odpowiada pocztkowi listy.
     * @throws ListException jezeli podana pozycja jest mniejsza niz zero lub
     * wieksza niz liczba elementow w liscie
     */
    public void addAtPosition(T newData, int position) throws ListException;

    /**
     * Zwraca liczbe elementow listy.
     *
     * @return liczba elementow listy
     */
    public int size();

    /**
     * Usuwa poczatkowy element listy.
     *
     * @return dane z usuwanego elementu
     * @throws ListException jezeli lista jest pusta
     */
    public T removeFirst() throws ListException;

    /**
     * Usuwa ostatni element listy.
     *
     * @return dane z usuwanego elementu
     * @throws ListException jezeli lista jest pusta
     */
    public T removeLast() throws ListException;

    /**
     * Usuwa element listy o podanym indeksie.
     *
     * @param position indeks elementu do usuniecia. Pierwszy element listy ma
     * indeks zero.
     * @return dane z usuwanego elementu
     * @throws ListException jezeli podany indeks jest mniejszy niz zero lub
     * wiekszy niz aktualny rozmiar listy
     */
    public T remove(int position) throws ListException;

    /**
     * Wyszukuje w liscie element o podanej wartosci.
     *
     * @param dataToFind poszukiwane dane
     * @return indeks pierwszego elementu listy, ktory zawiera poszukiwane dane,
     * lub -1, jesli lista nie zawiera poszukiwanej wartosci
     */
    public int find(T dataToFind);

    /**
     * Sprawdza, czy lista zawiera podana wartosc.
     * @param data poszukiwane dane
     * @return true, jesli lista zawiera poszukiwane dane, lub false w przeiwnym wypadku
     */
    public boolean contains(T data);

    /**
     * Wypisuje na ekran zawartosc listy.
     */
    public void print();
}