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:
//