1 void shuffle(int *dest,int N)
 2 {
 3     int pos,card;
 4     for (card=1;card<=N;card++)
 5     {
 6         do
 7         {
 8             pos=rand()%(N-1);
 9         } while (dest[pos]!=0);
10
11         dest[pos]=card;
12     }
13 }
14
15 void main()
16 {
17     int dest[54]={0};
18     shuffle(dest,54);
19     for (int i=0;i<54;i++)
20     {
21         cout<<dest[i]<<" ";
22     }
23 }

 1 void shuffle ( int a[], int n )
 2 {
 3     int tmp = 0, p1, p2;
 4     int cnt = rand() % 1023;
 5     while (cnt--)
 6     {
 7         p1 = rand() % n;
 8         p2 = rand() % n;
 9         tmp = a[p1];
10         a[p1] = a[p2];
11         a[p2] = tmp;
12     }
13 }

 1 void vectorShuffle(vector<int> &unshuffle,vector<int> &shuffled)
 2 {
 3     unsigned int temp,len=unshuffle.size();
 4     while(len)
 5     {
 6         temp=rand()%(len--);
 7         shuffled.push_back(unshuffle[temp]);
 8         unshuffle.erase(unshuffle.begin()+temp);
 9     }
10 }
11
12
13 void main()
14 {
15     vector<int> uncard,carded;
16     for (int i=0;i<54;i++)
17     {
18         uncard.push_back(i+1);
19     }
20     vectorShuffle(uncard,carded);
21     for (int j=0;j<54;j++)
22     {
23         cout<<carded[j]<<" ";
24     }
25 }

