vlist java实现-转

转自：http://www.blogjava.net/changedi/archive/2012/04/15/374226.html

vlist是一种列表的实现。结构如下图：

 （图来源wikipedia）

类似链接表的结构，但是，不是线性的。它的结构基于一种2的幂次扩展，第一个链接节点包含了列表的前一半数据，第二个包含了剩下一半的一半，依次递归。节点的基本结构不像LinkedList的节点是双端队列，每个VListCell包含了下个节点的指针mNext和前一个节点的指针mPrev，同时内置一个数组mElems用来存放当前节点的数据集合，包含一个数字指针指向当前数组元素的位置。举个例子，如果有个Vlist包含10个元素，分别是1-10的整数，而且是按升序顺序插入的，那么vlist的结构数据时这样的：

 

VList基于数组实现，在add操作时，每次会把元素插入到list的最前面一个节点内的mElems的最后一个位置，首先判断head，如果head的元素数组已经满了，那么就增加一个头节点并扩容其elems数组为2倍，然后插入到位置指针所指向的地方去，时间是O(1)的。而在get操作时，要首先定位第n个元素的位置，会进行一次locate定位操作，接着直接返回数组中的该locate位置即可。定位操作实质是二分的，但是因为VList本身就是一个单向的二分表，因此顺序判断即可，时间复杂度是平均O(1)和最坏情况O(log n)。对应get的set操作，复杂度和步骤完全一样。当然最最恶心的还是remove操作了，因为基于数组，且本身结构有意义（特定的），所以删除会复杂一些，首先一个O(log n)的locate定位，找到元素后，删掉之后，是把它之前的所有元素后移一位，当然这个移位操作并不是特别复杂，只要把当前节点的全部后移，然后如果当前节点有前驱节点，那么前驱的最后一个元素覆盖当前节点第一个元素，如此反复直到当前节点指针为空结束，时间复杂度是O(n)的。

我做了一个perf test来测试性能，发现这个不伦不类的list在arralist和linkedlist面前显得是脆弱的。那它的作用体现在哪里呢？简单的设计和良好的结构，满足add和get的平衡，对于list后半部分的数据的操作具有很好的性能，像个数组，但是又和其前半部分有快速的链接关系，对于其数组的不可变性也是最好的用于函数式编程的典范（来源于wikipedia的翻译）

