Question

我有一张扑克牌的arraylist。

private ArrayList<VisibleCard> m_vecCards;

在通过以下方式访问其成员时，它有一个私人范围

public VisibleCard getCard(int n) {
    return this.m_vecCards.get(n);
}

我发现元素是通过冒泡排序算法未分类的：

public void sortCards() {
    int swapCounter, nIndex;
    int upperBound = this.m_vecCards.size() - 1;
    while(true) {
        swapCounter = 0;
        for ( nIndex = 0; nIndex < upperBound; nIndex++ ) {
            if ( this.m_vecCards.get(nIndex).getNumericVal() > this.m_vecCards.get(nIndex + 1).getNumericVal() ) {
                Collections.swap(this.m_vecCards, nIndex, nIndex + 1);
                swapCounter++;
            }
        }
        if ( swapCounter == 0 ) {
            for ( nIndex = 0; nIndex < 7; nIndex++ ) {
                Log.d("order", ""+ this.m_vecCards.get(nIndex).getNumericVal());
            }
            return;
        }
    }
}

我有一个日志函数，我可以使用它来测试数字，以确保我的数组正在排序，并且数组正在排序，但结果不是永久性的。

12-18 06:51:08.077: D/order(3636): 2
12-18 06:51:08.077: D/order(3636): 4
12-18 06:51:08.077: D/order(3636): 5
12-18 06:51:08.077: D/order(3636): 8
12-18 06:51:08.077: D/order(3636): 8
12-18 06:51:08.077: D/order(3636): 9
12-18 06:51:08.077: D/order(3636): 9
12-18 06:51:08.087: D/order(3636): 1
12-18 06:51:08.087: D/order(3636): 5
12-18 06:51:08.087: D/order(3636): 6
12-18 06:51:08.087: D/order(3636): 8
12-18 06:51:08.087: D/order(3636): 12
12-18 06:51:08.087: D/order(3636): 12
12-18 06:51:08.087: D/order(3636): 13
12-18 06:51:08.087: D/order(3636): 1
12-18 06:51:08.087: D/order(3636): 1
12-18 06:51:08.087: D/order(3636): 2
12-18 06:51:08.087: D/order(3636): 3
12-18 06:51:08.087: D/order(3636): 3
12-18 06:51:08.087: D/order(3636): 10
12-18 06:51:08.087: D/order(3636): 10
12-18 06:51:08.087: D/order(3636): 4
12-18 06:51:08.097: D/order(3636): 6
12-18 06:51:08.097: D/order(3636): 6
12-18 06:51:08.097: D/order(3636): 9
12-18 06:51:08.097: D/order(3636): 10
12-18 06:51:08.097: D/order(3636): 11
12-18 06:51:08.097: D/order(3636): 13

基本上，ArrayList中的元素不会像我想的那样“永久”交换。我无法理解这种现象，因为我发现代码或日志调试没有任何问题。

public void addCard(VisibleCard vc) {
    if ( this.m_humanAgent ) {
        vc.setPosition(-20, (this.m_vecCards.size() * 85) + 100);
        vc.rotate(1.57079633);
        vc.setup();
    }
    this.m_vecCards.add(vc);
    if ( this.m_vecCards.size() == 7 ) {
        this.sortCards();
    }
}

我为每个玩家添加了总共七张牌，在阵列中存在七个元素之后，我调用了sortCards（）方法，但是在输出牌之后，它们没有按照他们应该的顺序出现。

我像这样渲染输出：

    for ( int n = 0; n < 7; n++ ) {
        this.m_flushRummy.getPlayer(0).getCard(n).draw(gl, m_bmTextureIds[0]);
    }

Answer 1

当然，它没有以正确的顺序出现在图形上！这是根本原因：

vc.setPosition(-20, (this.m_vecCards.size() * 85) + 100);

您可以在对卡片进行排序之前设置它们的图形位置:)然后以正确的顺序绘制它们，但不是在正确的位置。

Answer 2

这不能直接回答您的问题，但您是否需要自己实施排序算法？如果没有，您可以/应该使用Collections.sort(List)或Collections.sort(List, Comparator)方法。

此外，正如汤姆评论的那样，这将比使用冒泡排序快得多。

Answer 3

public void sortCards() {
int swapCounter, nIndex;
int upperBound = this.m_vecCards.size() - 1;
while(swapCounter > 0) {
    swapCounter = 0;
    for ( nIndex = 0; nIndex < upperBound; nIndex++ ) {
        if ( this.m_vecCards.get(nIndex).getNumericVal() > this.m_vecCards.get(nIndex + 1).getNumericVal() ) {
            Collections.swap(this.m_vecCards, nIndex, nIndex + 1);
            swapCounter++;
        }
    }
    upperBound--;
 }    
    if ( swapCounter == 0 ) {
        for ( nIndex = 0; nIndex < 7; nIndex++ ) {
            Log.d("order", ""+ this.m_vecCards.get(nIndex).getNumericVal());
        }
        return;
    }
}
}

ArrayList元素交换不是永久性的

3 个答案: