I am trying to develop an card game for Android Can anyone suggest me how to write code for effectively shuffling the playing cards?
Card shuffling is an algorithm which is easy to write intuitively, and get entirely wrong by doing so. There's a good reference for implementing card shuffling correctly on Wikipedia. What I'm presenting here is a very slightly simplified version of the algorithm covered on that page under The modern algorithm.
Here's the basic idea, in plain english:
Consider a deck of cards. For this discussion, you can have any number of cards in the deck, and they may start in any order.
We're going to be talking about "position" in the deck, where "position" is how many cards are higher in the deck than the card in that position. For example, the card on top of the deck is at position 0, the card beneath that is at position 1 (because there is 1 card higher than it -- the top card), and in a standard 52-card deck, the bottom card is at position 51, as 51 cards are higher than it in the deck.
Now, we consider each position in the deck, one at a time, starting from the bottom, and working our way up to the top.
For each position, we randomly select one of the cards which is at that position or at a lower-numbered position (remember, the top of the deck is 0, and we're working our way up from the bottom of the deck, so for each position, you're effectively picking up all the cards at and above that position and randomly picking one of those cards).
When we have made the random selection, we swap the card at the position we're currently considering with the card we randomly selected. If we randomly selected the card which was already in that position, then no swap is performed.
After swapping (or not swapping, if we randomly selected the card which was already in the position we were considering), we move on to the next position in the deck and continue.
In pseudocode, with n being the number of cards in the deck, and a being an array representing the deck, the algorithm looks like this:
You first define a sequence of all the cards you want to shuffle:
Then you walk through every position in the sequence and assign it a card randomly.
I'd like to chime in and mention "format preserving encryption" as a method for shuffling cards in a game.
Essentially what you'd have is an encryption algorithm that takes in a value 0 to 51, and a key (shuffle seed) and spits out a value 0 to 51. Since encryption is reversible by definition that means any 2 input numbers cannot encrypt to the same output number, which means if you encrypted 0 to 51, you'd get 0 to 51 as output in a different order. In other words you have your shuffle and don't even need to do any actual shuffling.
In this case you'd have to make or find an encryption algorithm that took in 6 bits and spit out 6 bits (0-63). To draw the next card from the deck you'd have an index variable which started at zero, you'd encrypt that index, increment the index and look at the value that came out of the cipher. If the value is >= 52, you ignore it and generate a new number (and increment the index again of course). Since encrypting 0-63 will result in 0-63 as output, in a different order, you are just ignoring any value that comes out >= 52 so that you have your algorithm that takes in 0-51 and spits out 0-51.
To reshuffle the deck, set the index back to zero and change the encryption key (shuffle seed).
Your algorithm doesn't need to be cryptographic quality (and it shouldn't be, cause that would be computationally expensive!). One really good way to come up with a custom sized encryption algorithm like this would be to use a feistel network, which lets you customize size and quality depending on your needs. For the round function of the feistel network, I'd recommend something like murmurhash3 because it's fast and has a good avalanche effect, which would make the shuffles appear well randomized.
Check out my blog post for even more detailed info and source code: http://blog.demofox.org/2013/07/06/fast-lightweight-random-shuffle-functionality-fixed/
The java 1.5 enum tutorial has a interesting way to implement a deck of cards, building up the deck, shuffling and dealing. All very simple using
And the class to manage the deck.