A. c语言将数组排列并把最大的放在第一位,把最小的放在第二位
先找最大和最小的下标 然后和第一个第二个交换就行了。
voidfunc(int*a,intl)
{
intmin,max,i;
min=max=0;
for(i=1;i<l;i++)
{
if(a[i]>a[max])max=i;
if(a[i]<a[min])min=i;
}
i=a[0];
a[0]=a[max];
a[max]=i;
if(min==0)min=max;
i=a[1];
a[1]=a[min];
a[min]=i;
}
B. C语言字符串长度比较和交换
这个地方有笔误：
if ((int)strnlen_s(pstring[i], str_size) - (int)strnlen_s(pstring[w], str_size) > 0);//比较长度 这个判断有问题
//符号的前面多了；符号，导致底下的语句没有在if语句里，应该改为：
if ((int)strnlen_s(pstring[i], str_size) - (int)strnlen_s(pstring[w], str_size) > 0) //比较长度 这个判断有问题
C. c语言排列问题
下面是C语言里面常用的三种排序方法，但愿对楼主有帮助，一、冒泡法（起泡法）算法要求：用起泡法对10个整数按升序排序。算法分析：如果有n个数，则要进行n-1趟比较。在第1趟比较中要进行n-1次相邻元素的两两比较，在第j趟比较中要进行n-j次两两比较。比较的顺序从前往后，经过一趟比较后，将最值沉底（换到最后一个元素位置），最大值沉底为升序，最小值沉底为降序。算法源代码： # include main() { int a[10],i,j,t; printf("Please input 10 numbers: "); /*输入源数据*/ for(i=0;i<10;i++) scanf("%d",&a[i]); /*排序*/ for(j=0;j<9;j++) /*外循环控制排序趟数，n个数排n-1趟*/ for(i=0;i*内循环每趟比较的次数，第j趟比较n-j次*/ if(a[i]>a[i+1]) /*相邻元素比较，逆序则交换*/ { t=a[i]; a[i]=a[i+1]; a[i+1]=t; } /*输出排序结果*/ printf("The sorted numbers: "); for(i=0;i<10;i++) printf("%d ",a[i]); printf("\n"); } 算法特点：相邻元素两两比较，每趟将最值沉底即可确定一个数在结果的位置，确定元素位置的顺序是从后往前，其余元素可能作相对位置的调整。可以进行升序或降序排序。算法分析：定义n-1次循环，每个数字比较n-j次，比较前一个数和后一个数的大小。然后交换顺序。二、选择法算法要求：用选择法对10个整数按降序排序。算法分析：每趟选出一个最值和无序序列的第一个数交换，n个数共选n-1趟。第i趟假设i为最值下标，然后将最值和i+1至最后一个数比较，找出最值的下标，若最值下标不为初设值，则将最值元素和下标为i的元素交换。算法源代码： # include main() { int a[10],i,j,k,t,n=10; printf("Please input 10 numbers:"); for(i=0;i<10;i++) scanf("%d",&a[i]); for(i=0;i main() { int a[10],i,j,t; printf("Please input 10 numbers: "); for(i=0;i<10;i++) scanf("%d",&a[i]); for(i=1;i*外循环控制趟数，n个数从第2个数开始到最后共进行n-1次插入*/ { t=a[i]; /*将待插入数暂存于变量t中*/ for( j=i-1 ; j>=0 && t>a[j] ; j-- ) /*在有序序列（下标0 ~ i-1）中寻找插入位置*/ a[j+1]=a[j]; /*若未找到插入位置，则当前元素后移一个位置*/ a[j+1]=t; /*找到插入位置，完成插入*/ } printf("The sorted numbers: "); for(i=0;i<10;i++) printf("%d ",a[i]); printf("\n"); } 算法特点：每趟从无序序列中取出第一个数插入到有序序列的合适位置，元素的最终位置在最后一趟插入后才能确定位置。也可是先用循环查找插入位置（可从前往后或从后往前），再将插入位置之后的元素（有序列中）逐个后移一个位置，最后完成插入。该算法的特点是在寻找插入位置的同时完成元素的移动。因为元素的移动必须从后往前，则可将两个操作结合在一起完成，提高算法效率。仍可进行升序或降序排序。二、下面是三种排序的概念及其优缺点冒泡排序已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。再比较a[2]与a[3]的值，若a[2]大于a[3]则交换两者的值，否则不变。再比较a[3]与a[4]，依此类推，最后比较a[n-1]与a[n]的值。这样处理一轮后，a[n]的值一定是这组数据中最大的。再对a[1]~a[n-1]以相同方法处理一轮，则a[n-1]的值一定是a[1]~a[n-1]中最大的。再对a[1]~a[n-2]以相同方法处理一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。优点：稳定，比较次数已知；缺点：慢，每次只能移动相邻两个数据，移动数据的次数多。选择排序已知一组无序数据a[1]、a[2]、……a[n]，需将其按升序排列。首先比较a[1]与a[2]的值，若a[1]大于a[2]则交换两者的值，否则不变。再比较a[1]与a[3]的值，若a[1]大于a[3]则交换两者的值，否则不变。再比较a[1]与a[4]，依此类推，最后比较a[1]与a[n]的值。这样处理一轮后，a[1]的值一定是这组数据中最小的。再将a[2]与a[3]~a[n]以相同方法比较一轮，则a[2]的值一定是a[2]~a[n]中最小的。再将a[3]与a[4]~a[n]以相同方法比较一轮，依此类推。共处理n-1轮后a[1]、a[2]、……a[n]就以升序排列了。优点：稳定，比较次数与冒泡排序一样，数据移动次数比冒泡排序少；缺点：相对之下还是慢。插入排序已知一组升序排列数据a[1]、a[2]、……a[n]，一组无序数据b[1]、b[2]、……b[m]，需将二者合并成一个升序数列。首先比较b[1]与a[1]的值，若b[1]大于a[1]，则跳过，比较b[1]与a[2]的值，若b[1]仍然大于a[2]，则继续跳过，直到b[1]小于a数组中某一数据a[x]，则将a[x]~a[n]分别向后移动一位，将b[1]插入到原来a[x]的位置这就完成了b[1]的插入。b[2]~b[m]用相同方法插入。（若无数组a，可将b[1]当作n=1的数组a）优点：稳定，快；缺点：比较次数不一定，比较次数越少，插入点后的数据移动越多，特别是当数据总量庞大的时候，但用链表可以解决这个问题。
D. c语言输入多个字符串将其按长度大小排列,首字母相同时按字母表顺序排列
不知道你意思表达清楚了没，“首字母相同时按字母表顺序排列”，这句话是不是表达错了，是不是应该是若字符串长度相等时按首字母大小排序，，，，我这按升序排的，输入多少个字符串有define决定，可自己定义，
E. c语言输入一个长度为10的整数数组，将其中出现的素数首尾交换 非素数保持位置不变
#include<stdio.h>
int isprime(int n) {
if(n == 2 || n == 3)
return 1;
if (n < 2 || n % 2 == 0)
return 0;
for (int i = 2; i * i <= n; i++)
if (n % i == 0)
return 0;
return 1;
}
int main() {
int a[10], p[10], i, j, t;
for (i = 0, j = 0; i < 10; i++) {
scanf("%d", &a[i]);
if (isprime(a[i]))
p[j++] = i;
}
for (i = 0; i < j / 2; i++) {
t = a[p[i]];
a[p[i]] = a[p[j - i - 1]];
a[p[j - i - 1]] = t;
}
for (i = 0, j = 0; i < 10; i++)
printf("%d ", a[i]);
return 0;
}
F. C语言长度修正符问题
不是这么理解的。
C 标准要求 float 类型至少要能精确表示到小数点后6位，并且整数部分的表示范围至少要达到 10-37 -- 10+37 。float 一般是 32 位的。
C 标准规定double 类型的整数部分的最小表示范围和 float 一样，都是 10-37 到 10+37，但是它要求 double 类型的小数部分至少要能精确到小数点后 10 位。double 通常是 64 位的。
所以可以看出，float最多可以精确到小数点后6位，而double最多可以精确到小数点后10位
由于9999.111111正好是小数点后6位，所以使用%f,%lf输出都是一样的。
G. 用c语言通常我们对一个长度为n(n≤24)的整数数列进行排序操作,其实就是讲他们
如果没有相等的情况的话,那么输入可以看成是一个排列
每一种情况有2个分支.
分支1：将最大的数匹配到对应位置,这步可能花费1步或2步
分支2：获得排列的转置,该排列等价于其置换.这一步花费步数0
按最短路来写,需要判重,因为非常多重复状态,当n为24大概就10多万的状态点
如果输入有相等的情况,暂时没有好办法,估计数据中没有相等的情况,如果确实存在相等的情况,由于这是一个考察置换群的题目,那么看看有重复的置换群状态如何求吧
H. 用C语言编程部分排序 （急）
#include <stdlib.h>
#include <stdio.h>
void jsSort(int *a, int s)
{
int i, j, k, t, n1, n2;
for (i = 0; i < s-1; ++i)
{
k = i;
for (j = i + 1; j < s; ++j)
{
n1 = a[k] % 1000;
n2 = a[j] % 1000;
if (n1 > n2)
{
k = j;
}
else if (n1 == n2)
{
if (a[k] < a[j])
k = j;
}
}
if (k != i)
{
t = a[i];
a[i] = a[k];
a[k] = t;
}
}
}
void main()
{
int a[] = {1000, 2000, 3000, 1200, 2300, 3400, 4500, 5500, 6500};
int i;
jsSort(a, 9);
for (i = 0; i < 8; ++i)
printf("%d ", a[i]);
printf("%d\n", a[i]);
system("PAUSE");
}
I. c语言（高分）
1.相对于递归算法,递推算法免除了数据进出栈的过程，也就是说,不需要函数不断的向边界值靠拢,而直接从边界出发,直到求出函数值.
比如阶乘函数：f(n)=n*f(n-1)
在f(3)的运算过程中,递归的数据流动过程如下:
f(3){f(i)=f(i-1)*i}-->f(2)-->f(1)-->f(0){f(0)=1}-->f(1)-->f(2)--f(3){f(3)=6}
而递推如下:
f(0)-->f(1)-->f(2)-->f(3)
由此可见,递推的效率要高一些,在可能的情况下应尽量使用递推.但是递归作为比较基础的算法,它的作用不能忽视.所以,在把握这两种算法的时候应该特别注意.
2.所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
分类
在计算机科学所使用的排序算法通常被分类为：
计算的复杂度（最差、平均、和最好表现），依据串行（list）的大小（n）。一般而言，好的表现是O。(n log n)，且坏的行为是Ω(n2)。对于一个排序理想的表现是O(n)。仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要Ω(n log n)。
记忆体使用量（以及其他电脑资源的使用）
稳定度：稳定排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。也就是一个排序算法是稳定的，就是当有两个有相等关键的纪录R和S，且在原本的串行中R出现在S之前，在排序过的串行中R也将会是在S之前。
一般的方法：插入、交换、选择、合并等等。交换排序包含冒泡排序（bubble sort）和快速排序（quicksort）。选择排序包含shaker排序和堆排序（heapsort）。
当相等的元素是无法分辨的，比如像是整数，稳定度并不是一个问题。然而，假设以下的数对将要以他们的第一个数字来排序。
(4, 1) (3, 1) (3, 7) (5, 6)
在这个状况下，有可能产生两种不同的结果，一个是依照相等的键值维持相对的次序，而另外一个则没有：
(3, 1) (3, 7) (4, 1) (5, 6) (维持次序)
(3, 7) (3, 1) (4, 1) (5, 6) (次序被改变)
不稳定排序算法可能会在相等的键值中改变纪录的相对次序，但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地时作为稳定。作这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个物件间之比较，就会被决定使用在原先资料次序中的条目，当作一个同分决赛。然而，要记住这种次序通常牵涉到额外的空间负担。
排列算法列表
在这个表格中，n是要被排序的纪录数量以及k是不同键值的数量。
稳定的
冒泡排序（bubble sort） — O(n2)
鸡尾酒排序 (Cocktail sort, 双向的冒泡排序) — O(n2)
插入排序 （insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 额外 记忆体
计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外 记忆体
归并排序 （merge sort）— O(n log n); 需要 O(n) 额外记忆体
原地归并排序 — O(n2)
二叉树排序 （Binary tree sort） — O(n log n); 需要 O(n) 额外记忆体
鸽巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 额外记忆体
基数排序 （radix sort）— O(n·k); 需要 O(n) 额外记忆体
Gnome sort — O(n2)
Library sort — O(n log n) with high probability, 需要 (1+ε)n 额外记忆体
不稳定
选择排序 （selection sort）— O(n2)
希尔排序 （shell sort）— O(n log n) 如果使用最佳的现在版本
Comb sort — O(n log n)
堆排序 （heapsort）— O(n log n)
Smoothsort — O(n log n)
快速排序 （quicksort）— O(n log n) 期望时间, O(n2) 最坏情况; 对于大的、乱数串行一般相信是最快的已知排序
Introsort — O(n log n)
Patience sorting — O(n log n + k) 最外情况时间, 需要 额外的 O(n + k) 空间, 也需要找到最长的递增子序列（longest increasing subsequence）
不实用的排序算法
Bogo排序 — O(n × n!) 期望时间, 无穷的最坏情况。
Stupid sort — O(n3); 递回版本需要 O(n2) 额外记忆体
Bead sort — O(n) or O(√n), 但需要特别的硬体
Pancake sorting — O(n), 但需要特别的硬体
排序的算法
排序的算法有很多，对空间的要求及其时间效率也不尽相同。下面列出了一些常见的排序算法。这里面插入排序和冒泡排序又被称作简单排序，他们对空间的要求不高，但是时间效率却不稳定；而后面三种排序相对于简单排序对空间的要求稍高一点，但时间效率却能稳定在很高的水平。基数排序是针对关键字在一个较小范围内的排序算法。
插入排序
冒泡排序
选择排序
快速排序
堆排序
归并排序
基数排序
希尔排序
插入排序
插入排序是这样实现的：
首先新建一个空列表，用于保存已排序的有序数列（我们称之为"有序列表"）。
从原数列中取出一个数，将其插入"有序列表"中，使其仍旧保持有序状态。
重复2号步骤，直至原数列为空。
插入排序的平均时间复杂度为平方级的，效率不高，但是容易实现。它借助了"逐步扩大成果"的思想，使有序列表的长度逐渐增加，直至其长度等于原列表的长度。
冒泡排序
冒泡排序是这样实现的：
首先将所有待排序的数字放入工作列表中。
从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。
重复2号步骤，直至再也不能交换。
冒泡排序的平均时间复杂度与插入排序相同，也是平方级的，但也是非常容易实现的算法。
选择排序
选择排序是这样实现的：
设数组内存放了n个待排数字，数组下标从1开始，到n结束。
i=1
从数组的第i个元素开始到第n个元素，寻找最小的元素。
将上一步找到的最小元素和第i位元素交换。
如果i=n－1算法结束，否则回到第3步
选择排序的平均时间复杂度也是O(n²)的。
快速排序
现在开始，我们要接触高效排序算法了。实践证明，快速排序是所有排序算法中最高效的一种。它采用了分治的思想：先保证列表的前半部分都小于后半部分，然后分别对前半部分和后半部分排序，这样整个列表就有序了。这是一种先进的思想，也是它高效的原因。因为在排序算法中，算法的高效与否与列表中数字间的比较次数有直接的关系，而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了，大大减少了数字间不必要的比较。但查找数据得另当别论了。
堆排序
堆排序与前面的算法都不同，它是这样的：
首先新建一个空列表，作用与插入排序中的"有序列表"相同。
找到数列中最大的数字，将其加在"有序列表"的末尾，并将其从原数列中删除。
重复2号步骤，直至原数列为空。
堆排序的平均时间复杂度为nlogn,效率高（因为有堆这种数据结构以及它奇妙的特征，使得"找到数列中最大的数字"这样的操作只需要O(1)的时间复杂度，维护需要logn的时间复杂度），但是实现相对复杂（可以说是这里7种算法中比较难实现的）。
看起来似乎堆排序与插入排序有些相像，但他们其实是本质不同的算法。至少，他们的时间复杂度差了一个数量级，一个是平方级的，一个是对数级的。
平均时间复杂度
插入排序 O(n2)
冒泡排序 O(n2)
选择排序 O(n2)
快速排序 O(n log n)
堆排序 O(n log n)
归并排序 O(n log n)
基数排序 O(n)
希尔排序 O(n1.25)
3.索引查找是在索引表和主表(即线性表的索引存储结构)上进行的查找。索引查找的过程是：首先根据给定的索引值K1，在索引表上查找出索引值等于KI的索引项，以确定对应予表在主表中的开始位置和长度，然后再根据给定的关键字K2，茬对应的子表中查找出关键字等于K2的元素(结点)。对索引表或子表进行查找时，若表是顺序存储的有序表，则既可进行顺序查找，也可进行二分查找，否则只能进行顺序查找。
设数组A是具有mainlist类型的一个主表，数组B是具有inde)dist类型的在主表A 上建立的一个索引表，m为索引表B的实际长度，即所含的索引项的个数，KI和K2分别为给定待查找的索引值和关键字(当然它们的类型应分别为索引表中索引值域的类型和主表中关键字域在索引存储中，不仅便于查找单个元素，而且更便于查找一个子表中的全部元素。当需要对一个子袁中的全部元素依次处理时，只要从索引表中查找出该子表的开始位
置即可。由此开始位置可以依次取出该子表中的每一个元素，所以整个查找过程的时间复杂度为，若不是采用索引存储，而是采用顺序存储，即使把它组织成有序表而进行二分查找时，索引查找一个子表中的所有元素与二分查找一个子表中的所有元素相比。
若在主表中的每个子表后都预留有空闲位置，则索引存储也便于进行插入和删除运算，因为其运算过程只涉及到索引表和相应的子表，只需要对相应子表中的元素进行比较和移动，与其它任何子表无关，不像顺序表那样需涉及到整个表中的所有元素，即牵一发而动全身。
在线性表的索引存储结构上进行插入和删除运算的算法，也同查找算法类似，其过程为：首先根据待插入或删除元素的某个域(假定子表就是按照此域的值划分的)的值查找索引表，确定出对应的子表，然后再根据待插入或删除元素的关键字，在该子表中做插入或删除元素的操作。因为每个子表不是顺序存储，就是链接存储，所以对它们做插入或删除操作都是很简单的。
4.插入法排序
#define N 10
#include"stdio.h"
main()
{ int i,j,k,t,a[N];
clrscr();
printf("Please input %d numbers:\n",N);
for(i=0;i<N;i++)
scanf("%d",&a[i]);
for(i=1;i<N;i++)
{
for(j=0;j<i;j++)
{if(a[j]>a[i])
{t=a[i];
for(k=i;k>=j;k--)
a[k]=a[k-1];
a[j]=t;
}
}
}
printf("small to big order:\n");
for(i=0;i<N;i++)
printf("%-2d",a[i]);
printf("\n");
getch();
}
J. C语言VC++6.0实现一个置换加密
这个应该满足要求：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
FILE *fi,*fo;
char ps[20],txt1[1024],txt2[1024];
int plen,ps1[20];
int i,j,k;
void main(){
printf("password? ");
scanf("%s",ps);
plen=strlen(ps);
printf("PASSWORD is %s in length of %d, separated into:\n",ps,plen);
for(i=0;i<plen;i++){ps1[i]=ps[i]-48;printf("%3d",ps1[i]);}
fi=fopen("d:\\datin.txt","ra");
if(fi==NULL)exit(111);
fscanf(fi,"%s\n",txt1);
fclose(fi);
printf("\n\n---TEXT in file d:\\datin.txt before encoding : ---\n%s\n",txt1);
fo=fopen("d:\\datout.txt","wa");
if(fo==NULL)exit(222);
for(j=0;j<strlen(txt1);j++){
for(i=0;i<plen;i++)fprintf(fo,"%c",txt1[ps1[i]-1+j]);
j+=plen-1;
}
fclose(fo);
fi=fopen("d:\\datout.txt","ra");
fscanf(fi,"%s\n",txt2);
fclose(fi);
printf("\n---TEXT in file d:\\datout.txt after encoding : ---\n%s",txt2);
printf("\n");
}
// contents in datin.txt:
//