# 11.15 Shuffling Fairly

#### 11.15.1 Problem

You have an ordered list of items that you would like to shuffle randomly, then visit one at a time. You would like to do so securely and without biasing any element.

#### 11.15.2 Solution

For each index, swap the item at that index with the item at a random index that has not been fully processed, including the current index.

#### 11.15.3 Discussion

Performing a statistically fair shuffle is actually not easy to do right. Many developers who implement a shuffle that seems right to them off the top of their heads get it wrong.

We present code to shuffle an array of integers here. We perform a statistically fair shuffle, using the spc_rand_range( ) function from Recipe 11.11.

```#include <stdlib.h>

void spc_shuffle(int *items, size_t numitems) {
int    tmp;
size_t swapwith;

while (--numitems) {
/* Remember, it must be possible for a value to swap with itself */
swapwith = spc_rand_range(0, numitems);
tmp = items[swapwith];
items[swapwith] = items[numitems];
items[numitems] = tmp;
}
}```

If you need to shuffle an array of objects, you can use this function to first permute an array of integers, then use that permutation to reorder the elements in your array. That is, if you have three database records, and you shuffle the list [1, 2, 3], getting [3, 1, 2], you would build a new array consisting of the records in the listed order.

Recipe 11.11

 Foreword
 Preface
 Chapter 1. Safe Initialization
 Chapter 2. Access Control
 Chapter 3. Input Validation
 Chapter 4. Symmetric Cryptography Fundamentals
 Chapter 5. Symmetric Encryption
 Chapter 6. Hashes and Message Authentication
 Chapter 7. Public Key Cryptography
 Chapter 8. Authentication and Key Exchange
 Chapter 9. Networking
 Chapter 10. Public Key Infrastructure
 Chapter 12. Anti-Tampering
 Chapter 13. Other Topics
 Colophon