源代码如下，继承了jdk中的AbstractList<T>：

 1: public final class VList<T> extends AbstractList<T> {
   2:  
   3:     /**
   4:      * A single cell in the VList implementation.
   5:      */
   6:     private static final class VListCell<T> {
   7:         public final T[] mElems;
   8:         public final VListCell<T> mNext;
   9:  
  10:         /*
  11:          * This field is not mutable because when new elements are added/deleted
  12:          * from the main list, the previous pointer needs to be updated.
  13:          * However, next links never change because the list only grows in one
  14:          * direction.
  15:          */
  16:         public VListCell<T> mPrev;
  17:  
  18:         /*
  19:          * The number of unused elements in this cell. Alternatively, you can
  20:          * think of this as the index in the array in which the first used
  21:          * element appears. Both interpretations are used in this
  22:          * implementation.
  23:          */
  24:         public int mFreeSpace;
  25:  
  26:         /**
  27:          * Constructs a new VListCell with the specified number of elements and
  28:          * specified next element.
  29:          * 
  30:          * @param numElems
  31:          *            The number of elements this cell should have space for.
  32:          * @param next
  33:          *            The cell in the list of cells that follows this one.
  34:          */
  35:         public VListCell(int numElems, VListCell<T> next) {
  36:             mElems = (T[]) new Object[numElems];
  37:             mNext = next;
  38:             mPrev = null;
  39:  
  40:             /* Update the next cell to point back to us. */
  41:             if (next != null)
  42:                 next.mPrev = this;
  43:  
  44:             /* We have free space equal to the number of elements. */
  45:             mFreeSpace = numElems;
  46:         }
  47:     }
  48:  
  49:     /**
  50:      * A utility struct containing information about where an element is in the
  51:      * VList. Methods that need to manipulate individual elements of the list
  52:      * use this struct to communicate where in the list to look for that
  53:      * element.
  54:      */
  55:     private static final class VListLocation<T> {
  56:         public final VListCell<T> mCell;
  57:         public final int mOffset;
  58:  
  59:         public VListLocation(VListCell<T> cell, int offset) {
  60:             mCell = cell;
  61:             mOffset = offset;
  62:         }
  63:     }
  64:  
  65:     /*
  66:      * Pointer to the head of the VList, which contains the final elements of
  67:      * the list.
  68:      */
  69:     private VListCell<T> mHead;
  70:  
  71:     /* Cached total number of elements in the array. */
  72:     private int mSize;
  73:  
  74:     /**
  75:      * Adds a new element to the end of the array.
  76:      * 
  77:      * @param elem
  78:      *            The element to add.
  79:      * @return true
  80:      */
  81:     @Override
  82:     public boolean add(T elem) {
  83:         /* If no free space exists, add a new element to the list. */
  84:         if (mHead == null || mHead.mFreeSpace == 0)
  85:             mHead = new VListCell<T>(mHead == null ? 1
  86:                     : mHead.mElems.length * 2, mHead);
  87:  
  88:         /* Prepend this element to the current cell. */
  89:         mHead.mElems[(mHead.mFreeSpace--) - 1] = elem;
  90:         ++mSize;
  91:  
  92:         /* Success! */
  93:         return true;
  94:     }
  95:  
  96:     /**
  97:      * Given an absolute offset into the VList, returns an object describing
  98:      * where that object is in the VList.
  99:      * 
 100:      * @param index
 101:      *            The index into the VList.
 102:      * @return A VListLocation object holding information about where that
 103:      *         element can be found.
 104:      */
 105:     private VListLocation<T> locateElement(int index) {
 106:         /* Bounds-check. */
 107:         if (index >= size() || index < 0)
 108:             throw new IndexOutOfBoundsException("Position " + index + "; size "
 109:                     + size());
 110:  
 111:         /*
 112:          * Because the list is stored with new elements in front and old
 113:          * elements in back, we'll invert the index so that 0 refers to the
 114:          * final element of the array and size() - 1 refers to the first
 115:          * element.
 116:          */
 117:         index = size() - 1 - index;
 118:  
 119:         /*
 120:          * Scan across the cells, looking for the first one that can hold our
 121:          * entry. We do this by continuously skipping cells until we find one
 122:          * that can be sure to hold this element.
 123:          * 
 124:          * Note that each cell has mElems.length elements, of which mFreeSpace
 125:          * is used. This means that the total number of used elements in each
 126:          * cell is mElems.length - mFreeSpace.
 127:          */
 128:         VListCell<T> curr = mHead;
 129:         while (index >= curr.mElems.length - curr.mFreeSpace) {
 130:             /* Skip past all these elements. */
 131:             index -= curr.mElems.length - curr.mFreeSpace;
 132:             curr = curr.mNext;
 133:         }
 134:  
 135:         /*
 136:          * We're now in the correct location for what we need to do. The element
 137:          * we want can be found by indexing the proper amount beyond the free
 138:          * space.
 139:          */
 140:         return new VListLocation<T>(curr, index + curr.mFreeSpace);
 141:     }
 142:  
 143:     /**
 144:      * Scans for the proper location in the cell list for the element, then
 145:      * returns the element at that position.
 146:      * 
 147:      * @param index
 148:      *            The index at which to look up the element.
 149:      * @return The element at that position.
 150:      */
 151:     @Override
 152:     public T get(int index) {
 153:         VListLocation<T> where = locateElement(index);
 154:  
 155:         /* Return the element in the current position of this array. */
 156:         return where.mCell.mElems[where.mOffset];
 157:     }
 158:  
 159:     /**
 160:      * Returns the cached size.
 161:      * 
 162:      * @return The size of the VList.
 163:      */
 164:     @Override
 165:     public int size() {
 166:         return mSize;
 167:     }
 168:  
 169:     /**
 170:      * Sets an element at a particular position to have a particular value.
 171:      * 
 172:      * @param index
 173:      *            The index at which to write a new value.
 174:      * @param value
 175:      *            The value to write at that position.
 176:      * @return The value originally held at that position.
 177:      */
 178:     @Override
 179:     public T set(int index, T value) {
 180:         VListLocation<T> where = locateElement(index);
 181:  
 182:         /* Cache the element in the current position of this array. */
 183:         T result = where.mCell.mElems[where.mOffset];
 184:         where.mCell.mElems[where.mOffset] = value;
 185:         return result;
 186:     }
 187:  
 188:     /**
 189:      * Removes the element at the specified position from the VList, returning
 190:      * its value.
 191:      * 
 192:      * @param index
 193:      *            The index at which the element should be removed.
 194:      * @return The value held at that position.
 195:      */
 196:     @Override
 197:     public T remove(int index) {
 198:         VListLocation<T> where = locateElement(index);
 199:  
 200:         /* Cache the value that will be removed. */
 201:         T result = where.mCell.mElems[where.mOffset];
 202:  
 203:         /* Invoke the helper to do most of the work. */
 204:         removeAtPosition(where);
 205:  
 206:         return result;
 207:     }
 208:  
 209:     /**
 210:      * Removes the element at the indicated VListLocation.
 211:      * 
 212:      * @param where
 213:      *            The location at which the element should be removed.
 214:      */
 215:     private void removeAtPosition(VListLocation<T> where) {
 216:         /*
 217:          * Scan backward across the blocks after this element, shuffling array
 218:          * elements down a position and copying the last element of the next
 219:          * block over to fill in the top.
 220:          * 
 221:          * The variable shuffleTargetPosition indicates the first element of the
 222:          * block that should be overwritten during the shuffle-down. In the
 223:          * first block, this is the position of the element that was
 224:          * overwritten. In all other blocks, it's the last element.
 225:          */
 226:         VListCell<T> curr = where.mCell;
 227:         for (int shuffleTargetPosition = where.mOffset; curr != null; curr = curr.mPrev, shuffleTargetPosition = (curr == null ? 0
 228:                 : curr.mElems.length - 1)) {
 229:             /*
 230:              * Shuffle down each element in the current array on top of the
 231:              * target position. Note that in the final block, this may end up
 232:              * copying a whole bunch of null values down. This is more work than
 233:              * necessary, but is harmless and doesn't change the asymptotic
 234:              * runtime (since the last block has size O(n)).
 235:              */
 236:             for (int i = shuffleTargetPosition - 1; i >= 0; --i)
 237:                 curr.mElems[i + 1] = curr.mElems[i];
 238:  
 239:             /*
 240:              * Copy the last element of the next array to the top of this array,
 241:              * unless this is the first block (in which case there is no next
 242:              * array).
 243:              */
 244:             if (curr.mPrev != null)
 245:                 curr.mElems[0] = curr.mPrev.mElems[curr.mPrev.mElems.length - 1];
 246:         }
 247:  
 248:         /*
 249:          * The head just lost an element, so it has some more free space. Null
 250:          * out the lost element and increase the free space.
 251:          */
 252:         ++mHead.mFreeSpace;
 253:         mHead.mElems[mHead.mFreeSpace - 1] = null;
 254:  
 255:         /* The whole list just lost an element. */
 256:         --mSize;
 257:  
 258:         /* If the head is entirely free, remove it from the list. */
 259:         if (mHead.mFreeSpace == mHead.mElems.length) {
 260:             mHead = mHead.mNext;
 261:  
 262:             /*
 263:              * If there is at least one block left, remove the previous block
 264:              * from the linked list.
 265:              */
 266:             if (mHead != null)
 267:                 mHead.mPrev = null;
 268:         }
 269:     }
 270:  
 271:     /**
 272:      * A custom iterator class that traverses the elements of this container in
 273:      * an intelligent way. The normal iterator will call get repeatedly, which
 274:      * is slow because it has to continuously scan for the proper location of
 275:      * the next element. This iterator works by traversing the cells as a proper
 276:      * linked list.
 277:      */
 278:     private final class VListIterator implements Iterator<T> {
 279:         /*
 280:          * The cell and position in that cell that we are about to visit. We
 281:          * maintain the invariant that if there is a next element, mCurrCell is
 282:          * non-null and conversely that if mCurrCell is null, there is no next
 283:          * element.
 284:          */
 285:         private VListCell<T> mCurrCell;
 286:         private int mCurrIndex;
 287:  
 288:         /*
 289:          * Stores whether we have something to remove (i.e. whether we've called
 290:          * next() without an invervening remove()).
 291:          */
 292:         private boolean mCanRemove;
 293:  
 294:         /**
 295:          * Constructs a new VListIterator that will traverse the elements of the
 296:          * containing VList.
 297:          */
 298:         public VListIterator() {
 299:             /*
 300:              * Scan to the tail using the "pointer chase" algorithm. When this
 301:              * terminates, prev will hold a pointer to the last element of the
 302:              * list.
 303:              */
 304:             VListCell<T> curr, prev;
 305:             for (curr = mHead, prev = null; curr != null; prev = curr, curr = curr.mNext)
 306:                 ;
 307:  
 308:             /* Set the current cell to the tail. */
 309:             mCurrCell = prev;
 310:  
 311:             /*
 312:              * If the tail isn't null, it must be a full list of size 1. Set the
 313:              * current index appropriately.
 314:              */
 315:             if (mCurrCell != null)
 316:                 mCurrIndex = 0;
 317:         }
 318:  
 319:         /**
 320:          * As per our invariant, returns whether mCurrCell is non-null.
 321:          */
 322:         public boolean hasNext() {
 323:             return mCurrCell != null;
 324:         }
 325:  
 326:         /**
 327:          * Advances the iterator and returns the element it used to be over.
 328:          */
 329:         public T next() {
 330:             /* Bounds-check. */
 331:             if (!hasNext())
 332:                 throw new NoSuchElementException();
 333:  
 334:             /* Cache the return value; we'll be moving off of it soon. */
 335:             T result = mCurrCell.mElems[mCurrIndex];
 336:  
 337:             /* Back up one step. */
 338:             --mCurrIndex;
 339:  
 340:             /*
 341:              * If we walked off the end of the buffer, advance to the next
 342:              * element of the list.
 343:              */
 344:             if (mCurrIndex < mCurrCell.mFreeSpace) {
 345:                 mCurrCell = mCurrCell.mPrev;
 346:  
 347:                 /*
 348:                  * Update the next get location, provided of course that we
 349:                  * didn't just walk off the end of the list.
 350:                  */
 351:                 if (mCurrCell != null)
 352:                     mCurrIndex = mCurrCell.mElems.length - 1;
 353:             }
 354:  
 355:             /* Since there was indeed an element, we can remove it. */
 356:             mCanRemove = true;
 357:  
 358:             return result;
 359:         }
 360:  
 361:         /**
 362:          * Removes the last element we visited.
 363:          */
 364:         public void remove() {
 365:             /* Check whether there's something to remove. */
 366:             if (!mCanRemove)
 367:                 throw new IllegalStateException(
 368:                         "remove() without next(), or double remove().");
 369:  
 370:             /* Clear the flag saying we can do this. */
 371:             mCanRemove = false;
 372:  
 373:             /*
 374:              * There are several cases to consider. If the current cell is null,
 375:              * we've walked off the end of the array, so we want to remove the
 376:              * very last element. If the current cell isn't null and the cursor
 377:              * is in the middle, remove the previous element and back up a step.
 378:              * If the current cell isn't null and the cursor is at the front,
 379:              * remove the element one step before us and back up a step.
 380:              */
 381:  
 382:             /* Case 1. */
 383:             if (mCurrCell == null)
 384:                 VList.this.remove(size() - 1);
 385:             /* Case 2. */
 386:             else if (mCurrIndex != mCurrCell.mElems.length - 1) {
 387:                 /*
 388:                  * Back up a step, and remove the element at this position.
 389:                  * After the remove completes, the element here should be the
 390:                  * next element to visit.
 391:                  */
 392:                 ++mCurrIndex;
 393:                 removeAtPosition(new VListLocation<T>(mCurrCell, mCurrIndex));
 394:             }
 395:             /* Case 3. */
 396:             else {
 397:                 /*
 398:                  * Back up a step to the top of the previous list. We know that
 399:                  * the top will be at position 0, since all internal blocks are
 400:                  * completely full. We also know that we aren't at the very
 401:                  * front of the list, since if we were, then the call to next()
 402:                  * that enabled this call would have pushed us to the next
 403:                  * location.
 404:                  */
 405:                 mCurrCell = mCurrCell.mNext;
 406:                 mCurrIndex = 0;
 407:                 removeAtPosition(new VListLocation<T>(mCurrCell, mCurrIndex));
 408:             }
 409:         }
 410:     }
 411:  
 412:     /**
 413:      * Returns a custom iterator rather than the default.
 414:      */
 415:     @Override
 416:     public Iterator<T> iterator() {
 417:         return new VListIterator();
 418:     }
 419:  
 420: }

参考资料：

http://www.keithschwarz.com/interesting/code/?dir=vlist

http://en.wikipedia.org/wiki/VList