欧美在路边给了钱就可以做网站,厦门网站开发公司,苏州企业网站建设电话,免费网站备案号码前言
LinkedList底层虽然是基于链表实现#xff0c;但是由于其对底层节点进行了封装#xff0c;导致无法操作底层Node对象。这也为使用上带来了很多不便#xff0c;比如我之前遇到的一个需求#xff1a;将n个队伍按照瑞士轮进行编排#xff0c;组成n/2个队伍#xff0c;…前言
LinkedList底层虽然是基于链表实现但是由于其对底层节点进行了封装导致无法操作底层Node对象。这也为使用上带来了很多不便比如我之前遇到的一个需求将n个队伍按照瑞士轮进行编排组成n/2个队伍并且之前交过手的不能再相遇这个需求拆分一下便是将n个队伍按照顺序排序后按照顺序两两组队如果判断不能组队则跳过该队伍与下一个队伍进行匹配。以此类推直到全部匹配上为止。如果使用链表相对更简单也更容易理解。
LinkedList增强
增强的目的是为了操作内部的链表实现寻找当前节点的下一个节点。
import java.util.*;
import java.util.function.Consumer;/*** program: Reids* description:* author: Cheng Zhi* create: 2024-09-15 14:58**/
public class JefLinkedListE extends AbstractListE {transient int size 0;/*** Pointer to first node.* Invariant: (first null last null) ||* (first.prev null first.item ! null)*/transient NodeE first;/*** Pointer to last node.* Invariant: (first null last null) ||* (last.next null last.item ! null)*/transient NodeE last;/*** Constructs an empty list.*/public JefLinkedList() {}/*** Constructs a list containing the elements of the specified* collection, in the order they are returned by the collections* iterator.** param c the collection whose elements are to be placed into this list* throws NullPointerException if the specified collection is null*/public JefLinkedList(Collection? extends E c) {this();addAll(c);}/*** Links e as first element.*/private void linkFirst(E e) {final NodeE f first;final NodeE newNode new Node(null, e, f);first newNode;if (f null)last newNode;elsef.prev newNode;size;modCount;}/*** Links e as last element.*/void linkLast(E e) {final NodeE l last;final NodeE newNode new Node(l, e, null);last newNode;if (l null)first newNode;elsel.next newNode;size;modCount;}/*** Inserts element e before non-null Node succ.*/void linkBefore(E e, NodeE succ) {// assert succ ! null;final NodeE pred succ.prev;final NodeE newNode new Node(pred, e, succ);succ.prev newNode;if (pred null)first newNode;elsepred.next newNode;size;modCount;}/*** Unlinks non-null first node f.*/private E unlinkFirst(NodeE f) {// assert f first f ! null;final E element f.item;final NodeE next f.next;f.item null;f.next null; // help GCfirst next;if (next null)last null;elsenext.prev null;size--;modCount;return element;}/*** 移除指定节点* param node*/public void removeNode(NodeE node) {// 获取前置节点NodeE prev node.prev;NodeE next node.next;if (prev ! null) {prev.next next;} else {// 如果前置节点为空说明是头节点removeFirst();return;}if (next ! null) {size--;next.prev prev;} else {removeLast();return;}}/*** 获取头节点* return*/public NodeE getFirstNode() {return first;}/*** Unlinks non-null last node l.*/private E unlinkLast(NodeE l) {// assert l last l ! null;final E element l.item;final NodeE prev l.prev;l.item null;l.prev null; // help GClast prev;if (prev null)first null;elseprev.next null;size--;modCount;return element;}/*** Unlinks non-null node x.*/E unlink(NodeE x) {// assert x ! null;final E element x.item;final NodeE next x.next;final NodeE prev x.prev;if (prev null) {first next;} else {prev.next next;x.prev null;}if (next null) {last prev;} else {next.prev prev;x.next null;}x.item null;size--;modCount;return element;}/*** Returns the first element in this list.** return the first element in this list* throws NoSuchElementException if this list is empty*/public E getFirst() {final NodeE f first;if (f null)throw new NoSuchElementException();return f.item;}/*** Returns the last element in this list.** return the last element in this list* throws NoSuchElementException if this list is empty*/public E getLast() {final NodeE l last;if (l null)throw new NoSuchElementException();return l.item;}/*** Removes and returns the first element from this list.** return the first element from this list* throws NoSuchElementException if this list is empty*/public E removeFirst() {final NodeE f first;if (f null)throw new NoSuchElementException();return unlinkFirst(f);}/*** Removes and returns the last element from this list.** return the last element from this list* throws NoSuchElementException if this list is empty*/public E removeLast() {final NodeE l last;if (l null)throw new NoSuchElementException();return unlinkLast(l);}/*** Inserts the specified element at the beginning of this list.** param e the element to add*/public void addFirst(E e) {linkFirst(e);}/*** Appends the specified element to the end of this list.** pThis method is equivalent to {link #add}.** param e the element to add*/public void addLast(E e) {linkLast(e);}/*** Returns {code true} if this list contains the specified element.* More formally, returns {code true} if and only if this list contains* at least one element {code e} such that* tt(onullnbsp;?nbsp;enullnbsp;:nbsp;o.equals(e))/tt.** param o element whose presence in this list is to be tested* return {code true} if this list contains the specified element*/public boolean contains(Object o) {return indexOf(o) ! -1;}/*** Returns the number of elements in this list.** return the number of elements in this list*/public int size() {return size;}/*** Appends the specified element to the end of this list.** pThis method is equivalent to {link #addLast}.** param e element to be appended to this list* return {code true} (as specified by {link Collection#add})*/public boolean add(E e) {linkLast(e);return true;}/*** Removes the first occurrence of the specified element from this list,* if it is present. If this list does not contain the element, it is* unchanged. More formally, removes the element with the lowest index* {code i} such that* tt(onullnbsp;?nbsp;get(i)nullnbsp;:nbsp;o.equals(get(i)))/tt* (if such an element exists). Returns {code true} if this list* contained the specified element (or equivalently, if this list* changed as a result of the call).** param o element to be removed from this list, if present* return {code true} if this list contained the specified element*/public boolean remove(Object o) {if (o null) {for (NodeE x first; x ! null; x x.next) {if (x.item null) {unlink(x);return true;}}} else {for (NodeE x first; x ! null; x x.next) {if (o.equals(x.item)) {unlink(x);return true;}}}return false;}/*** Appends all of the elements in the specified collection to the end of* this list, in the order that they are returned by the specified* collections iterator. The behavior of this operation is undefined if* the specified collection is modified while the operation is in* progress. (Note that this will occur if the specified collection is* this list, and its nonempty.)** param c collection containing elements to be added to this list* return {code true} if this list changed as a result of the call* throws NullPointerException if the specified collection is null*/public boolean addAll(Collection? extends E c) {return addAll(size, c);}/*** Inserts all of the elements in the specified collection into this* list, starting at the specified position. Shifts the element* currently at that position (if any) and any subsequent elements to* the right (increases their indices). The new elements will appear* in the list in the order that they are returned by the* specified collections iterator.** param index index at which to insert the first element* from the specified collection* param c collection containing elements to be added to this list* return {code true} if this list changed as a result of the call* throws IndexOutOfBoundsException {inheritDoc}* throws NullPointerException if the specified collection is null*/public boolean addAll(int index, Collection? extends E c) {checkPositionIndex(index);Object[] a c.toArray();int numNew a.length;if (numNew 0)return false;NodeE pred, succ;if (index size) {succ null;pred last;} else {succ node(index);pred succ.prev;}for (Object o : a) {SuppressWarnings(unchecked) E e (E) o;NodeE newNode new Node(pred, e, null);if (pred null)first newNode;elsepred.next newNode;pred newNode;}if (succ null) {last pred;} else {pred.next succ;succ.prev pred;}size numNew;modCount;return true;}/*** Removes all of the elements from this list.* The list will be empty after this call returns.*/public void clear() {// Clearing all of the links between nodes is unnecessary, but:// - helps a generational GC if the discarded nodes inhabit// more than one generation// - is sure to free memory even if there is a reachable Iteratorfor (NodeE x first; x ! null; ) {NodeE next x.next;x.item null;x.next null;x.prev null;x next;}first last null;size 0;modCount;}// Positional Access Operations/*** Returns the element at the specified position in this list.** param index index of the element to return* return the element at the specified position in this list* throws IndexOutOfBoundsException {inheritDoc}*/public E get(int index) {checkElementIndex(index);return node(index).item;}/*** Replaces the element at the specified position in this list with the* specified element.** param index index of the element to replace* param element element to be stored at the specified position* return the element previously at the specified position* throws IndexOutOfBoundsException {inheritDoc}*/public E set(int index, E element) {checkElementIndex(index);NodeE x node(index);E oldVal x.item;x.item element;return oldVal;}/*** Inserts the specified element at the specified position in this list.* Shifts the element currently at that position (if any) and any* subsequent elements to the right (adds one to their indices).** param index index at which the specified element is to be inserted* param element element to be inserted* throws IndexOutOfBoundsException {inheritDoc}*/public void add(int index, E element) {checkPositionIndex(index);if (index size)linkLast(element);elselinkBefore(element, node(index));}/*** Removes the element at the specified position in this list. Shifts any* subsequent elements to the left (subtracts one from their indices).* Returns the element that was removed from the list.** param index the index of the element to be removed* return the element previously at the specified position* throws IndexOutOfBoundsException {inheritDoc}*/public E remove(int index) {checkElementIndex(index);return unlink(node(index));}/*** Tells if the argument is the index of an existing element.*/private boolean isElementIndex(int index) {return index 0 index size;}/*** Tells if the argument is the index of a valid position for an* iterator or an add operation.*/private boolean isPositionIndex(int index) {return index 0 index size;}/*** Constructs an IndexOutOfBoundsException detail message.* Of the many possible refactorings of the error handling code,* this outlining performs best with both server and client VMs.*/private String outOfBoundsMsg(int index) {return Index: index, Size: size;}private void checkElementIndex(int index) {if (!isElementIndex(index))throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}private void checkPositionIndex(int index) {if (!isPositionIndex(index))throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}/*** Returns the (non-null) Node at the specified element index.*/NodeE node(int index) {// assert isElementIndex(index);if (index (size 1)) {NodeE x first;for (int i 0; i index; i)x x.next;return x;} else {NodeE x last;for (int i size - 1; i index; i--)x x.prev;return x;}}// Search Operations/*** Returns the index of the first occurrence of the specified element* in this list, or -1 if this list does not contain the element.* More formally, returns the lowest index {code i} such that* tt(onullnbsp;?nbsp;get(i)nullnbsp;:nbsp;o.equals(get(i)))/tt,* or -1 if there is no such index.** param o element to search for* return the index of the first occurrence of the specified element in* this list, or -1 if this list does not contain the element*/public int indexOf(Object o) {int index 0;if (o null) {for (NodeE x first; x ! null; x x.next) {if (x.item null)return index;index;}} else {for (NodeE x first; x ! null; x x.next) {if (o.equals(x.item))return index;index;}}return -1;}/*** Returns the index of the last occurrence of the specified element* in this list, or -1 if this list does not contain the element.* More formally, returns the highest index {code i} such that* tt(onullnbsp;?nbsp;get(i)nullnbsp;:nbsp;o.equals(get(i)))/tt,* or -1 if there is no such index.** param o element to search for* return the index of the last occurrence of the specified element in* this list, or -1 if this list does not contain the element*/public int lastIndexOf(Object o) {int index size;if (o null) {for (NodeE x last; x ! null; x x.prev) {index--;if (x.item null)return index;}} else {for (NodeE x last; x ! null; x x.prev) {index--;if (o.equals(x.item))return index;}}return -1;}// Queue operations./*** Retrieves, but does not remove, the head (first element) of this list.** return the head of this list, or {code null} if this list is empty* since 1.5*/public E peek() {final NodeE f first;return (f null) ? null : f.item;}/*** Retrieves, but does not remove, the head (first element) of this list.** return the head of this list* throws NoSuchElementException if this list is empty* since 1.5*/public E element() {return getFirst();}/*** Retrieves and removes the head (first element) of this list.** return the head of this list, or {code null} if this list is empty* since 1.5*/public E poll() {final NodeE f first;return (f null) ? null : unlinkFirst(f);}/*** Retrieves and removes the head (first element) of this list.** return the head of this list* throws NoSuchElementException if this list is empty* since 1.5*/public E remove() {return removeFirst();}/*** Adds the specified element as the tail (last element) of this list.** param e the element to add* return {code true} (as specified by {link Queue#offer})* since 1.5*/public boolean offer(E e) {return add(e);}// Deque operations/*** Inserts the specified element at the front of this list.** param e the element to insert* return {code true} (as specified by {link Deque#offerFirst})* since 1.6*/public boolean offerFirst(E e) {addFirst(e);return true;}/*** Inserts the specified element at the end of this list.** param e the element to insert* return {code true} (as specified by {link Deque#offerLast})* since 1.6*/public boolean offerLast(E e) {addLast(e);return true;}/*** Retrieves, but does not remove, the first element of this list,* or returns {code null} if this list is empty.** return the first element of this list, or {code null}* if this list is empty* since 1.6*/public E peekFirst() {final NodeE f first;return (f null) ? null : f.item;}/*** Retrieves, but does not remove, the last element of this list,* or returns {code null} if this list is empty.** return the last element of this list, or {code null}* if this list is empty* since 1.6*/public E peekLast() {final NodeE l last;return (l null) ? null : l.item;}/*** Retrieves and removes the first element of this list,* or returns {code null} if this list is empty.** return the first element of this list, or {code null} if* this list is empty* since 1.6*/public E pollFirst() {final NodeE f first;return (f null) ? null : unlinkFirst(f);}/*** Retrieves and removes the last element of this list,* or returns {code null} if this list is empty.** return the last element of this list, or {code null} if* this list is empty* since 1.6*/public E pollLast() {final NodeE l last;return (l null) ? null : unlinkLast(l);}/*** Pushes an element onto the stack represented by this list. In other* words, inserts the element at the front of this list.** pThis method is equivalent to {link #addFirst}.** param e the element to push* since 1.6*/public void push(E e) {addFirst(e);}/*** Pops an element from the stack represented by this list. In other* words, removes and returns the first element of this list.** pThis method is equivalent to {link #removeFirst()}.** return the element at the front of this list (which is the top* of the stack represented by this list)* throws NoSuchElementException if this list is empty* since 1.6*/public E pop() {return removeFirst();}/*** Removes the first occurrence of the specified element in this* list (when traversing the list from head to tail). If the list* does not contain the element, it is unchanged.** param o element to be removed from this list, if present* return {code true} if the list contained the specified element* since 1.6*/public boolean removeFirstOccurrence(Object o) {return remove(o);}/*** Removes the last occurrence of the specified element in this* list (when traversing the list from head to tail). If the list* does not contain the element, it is unchanged.** param o element to be removed from this list, if present* return {code true} if the list contained the specified element* since 1.6*/public boolean removeLastOccurrence(Object o) {if (o null) {for (NodeE x last; x ! null; x x.prev) {if (x.item null) {unlink(x);return true;}}} else {for (NodeE x last; x ! null; x x.prev) {if (o.equals(x.item)) {unlink(x);return true;}}}return false;}/*** Returns a list-iterator of the elements in this list (in proper* sequence), starting at the specified position in the list.* Obeys the general contract of {code List.listIterator(int)}.p** The list-iterator is ifail-fast/i: if the list is structurally* modified at any time after the Iterator is created, in any way except* through the list-iterators own {code remove} or {code add}* methods, the list-iterator will throw a* {code ConcurrentModificationException}. Thus, in the face of* concurrent modification, the iterator fails quickly and cleanly, rather* than risking arbitrary, non-deterministic behavior at an undetermined* time in the future.** param index index of the first element to be returned from the* list-iterator (by a call to {code next})* return a ListIterator of the elements in this list (in proper* sequence), starting at the specified position in the list* throws IndexOutOfBoundsException {inheritDoc}* see List#listIterator(int)*/public ListIteratorE listIterator(int index) {checkPositionIndex(index);return new ListItr(index);}private class ListItr implements ListIteratorE {private NodeE lastReturned;private NodeE next;private int nextIndex;private int expectedModCount modCount;ListItr(int index) {// assert isPositionIndex(index);next (index size) ? null : node(index);nextIndex index;}public boolean hasNext() {return nextIndex size;}public E next() {checkForComodification();if (!hasNext())throw new NoSuchElementException();lastReturned next;next next.next;nextIndex;return lastReturned.item;}public boolean hasPrevious() {return nextIndex 0;}public E previous() {checkForComodification();if (!hasPrevious())throw new NoSuchElementException();lastReturned next (next null) ? last : next.prev;nextIndex--;return lastReturned.item;}public int nextIndex() {return nextIndex;}public int previousIndex() {return nextIndex - 1;}public void remove() {checkForComodification();if (lastReturned null)throw new IllegalStateException();NodeE lastNext lastReturned.next;unlink(lastReturned);if (next lastReturned)next lastNext;elsenextIndex--;lastReturned null;expectedModCount;}public void set(E e) {if (lastReturned null)throw new IllegalStateException();checkForComodification();lastReturned.item e;}public void add(E e) {checkForComodification();lastReturned null;if (next null)linkLast(e);elselinkBefore(e, next);nextIndex;expectedModCount;}public void forEachRemaining(Consumer? super E action) {Objects.requireNonNull(action);while (modCount expectedModCount nextIndex size) {action.accept(next.item);lastReturned next;next next.next;nextIndex;}checkForComodification();}final void checkForComodification() {if (modCount ! expectedModCount)throw new ConcurrentModificationException();}}public static class NodeE {E item;NodeE next;NodeE prev;Node(NodeE prev, E element, NodeE next) {this.item element;this.next next;this.prev prev;}}/*** since 1.6*/public IteratorE descendingIterator() {return new DescendingIterator();}/*** Adapter to provide descending iterators via ListItr.previous*/private class DescendingIterator implements IteratorE {private final ListItr itr new ListItr(size());public boolean hasNext() {return itr.hasPrevious();}public E next() {return itr.previous();}public void remove() {itr.remove();}}SuppressWarnings(unchecked)private JefLinkedListE superClone() {try {return (JefLinkedListE) super.clone();} catch (CloneNotSupportedException e) {throw new InternalError(e);}}/*** Returns a shallow copy of this {code LinkedList}. (The elements* themselves are not cloned.)** return a shallow copy of this {code LinkedList} instance*/public Object clone() {JefLinkedListE clone superClone();// Put clone into virgin stateclone.first clone.last null;clone.size 0;clone.modCount 0;// Initialize clone with our elementsfor (NodeE x first; x ! null; x x.next)clone.add(x.item);return clone;}/*** Returns an array containing all of the elements in this list* in proper sequence (from first to last element).** pThe returned array will be safe in that no references to it are* maintained by this list. (In other words, this method must allocate* a new array). The caller is thus free to modify the returned array.** pThis method acts as bridge between array-based and collection-based* APIs.** return an array containing all of the elements in this list* in proper sequence*/public Object[] toArray() {Object[] result new Object[size];int i 0;for (NodeE x first; x ! null; x x.next)result[i] x.item;return result;}/*** Returns an array containing all of the elements in this list in* proper sequence (from first to last element); the runtime type of* the returned array is that of the specified array. If the list fits* in the specified array, it is returned therein. Otherwise, a new* array is allocated with the runtime type of the specified array and* the size of this list.** pIf the list fits in the specified array with room to spare (i.e.,* the array has more elements than the list), the element in the array* immediately following the end of the list is set to {code null}.* (This is useful in determining the length of the list ionly/i if* the caller knows that the list does not contain any null elements.)** pLike the {link #toArray()} method, this method acts as bridge between* array-based and collection-based APIs. Further, this method allows* precise control over the runtime type of the output array, and may,* under certain circumstances, be used to save allocation costs.** pSuppose {code x} is a list known to contain only strings.* The following code can be used to dump the list into a newly* allocated array of {code String}:** pre* String[] y x.toArray(new String[0]);/pre** Note that {code toArray(new Object[0])} is identical in function to* {code toArray()}.** param a the array into which the elements of the list are to* be stored, if it is big enough; otherwise, a new array of the* same runtime type is allocated for this purpose.* return an array containing the elements of the list* throws ArrayStoreException if the runtime type of the specified array* is not a supertype of the runtime type of every element in* this list* throws NullPointerException if the specified array is null*/SuppressWarnings(unchecked)public T T[] toArray(T[] a) {if (a.length size)a (T[])java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size);int i 0;Object[] result a;for (NodeE x first; x ! null; x x.next)result[i] x.item;if (a.length size)a[size] null;return a;}private static final long serialVersionUID 876323262645176354L;/*** Saves the state of this {code LinkedList} instance to a stream* (that is, serializes it).** serialData The size of the list (the number of elements it* contains) is emitted (int), followed by all of its* elements (each an Object) in the proper order.*/private void writeObject(java.io.ObjectOutputStream s)throws java.io.IOException {// Write out any hidden serialization magics.defaultWriteObject();// Write out sizes.writeInt(size);// Write out all elements in the proper order.for (NodeE x first; x ! null; x x.next)s.writeObject(x.item);}/*** Reconstitutes this {code LinkedList} instance from a stream* (that is, deserializes it).*/SuppressWarnings(unchecked)private void readObject(java.io.ObjectInputStream s)throws java.io.IOException, ClassNotFoundException {// Read in any hidden serialization magics.defaultReadObject();// Read in sizeint size s.readInt();// Read in all elements in the proper order.for (int i 0; i size; i)linkLast((E)s.readObject());}/*** Creates a ema hrefSpliterator.html#bindinglate-binding/a/em* and emfail-fast/em {link Spliterator} over the elements in this* list.** pThe {code Spliterator} reports {link Spliterator#SIZED} and* {link Spliterator#ORDERED}. Overriding implementations should document* the reporting of additional characteristic values.** implNote* The {code Spliterator} additionally reports {link Spliterator#SUBSIZED}* and implements {code trySplit} to permit limited parallelism..** return a {code Spliterator} over the elements in this list* since 1.8*/Overridepublic SpliteratorE spliterator() {return new LLSpliteratorE(this, -1, 0);}/** A customized variant of Spliterators.IteratorSpliterator */static final class LLSpliteratorE implements SpliteratorE {static final int BATCH_UNIT 1 10; // batch array size incrementstatic final int MAX_BATCH 1 25; // max batch array size;final JefLinkedListE list; // null OK unless traversedNodeE current; // current node; null until initializedint est; // size estimate; -1 until first neededint expectedModCount; // initialized when est setint batch; // batch size for splitsLLSpliterator(JefLinkedListE list, int est, int expectedModCount) {this.list list;this.est est;this.expectedModCount expectedModCount;}final int getEst() {int s; // force initializationfinal JefLinkedListE lst;if ((s est) 0) {if ((lst list) null)s est 0;else {expectedModCount lst.modCount;current lst.first;s est lst.size;}}return s;}public long estimateSize() { return (long) getEst(); }public SpliteratorE trySplit() {NodeE p;int s getEst();if (s 1 (p current) ! null) {int n batch BATCH_UNIT;if (n s)n s;if (n MAX_BATCH)n MAX_BATCH;Object[] a new Object[n];int j 0;do { a[j] p.item; } while ((p p.next) ! null j n);current p;batch j;est s - j;return Spliterators.spliterator(a, 0, j, Spliterator.ORDERED);}return null;}public void forEachRemaining(Consumer? super E action) {NodeE p; int n;if (action null) throw new NullPointerException();if ((n getEst()) 0 (p current) ! null) {current null;est 0;do {E e p.item;p p.next;action.accept(e);} while (p ! null --n 0);}if (list.modCount ! expectedModCount)throw new ConcurrentModificationException();}public boolean tryAdvance(Consumer? super E action) {NodeE p;if (action null) throw new NullPointerException();if (getEst() 0 (p current) ! null) {--est;E e p.item;current p.next;action.accept(e);if (list.modCount ! expectedModCount)throw new ConcurrentModificationException();return true;}return false;}public int characteristics() {return Spliterator.ORDERED | Spliterator.SIZED | Spliterator.SUBSIZED;}}}
编排测试
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;/*** program: Reids* description: 瑞士制编排* author: Cheng Zhi* create: 2024-09-15 14:30**/
public class SwissOrch {private JefLinkedListInteger linkedList new JefLinkedListInteger();private ListInteger usedPair new ArrayList();private ListInteger result new ArrayList();public SwissOrch(ListInteger list) {linkedList.addAll(list);}public void addPlayed(List list) {usedPair.addAll(list);}public ListInteger getResult() {return this.result;}public void pairing() {int noChangeCount 0; // 连续长度不变的计数器while(linkedList.size() 0) {// 记录当前链表长度int previousSize linkedList.size();boolean succFlag false;// 取出第一个JefLinkedList.NodeInteger node linkedList.getFirstNode();Integer playerA node.item;Integer pair null;JefLinkedList.NodeInteger next node;while(!succFlag) {next next.next;if (next null) {// 说明遍历到了最后一个break;}Integer playerB next.item;// 这里模拟匹配到对手的对局信息pair Integer.valueOf(playerA playerB);if (isCanPair(pair)) {// 匹配成功则删除该节点linkedList.removeNode(next);succFlag true;break;}}if (succFlag pair ! null) {linkedList.removeNode(node);result.add(pair);}// 更新计数器if (linkedList.size() previousSize) {noChangeCount;} else {noChangeCount 0; // 重置计数器}// 如果连续多次次大小不变退出循环if (noChangeCount linkedList.size()) {System.out.println(连续多次没有匹配到合适的选手说明最后两名之前已经交过手为了保证比赛的公平性这两人只能再次对局。);JefLinkedList.NodeInteger next1 node.next;if (next1 ! null) {pair Integer.valueOf(playerA next1.item);linkedList.removeNode(next1);result.add(pair);} else {System.out.println(轮空了 playerA);}break;}}}/*** 判断是否可以组队* param pair* return*/public boolean isCanPair(Integer pair) {if (usedPair.contains(pair)) {return false;}return true;}public static void main(String[] args) {LinkedListInteger linkedList new LinkedListInteger();linkedList.add(1);linkedList.add(2);linkedList.add(3);linkedList.add(4);linkedList.add(5);linkedList.add(6);linkedList.add(7);linkedList.add(8);linkedList.add(9);linkedList.add(10);linkedList.add(11);// 模拟前几局的交手情况本轮编排时已经交过手的不能再次交手LinkedListInteger played new LinkedList();played.add(34); // 第三队和第四队played.add(56); // 第五队和第六队played.add(910); // 第九队和第十队SwissOrch linked new SwissOrch(linkedList);linked.addPlayed(played);linked.pairing();System.out.println(linked.getResult());}
}
