Selection Sort

Question

I've reached yet another problem, but good friends. Another LinkedList sorting problem here...
public void selectionSort(LinkedList list) {
        if(list.isEmpty())
            System.out.println("List is currently empty.");
        else if (list.size() == 1)
            System.out.println("List is already sorted.");
        else{
            Node t1 = list.getFirst();
            while(t1.getNext()!=null)t1=t1.getNext();
            while(t1!=null) {
                Node t2=list.getFirst(),t3=t1;
                while(t2!=t1) {
                    if(t2.getData()>t3.getData())t3=t2;
                    t2=t2.getNext();
                int temp=t3.getData();
                t3.setData(t1.getData());
                t1.setData(temp);
                t1=t1.getPrev();
    }This sort of works...and sort of don't. Any advice?

Answer 1

Well here's the list class...I thought it was fine...
public class LinkedList {
    private Node head, tail;
    private int count;
    public LinkedList() {
        head = new Node(0, null, null);
        tail = new Node(0, head, null);
        count = 0;
        head.setNext(tail);
    public LinkedList(LinkedList rhs) {   //Copy constructor
        head = rhs.head;
        tail = rhs.tail;
        count = rhs.count;
    public void orderedInsert(int item) {   //Inserts the Node in the right position - Ascending
        Node back = null;
        Node newNode = new Node(item);
        Node pointer = head;
        boolean found = false;
        while(pointer != null && !found) {
            if(pointer.getData() > item)
                found = true;
            else {
                back = pointer;
                pointer = pointer.getNext();
        newNode.setNext(pointer);
        if(back == null) {
            head = newNode;
            count++;
        } else {
            back.setNext(newNode);
            count++;
    public void insert(int item) {   //Inserts at front of list
        Node newnode = new Node(item);
        if(head == null)
            head = newnode;
        else {
            newnode.setNext(head);
            head = newnode;
        count++;
    public void orderedRemove(int item) {   //Searches and removes selected Node
        Node back = null;
        boolean found = false;
        Node pointer = head;
        while(pointer != null && !found) {
            if(pointer.getData() == item)
                found = true;
            else {
                back = pointer;
                pointer = pointer.getNext();
        if(found)
            if(back == null) {
            head = pointer.getNext();
            count--;
            } else {
            back.setNext(pointer.getNext());
            count--;
            } else
                System.out.println("Data not found in list.");
    public void remove() {   //Removes from front of list
        if(head == null)
            System.out.println("List is currently empty.");
        else {
            Node n = head;
            head = head.getNext();
            n.setNext(null);
            count--;
    public boolean isEmpty() {return(count == 0);}
    public void print() {
        Node current = head;
        while(current != null) {
            System.out.println(current.getData());
            current = current.getNext();
    public int size() {return count;}
    public Node getFirst() throws IllegalStateException {
        if(isEmpty()) throw new IllegalStateException("List is empty");
        return head;
    public Node getLast() throws IllegalStateException {
        if(isEmpty()) throw new IllegalStateException("List is empty");
        return tail;
    public Node getPrev(Node v) throws IllegalArgumentException {
        if(v == head) throw new IllegalArgumentException
                ("Cannot move back past the head of the list");
        return v.getPrev();
    public Node getNext(Node v) throws IllegalArgumentException {
        if(v == tail) throw new IllegalArgumentException
                ("Cannot move forward past the tail of the list");
        return v.getNext();
    public void addBefore(Node v, Node z) throws IllegalArgumentException {
        Node u = getPrev(v);
        z.setPrev(u);
        z.setNext(v);
        v.setPrev(z);
        u.setNext(z);
        count++;
    public void addAfter(Node v, Node z) {
        Node w = getNext(v);
        z.setPrev(v);
        z.setNext(w);
        w.setPrev(z);
        v.setNext(z);
        count++;
    public void addFirst(Node v) {addAfter(head, v);}
    public void addLast(Node v) {addBefore(tail, v);}
    public void remove(Node v) {
        Node u = getPrev(v);
        Node w = getNext(v);
        w.setPrev(u);
        u.setNext(w);
        v.setPrev(null);
        v.setNext(null);
        count--;
    public boolean hasPrev(Node v) {return v != head;}
    public boolean hasNext(Node v) {return v != tail;}I'll try your idea and see what results I get.