循环链表中索引处的元素

Question

I was reading about circular linked lists. Here is a code which I do not understand how it works.

public int elementAt(int index){
        if(index>size){
            return -1;
        }
        Node n = head;
        while(index-1!=0){ // this line is unclear for me
            n=n.next;
            index--;
        }
        return n.data;
    }

I would write the same code but in this way :

public int elementAt(int index){
        if(index>size){
            return -1;
        }
        Node n = head;
        while(n.size != index){ // here is my change in the code
            n=n.next;
        }
        return n.data;
    }

Here is the whole code : http://algorithms.tutorialhorizon.com/circular-linked-list-complete-implementation/

Am I doing right in the second code ?

Thanks

Answer 1

The example code uses a 1-based index: 1, 2, 3, ..., size. Which is strange in computer science, where one would expect: 0, .. , size-1.

Unfortunately size is a property of the entire list, not a single Node in the list. So their solution is fine.

Though when index <= 0 then nice things happen.

---

For a real circular list the Node has a previous field. And the last node is linked both ways to the first node.

In that case you can walk in both directions, following next or previous . Then when index < size / 2 one would by next forwards to the index, or else go back by previous for about (size - index) steps. In order to take the least number of steps.

Answer 2

it is just doing a count. You can do it in various way. I assume that the size is the size of your LinkedList. In that case your code is wrong. you can do like following

public int elementAt(int index){
        if(index>size){
            return -1;
        }
        Node n = head;
        int i = 0; // zero-indexing
        while(i++ != index){ // you can increment i at the end too
            n=n.next;
        }
        return n.data;
    }

FIrst code is also counting, but instead of using another variable it used the existing one

Answer 3

The line which you do not understand is just counting "index" positions fordward, and it is starting at head. So the method is giving you back the element "index -1" positions from the head element Other assumption is that the head element is at 1