循环链表可以像链表一样只有单向引用，也可以像双向链表一样有双向引用。循环链表和链表之间唯一的区别在于，最后一个元素指向下一个元素的指针（tail.next）不是引用null，而是指向第一个元素（head）
双向循环链表有指向head元素的tail.next，和指向tail元素的head.prev

实现一个循环链表

  1. function CircularLinkedList() {
  3.     let Node = function(element){
  5.         this.element = element;
  6.         this.next = null;
  7.     };
  9.     let length = 0;
  10.     let head = null;
  12.     this.append = function(element){
  14.         let node = new Node(element),
  15.             current;
  17.         if (head === null){ //first node on list
  18.             head = node;
  19.         } else {
  21.             current = head;
  23.             //loop the list until find last item
  24.             while(current.next !== head){ //last element will be head instead of NULL
  25.                 current = current.next;
  26.             }
  28.             //get last item and assign next to added item to make the link
  29.             current.next = node;
  30.         }
  32.         //set node.next to head - to have circular list
  33.         node.next = head;
  35.         length++; //update size of list
  36.     };
  38.     this.insert = function(position, element){
  40.         //check for out-of-bounds values
  41.         if (position >= 0 && position <= length){
  43.             let node = new Node(element),
  44.                 current = head,
  45.                 previous,
  46.                 index = 0;
  48.             if (position === 0){ //add on first position
  50.                 if(!head){ // if no node  in list
  51.                     head = node;
  52.                     node.next = head;
  53.                 }else{
  54.                     node.next = current;
  56.                     //update last element
  57.                     while(current.next !== head){ //last element will be head instead of NULL
  58.                         current = current.next;
  59.                     }
  61.                     head = node;
  62.                     current.next = head;
  63.                 }
  66.             } else {
  67.                 while (index++ < position){
  68.                     previous = current;
  69.                     current = current.next;
  70.                 }
  71.                 node.next = current;
  72.                 previous.next = node;
  73.             }
  75.             length++; //update size of list
  77.             return true;
  79.         } else {
  80.             return false;
  81.         }
  82.     };
  84.     this.removeAt = function(position){
  86.         //check for out-of-bounds values
  87.         if (position > -1 && position < length){
  89.             let current = head,
  90.                 previous,
  91.                 index = 0;
  93.             //removing first item
  94.             if (position === 0){
  96.                 while(current.next !== head){ //needs to update last element first
  97.                     current = current.next;
  98.                 }
  100.                 head = head.next;
  101.                 current.next = head;
  103.             } else { //no need to update last element for circular list
  105.                 while (index++ < position){
  107.                     previous = current;
  108.                     current = current.next;
  109.                 }
  111.                 //link previous with current's next - skip it to remove
  112.                 previous.next = current.next;
  113.             }
  115.             length--;
  117.             return current.element;
  119.         } else {
  120.             return null;
  121.         }
  122.     };
  124.     this.remove = function(element){
  126.         let index = this.indexOf(element);
  127.         return this.removeAt(index);
  128.     };
  130.     this.indexOf = function(element){
  132.         let current = head,
  133.             index = -1;
  135.         //check first item
  136.         if (element == current.element){
  137.             return 0;
  138.         }
  140.         index++;
  142.         //check in the middle of the list
  143.         while(current.next !== head){
  145.             if (element == current.element){
  146.                 return index;
  147.             }
  149.             current = current.next;
  150.             index++;
  151.         }
  153.         //check last item
  154.         if (element == current.element){
  155.             return index;
  156.         }
  158.         return -1;
  159.     };
  161.     this.isEmpty = function() {
  162.         return length === 0;
  163.     };
  165.     this.size = function() {
  166.         return length;
  167.     };
  169.     this.getHead = function(){
  170.         return head;
  171.     };
  173.     this.toString = function(){
  175.         let current = head,
  176.             s = current.element;
  178.         while(current.next !== head){
  179.             current = current.next;
  180.             s += ', ' + current.element;
  181.         }
  183.         return s.toString();
  184.     };
  186.     this.print = function(){
  187.         console.log(this.toString());
  188.     };
  189. }