⑴ 用c语言对数组内元素乱序排列并输出
方法1：比较笨的办法是先排好。再在里面找。看是原来的第几个。 （代码我就不写了。）
方法2：有一个很快的方法，就是用快速排序排，
如果你深入的了解了快排，那么这个就很简单了。而且效率很高。
我给你写代码。
⑵ c语言如何随机打乱数组
int a[] = {3,5,7,1,4};
// 本程序考虑时间复杂度最小情况的乱序算法，O(t)=len-1
// 算法模仿彩票摇号，从全集中先取一个为第一位，再在剩余集合中取出一个为第2位，...
// 直至最后一个，只是考虑空间利用，已排序集合利用全集的空间。
int len=sizeof(a); // 全集元素数量
srand(unsigned(time(NULL))); // 摇号机准备
for(int i=len;i>1;i--) // 从全集开始摇号，直至只剩一个，已排在最后
{
int cur=len-i+(rand()%i); // 在剩余集合中摇号
int tmp=a[len-i]; // 当前序号位置挪空
a[len-i]=a[cur]; // 摇出的彩球放入当前序号
a[lcur]=tmp; // 放好剩余的彩球
}
⑶ 怎样用C语言打乱一个已排序的数组
如果要求不是很严格的话，感觉可以随机交换N次，每次交换，随机生成两个交换的元素的下标。
如果要求严格随机的话，感觉可以依次从数组里无放回的取数，并按照取数的先后顺序放入一个新的数组，然后新的数组就是打乱顺序之后的数组了。
⑷ 求一个数组打乱算法，C语言版本
objectMainextendsApp{
varreverse_pairs = 0//逆序数
defmsort[T](cmp:(T, T) => Boolean)(l:List[T]):List[T] = {
defmerge(l1:List[T], l2:List[T]):List[T]=(l1, l2)match{
case(Nil, _) => l2
case(_, Nil) => l1
case(x::left1, y::left2) =>
if(cmp(x, y))
x::merge(left1, l2)
else{
reverse_pairs += l1.length
y::merge(l1, left2)
}
}
valn = l.length / 2
if(n == 0)
return l
else{
val(l1, l2) = l.splitAt(n)
merge(msort(cmp)(l1), msort(cmp)(l2))
}
}
println(msort((x:Int, y:Int) => x<y)(List(5, 4, 3, 2, 7,6 )))
println(reverse_pairs)
}
⑸ 怎样使数组元素乱序
这个不叫乱序，这个叫排列组合。。。
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// 计算 n!
int fact(int n)
{
long f;
if (n ==0 || n == 1)
{
return 1;
}
else
{
return fact(n-1)*n;
}
}
void permutationAndCombination
(
// 基本参数
int data[],int dataSize,int selectNum,
// 递归用到的参数
int flag[],int count,
// 选择排列的结果
int ***result ,int *resultSize
)
{
int i;
int totalSelectMethods = fact(dataSize)/fact(dataSize-selectNum);
if(flag == NULL || (*result) == NULL)
{
flag = (int*)malloc(sizeof(int)*dataSize);
memset(flag,0,sizeof(int)*dataSize);
(*result) = (int**)malloc(sizeof(int*)*totalSelectMethods);
for(i=0;i<totalSelectMethods;i++)
{
(*result)[i] = (int*)malloc(sizeof(int)*selectNum);
}
*resultSize = 0;
}
if(selectNum == count)
{
(*resultSize) ++;
if((*resultSize) < totalSelectMethods)
{
for(i=0;i<selectNum;i++)
{
(*result)[*resultSize][i] = (*result)[(*resultSize)-1][i];
}
}
}
else
{
// 注意终止条件: (dataSize - i) >= (selectNum - count)
for(i = 0;i < dataSize ; i++)
{
if(flag[i] == 0)
{
(*result)[*resultSize][count] = data[i];
flag[i] = 1;
permutationAndCombination
(
data,dataSize,selectNum,
flag,count+1,
result,resultSize
);
flag[i] = 0;
}
}
}
}
int main(int argc, char *argv[])
{
int n,i,j;
int *data=NULL;
int **result = NULL,resultSize = 0;
while(scanf("%d",&n)!=EOF)
{
// 初始化排列组合用的整数数组，元素为：1~n
data = (int*)malloc(sizeof(int)*n);
for(i=0;i<n;i++)
{
data[i] = i+1;
}
// 进行排列组合
permutationAndCombination
(
data,n,n,
NULL,0,
&result,&resultSize
);
for(i=0;i<resultSize;i++)
{
printf("第%3d种方案：",i+1);
for(j=0;j<n;j++)
{
printf("%d ",result[i][j]);
}
printf("\n");
}
}
return 0;
}
/*
4
第 1种方案：1 2 3 4
第 2种方案：1 2 4 3
第 3种方案：1 3 2 4
第 4种方案：1 3 4 2
第 5种方案：1 4 2 3
第 6种方案：1 4 3 2
第 7种方案：2 1 3 4
第 8种方案：2 1 4 3
第 9种方案：2 3 1 4
第 10种方案：2 3 4 1
第 11种方案：2 4 1 3
第 12种方案：2 4 3 1
第 13种方案：3 1 2 4
第 14种方案：3 1 4 2
第 15种方案：3 2 1 4
第 16种方案：3 2 4 1
第 17种方案：3 4 1 2
第 18种方案：3 4 2 1
第 19种方案：4 1 2 3
第 20种方案：4 1 3 2
第 21种方案：4 2 1 3
第 22种方案：4 2 3 1
第 23种方案：4 3 1 2
第 24种方案：4 3 2 1
*/
⑹ 怎样使数组元素乱序
用递归吧，总体思想是：
第i个的取值的方法是：从让第i个取1到N，如果前i-1都没有取这个值，则第i个取这个值。
#define N 4
int a[N];
bool randArry(int iIndex)
{
if(N == iIndex)
{
for(int i = 0; i < N; i++)
{
printf("%d\t", a[i]);
}
printf("\n");
return true;
}
int iValue = 1;
//尝试每一个值
while(iValue <= N)
{
bool bFind = false;
//查看前几个数字是否已经取了该值
for(int i = 0; i < iIndex; i++)
{
if(iValue == a[i])
{
bFind = true;
break;
}
}
if(true == bFind)
{
iValue++;
continue ;
}
a[iIndex] = iValue;
randArry(iIndex + 1);
iValue++;
}
return true;
}
int main()
{
//赋初始值
for(int i = 0; i< N ; i++)
{
a[i] = 0;
}
randArry(0);
return 0;
}
⑺ C语言中如何将数组乱序
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<time.h>
int main()
{
int a[] = {3,5,7,1,4};
int n=5;
int i,j,T=1000,tmp;
srand(unsigned(time(NULL)));
while(T--)
{
i=rand()%n;
j=rand()%n;
tmp=a[i];
a[i]=a[j];
a[j]=tmp;
}
for(i=0;i<n;i++)printf("%d ",a[i]);
puts("");
return 0;
}
⑻ C语言中如何将数组乱序
可以这样:
srand(time(0));
for(i=0;i<N;i++)
{
m=rand()%9;
n=rand()%9;
t=a[m];
a[m]=a[n];
a[n]=t;
}
就是每次生成两个0到8之间的随机数,然后以它们作为下标,交换两个位置的数字,只要N足够大,应该能够达到要求
⑼ 用C语言怎样打乱一组数据
#pragma
once
#include
<iostream>
#include
<Windows.h>
using
namespace
std;
#pragma
comment(
lib,
"winmm.lib"
)
int
main()
{
//定义一个数组（自己随便定义，这里以10个大小的数组为例）
const
int
iSum
=
10;
int
iAry[iSum]
=
{3,7,5,87,23,1,65,8,51,64};
//定义一个数组用来保存打乱顺序后的数
int
iDistrubAry[iSum]
=
{0};
//播随机种子（以便每次随机的值有相等的机会）
srand(timeGetTime());
//每次随机的不相同的数存到这个数组里（以便下次随机时判断随机的数是否已经随机过了）
int
iRandomData[iSum]
=
{0};
//将iRandomData元数都赋初值为－1，表示没有产生一个随机数
for
(
int
i=0;
i<iSum;
i++
)
{
iRandomData[i]
=
-1;
}
//共产生不同的随机的个数
int
iRandomSum
=
0;
//打乱这个数组
for
(
int
i=0;
i<iSum;
i++
)
{
//随机一个数
int
iRandom
=
rand()%iSum;
//判断iRandomSum是否为0，是0的话表示没有随机过任何数，就不用查询是否随机到这个数了
if
(
iRandomSum
!=
0
)
{
//用来判断是否连续随机（当随机的数与之前随机的有重复时就连续随机）
for
(
int
i=0;
i<iRandomSum;
i++
)
{
if
(
iRandom
==
iRandomData[i]
)
{
iRandom
=
rand()%iSum;
//i要赋值为-1，表示重新查询是否与以前随机的数重复
i
=
-1;
}
}
}
//将产生的随机数添加到RandomData里面
iRandomData[iRandomSum]
=
iRandom;
//将随机的数作为原来数组的索引，取出原来数组此索引的值保存在打乱后的数组中
iDistrubAry[iRandomSum]
=
iAry[iRandom];
//将iRandom加1，表明已经打乱好了一个数
iRandomSum++;
}
//显示未打乱的数组
cout<<"未打乱的数组：";
for
(
int
i=0;
i<iSum;
i++
)
{
cout<<iAry[i]<<"
";
}
cout<<endl;
//显示打乱后的数组
cout<<"打乱后的数组：";
for
(
int
i=0;
i<iSum;
i++
)
{
cout<<iDistrubAry[i]<<"
";
}
cout<<endl;
system(
"pause"
);
}
⑽ 一个C语言的小问题，把一个数组随机打乱的代码，代码如下
因为i=9的时候，执行_rand(i,9);时，在函数_rand里，a为9，b为9，由于i=rand()%b; 所以i最大为8，所以在 if(i<a) goto Y; 这个地方会永远跳回到Y。就这么死循环了。