1. // 扑克牌发牌游戏 -- 第一次上机作业
2. /* 整个程序由三部分组成
3. 1.扑克牌初始化
4. 2.洗牌
5. 3.发牌
6. 4.玩家各自将手牌排序（按黑红紫坊从小到大的排序，2点最大）
7. */
8. #include <stdio.h>
9. #include <stdlib.h>
10. #include <time.h>
11. #include <iostream>
12. typedef struct card{
13. // 每张牌（Card）都用一个 strcut card 结构体类型来表示
14. char *face;  // 指针 face 指向不同纸牌的点数
15. char *suit;  // 指针 suit 指向不同纸牌的花色
16. } CARD;
17. CARD deck[52], player[4][13];
18. char *face[] = {"3", "4", "5", "6", "8", "8", "9", "10", "J", "Q", "K","A", "2"};
19. char *suit[] = {"/004", "/005", "/003", "/006"};
20. // 比较时用的牌值
21. void InitDeck (CARD * , char *[] , char *[]);
22. void Shuffle (CARD *);
23. void Deal (CARD * , CARD (*)[13]);
24. void Sort (CARD (*)[13]);
25. int  Value (char *);
26. void Disply(void );
27. int Locat(CARD *, int , CARD , int (*)(CARD, CARD));
28. int Equl(CARD, CARD);
29. void Testcard(CARD *, CARD (*)[13]);
30. int main(){
31. srand(time(NULL));
32. InitDeck (deck, face, suit);  // 填新牌
33. Shuffle (deck);  // 洗牌
34. Deal (deck, player); // 发牌
35. Sort (player);  // 对玩家的手牌进行排序
36. Disply();
37. Testcard(deck, player);
38. return 0;
39. }
40. void InitDeck (CARD *pDeck, char *pface[], char *psuit[]){
41. /* wDeck 结构体指针，指向待初始化桌牌 deck[52]
42. wface 字符数组指针，指向点数
43. wsuit 字符数组指针，指向花色
44. 该函数用于初始化桌牌 deck[52]
45. */
46. int i;
47. for (i = 0; i <= 51; i++){
48. pDeck[i].face = pface[i%13];  // 点数初始化
49. pDeck[i].suit = psuit[i/13];  // 花色初始化
50. }
51. }
52. void Shuffle (CARD *pDeck){
53. // 用产生的随机数 j 依次与前面的牌交换
54. int i, j;
55. CARD temp;
56. for (i = 0; i <= 51; i++){
57. // 洗牌
58. j = rand()%52;  // 产生0到51之间的随机数
59. temp = pDeck[i];  // 交换纸牌
60. pDeck[i] = pDeck[j];
61. pDeck[j] = temp;
62. }
63. }
64. void Deal (CARD *pDeck , CARD (*pplayer)[13]) {
65. int i, j;  // i为玩家编号，j为手牌编号
66. for (i = 0;i < 4; i++){
67. // 遍历四个玩家
68. for (j = 0;j < 13; j++){
69. // 洗牌第i个玩家的第j张牌是手牌中的第4*j+i张（轮流发牌）
70. pplayer[i][j] = pDeck[4*j+i];
71. }
72. }
73. }
74. void Sort (CARD (*pplayer)[13]){
75. // 运用插入排序法分别对四个玩家的手牌排序
76. int i, j, p, q;  // i为玩家编号，j为手牌编号，p, q 为工作指针
77. CARD temp;
78. for (i = 0;i < 4; i++){
79. // 外层循环，对四个玩家遍历
80. for (j = 1;j < 13; j++){
81. // 内层循环，开始排序
82. // 先比较face 再比较suit
83. temp = pplayer[i][j];  // 待插入的牌
84. for (p = j-1; p >= 0; p--){
85. // 从后往前找出第一个小于temp的牌的序号
86. if (Value(pplayer[i][p].face) < Value(temp.face))  // 找到比temp小的牌
87. break;
88. else if (Value(pplayer[i][p].face) == Value(temp.face)  // 若face 相同 则比较suit
89. ? Value(pplayer[i][p].suit) < Value(temp.suit) ? 1 : 0 : 0) break;
90. }
91. for (q = j-1; q > p; q--){  // 插入操作
92. pplayer[i][q+1] = pplayer[i][q];
93. }
94. pplayer[i][q+1] = temp;
95. }
96. }
97. }
98. int Value(char *str){
99. // 字符映射函数
100. int i = 0;
101. while(i < 4 && *str - *suit[i++]) ;
102. if (i == 4) {
103. i = 0;
104. while(i < 13 && *str - *face[i++]) ;
105. }
106. return i;
107. }
108. void Disply(){
109. using namespace std;
110. int i, j;
111. cout << "player1" << "player2" << "player3" << "player4" << endl;
112. for (j = 0; j < 13; j++){
113. // j为第 j 行
114. for (i = 0; i < 4; i++){
115. // i为第 i 位玩家
116. cout << player[i][j].suit << player[i][j].face << "/t";
117. if (i == 3) cout << endl;
118. }
119. }
120. }
121. void Testcard(CARD *pdeck, CARD (*pplayer)[13]){
122. using namespace std;
123. int i, j;
124. CARD temp;
125. for (i = 0; i < 51; i++){
126. temp = pdeck[i];
127. if (Locat(&deck[i+1],52,temp,Equl)){
128. cout << "error! the deckcard are same"<< endl;
129. break;
130. }
131. }  // 测试桌牌是否重复
132. for (i = 0; i < 4; i++){
133. for (j = 0; j < 13; j++){
134. temp = pplayer[i][j];
135. if(Locat(&pplayer[i][j+1],13,temp,Equl)){
136. cout << "error! the player's card are same" << endl;
137. break;
138. }
139. }  // 测试手牌是否重复
140. }
141. }
142. int Locat(CARD *pdecks, int len, CARD deck, int (*compare)(CARD , CARD )){
143. // 若牌堆中有满足 compare() 的牌则返回1,没有则返回0
144. // len牌堆的长度 有13和52
145. CARD *p;
146. int i = 0;  // 第一张牌
147. p = pdecks;  // 第一张牌的地址
148. while (i < len && compare(*p++ , deck))
149. ++i;
150. if(i == len)
151. return 0;
152. else
153. return 1;
154. }
155. int Equl(CARD card1, CARD card2){
156. // 比较card1 和 card2 是否相同，相同则返回0
157. // 不同返回1
158. int fval, sval;
159. // fval 为点数字符差，sval 为花色字符差
160. fval = *card1.face - *card2.face;
161. sval = *card1.suit - *card2.suit;
162. if(fval || sval)
163. return 1;  // 有一个不同就不相同
164. else
165. return 0;
166. }