c語言寫入文件的演算法思想

『壹』 c語言寫入文件方法

要寫入文件，可以按照以下步驟進行操作：
1 在代碼中引用stdio.h，即
#include <stdio.h>
C語言的所有文件操作介面，均聲明在這個頭文件中。
2 定義FILE *類型的變數。
3 打開文件，使用函數為fopen。格式為：
FILE *fopen(char *filename, char *mode);
參數filename為要寫入的文件名，mode為打開的方式，如果僅需寫入文件，可以使用"w"或
"wb"。
返回值為文件指針類型，賦值給之前定義的變數。如果返回值為NULL，代表打開失敗，無法寫入。
4 對文件進行寫操作。C語言中有很多寫文件的介面，包括fprintf, fwrite, fputs, fputc等等。
寫操作可以執行多次。
5 在全部寫操作完成後，執行fclose函數關閉文件指針。這樣就實現了C語言寫入文件。

『貳』 c語言怎麼將數據寫入文件

利用VC軟體通過代碼書寫就可以將數據寫入文件。

『叄』 C語言對文件的數據寫入的方法

將if((fp=fopen("e:\\文件讀寫.txt","r"))==NULL)中的判斷條件改成 if(fp==NULL)就行，因為你前面已經定義了fp=fopen("e:\\文件讀寫.txt","w");是以寫方式打開文件，所以再判斷中無需再添加以讀方式打開文件了，這樣就不會空了。

# include <stdio.h>
# include <stdlib.h>

int main ()
{
FILE *fp;

fp=fopen("e:\\文件讀寫.txt","w");

if(fp==NULL) //注意不要將==寫成=號，文件的路徑是「磁碟：\\文件夾\\文件名.格式」
{
printf("無法打開「文件讀寫.txt」\n");
exit(1);
}
else
printf("文件已成功打開，可以寫入數據了。\n");

fputc('H',fp);
fputs(" Hello World",fp);

fclose(fp);

return 0;
}

『肆』 c語言怎麼將數據寫入文件

可以使用C語言中的文件操作函數，將數據寫入文件。具體如下
一、打開文件。
使用fopen函數。格式為：
FILE *fopen(const char *name, const char * mode);
其中name為要寫入的文件名，mode為格式字元。要寫入文件，mode可以是：
1、 "w" 只寫方式，文本形式輸入；
2、"wb" 只寫方式，二進制形式輸入；
3、"wb+" 讀寫方式，二進制形式輸入；
4、"w+" 讀寫方式，文本形式輸入；
5、"a" 追加方式，寫入文件結尾，文本形式輸入;
6、"ab" 追加方式，寫入文件結尾，二進制形式輸入；

7、"ab+" 追加方式，可讀寫，寫入文件結尾，二進制形式輸入；
8、"a+" 追加方式，可讀寫，寫入文件結尾，文本形式輸入;
二、寫入數據。
可以使用各種寫入函數，向文件寫入。 如打開的文件指針為fp，可以使用如下函數：
1、 fputc， 寫入一個字元。聲明為:
int fputc(int ch, FILE *fp);
2、fputs, 寫入一個字元串，聲明為:
char * fputs(const char *str, FILE *fp);
3、fprintf，格式化寫入，功能和printf類似。 聲明為:
int fprintf(FILE *fp, const char *fmt, ...);
4、 fwirte， 按塊寫入二進制數據，聲明為:
int fwirte(char *buf, int block_size, int block_number, FILE *fp);
三、寫入完畢後，調用fclose關閉文件：
int fclose(FILE *fp);

『伍』 C語言實現文件排序

常見排序演算法（冒泡，選擇，快速）的C語言實現
要實現這幾種演算法的關鍵是要熟悉演算法的思想。簡單的說，冒泡排序，就如名字說的，每經過一輪排序，將最大的數沉到最底部。選擇排序的思想是將整個數列，分為有序區和無序區。每輪排序，將無序區里的最小數移入到有序區。快速排序的思想是以一個數為中心，通常這個數是該數列第一個數，將整個數列分為兩個部分，一個部分是大於這個數的區域，一個部分是小於這個數的區域。然後再對這兩個部分的數列分別排序。如果將數列分為兩個部分是通過，一方面從後向前的搜索，另一方面從前向後的搜索來實現的。具體的參考後面的來自網路的文檔。
從這幾個簡單的排序演算法上看，有幾個特點：
冒泡排序是最簡單的，也是最穩定的演算法。
選擇排序不太穩定，但是效率上較冒泡還是有較大的提升。其實在分析的過程中就能發現，選擇排序和冒泡排序相比，中間少了很多的交換過程，和比較的次數，這個應該是時間較少的原因。選擇排序能夠滿足一般的使用。當比較的數超過以萬為單位時，選擇排序也還是要一點時間的。
快速排序據說是最快的。這個可以從思想上看的出來。，當記錄較多的時候，快速排序的比較循環次數比上面2個都要少。但是在具體的實現過程中，並不見得如此。這是因為遞歸效率的低下導致的。當然，估計在實際使用過的過程，快速排序估計都會使用非遞歸操作棧的方式來實現。那樣應該會效率高傷不少。估計我會在後期出一個快速排序的非遞歸實現來真正比較它們3個性能。在下面的程序中，可以通過調高N的數字就能看的出來冒泡排序和選擇排序性能的差異。在N較小，大概幾百的時候，是看不出來的。N較大的的時候，比如N=1000或者N=10000的時候，快速排序的遞歸實現就會卡死在那裡了，出不了結果。
以下是具體的代碼：
/*
** 常見排序演算法比較
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#define N 10
#define Demo 1

void BubbleSort(int arr[], int n);
void SelectSort(int arr[], int n);
void QuickSort(int arr[], int n);
void PrintArray(int arr[], int n);
void GenerateArray(int arr[], int n);

int main(int argc, char *argv[])
{
int arr[N];

GenerateArray(arr, N);
#if Demo
printf("Before the bubble sort------------------------\n");
PrintArray(arr, N);
#endif
printf("Start Bubble sort----------------------\n");
clock_t start_time1=clock(); //開始計時
BubbleSort(arr, N);
clock_t end_time1=clock(); // 結束計時
printf("Running time is: %lf ms\n", (double)(end_time1-start_time1)/CLOCKS_PER_SEC*1000); //輸出運行時間
#if Demo
printf("After the bubble sort------------------------\n");
PrintArray(arr, N);
#endif
printf("-----------------------------------------------------------\n");

sleep(1000); // 單位是毫秒即千分之一秒
GenerateArray(arr, N);
#if Demo
printf("Before the selection sort------------------------\n");
PrintArray(arr, N);
#endif
printf("Start selection sort----------------------\n");
clock_t start_time2=clock(); //開始計時
SelectSort(arr, N);
clock_t end_time2=clock(); // 結束計時
printf("Running time is: %lf ms\n", (double)(end_time2-start_time2)/CLOCKS_PER_SEC*1000); //輸出運行時間
#if Demo
printf("After the selection sort------------------------\n");
PrintArray(arr, N);
#endif

printf("-----------------------------------------------------------\n");
sleep(1000); // 單位是毫秒即千分之一秒
GenerateArray(arr, N);
#if Demo
printf("Before the quick sort------------------------\n");
PrintArray(arr, N);
#endif
printf("Start quick sort----------------------\n");
clock_t start_time3=clock(); //開始計時
QuickSort(arr, N);
clock_t end_time3=clock(); // 結束計時
printf("Running time is: %lf ms\n", (double)(end_time3-start_time3)/CLOCKS_PER_SEC*1000); //輸出運行時間
#if Demo
printf("After the quick sort------------------------\n");
PrintArray(arr, N);
#endif

system("PAUSE");
return 0;
}

// 產生隨機列表
void GenerateArray(int arr[], int n)
{
int i;
srand((unsigned)time(0));

for(i = 0; i <N; i++)
{
arr[i] = rand(); // 生成隨機數 范圍在0-32767之間
}
}

// 列印列表
void PrintArray(int arr[], int n)
{
int i = 0;
for(i = 0; i < n; i++)
printf("%6d", arr[i]);
printf("\n");
}

// 經典冒泡排序
void BubbleSort(int arr[], int n)
{
int i = 0, j =0;
for(i = 0; i < n; i++)
for(j = 0; j < n - 1 - i; j++)
{
if(arr[j] > arr[j + 1])
{
arr[j] = arr[j] ^ arr[j+1];
arr[j+1] = arr[j] ^ arr[j+1];
arr[j] = arr[j] ^ arr[j+1];
}
}
}

// 快速排序的遞歸實現
void QuickSort(int arr[], int n)
{
if(n <= 1)
return;

int i =0 , j = n - 1;
int key = arr[0];
int index = 0;

while(i < j)
{
// 從後向前搜索
while(j > i && arr[j] > key)
j--;
if(j == i)
break;
else
{
//交換 a[j] a[i]
arr[j] = arr[j] ^arr[i];
arr[i] = arr[j] ^arr[i];
arr[j] = arr[j] ^arr[i];
index = j;
}

// 從前向後搜索
while(i < j && arr[i] <key)
i++;
if(i == j)
break;
else
{
// 交換 a[i] a[j]
arr[j] = arr[j] ^arr[i];
arr[i] = arr[j] ^arr[i];
arr[j] = arr[j] ^arr[i];
index = i;
}
}
QuickSort(arr, index);
QuickSort(arr + index + 1, n - 1 - index);
}

// 選擇排序
void SelectSort(int arr[], int n)
{
int i, j;
int min;

for(i = 0; i < n - 1; i++)
{
int index = 0;
min = arr[i];
for(j = i + 1; j < n; j++) //找出 i+1 - n 無序區的最小者與arr[i]交換
{
if(arr[j] < min)
{
min = arr[j];
index = j;
}
}
if(index != 0) //表明無序區有比arr[i]小的元素
{
arr[i] = arr[i]^arr[index];
arr[index] = arr[i]^arr[index];
arr[i] = arr[i]^arr[index];
}
}
}

程序里有幾點注意的地方：
一，在程序里，交換2個數，我使用了異或來處理。這個可以根據個人喜好。為了避免產生臨時變數，可以使用如下幾種方式來交換2個數：
a=a^b;
b=a^b;
a=a^b;

或者
a=a+b;
b=a-b;
a=a-b;
使用第二種也挺好的。第一種異或的方式，只適用於，2個數都為int型的，a,b可以正可以負，這個沒有關系，但是必須是int類型。
二， sleep()函數是包含在windows.h裡面的，要加入 #include <window.h>
三， 關於隨機數生成的2個函數 srand()種子發生器函數，還有rand()隨機數生成器函數，自己可以參考相關文檔。
四， Demo宏來控制是演示還是比較性能用的。當把N調整的很小，比如10的時候，可以設置Demo為1，那樣就能列印數組了，可以看到比較前後的情況。當把N調整到很大比如10000的時候，就把Demo設置為0，那樣就不列印數組，直接比較性能。

具體的演算法文檔參考下面的：
冒泡排序
基本概念
冒泡排序（BubbleSort）的基本概念是：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，將最大的數放到了最後。在第二趟：仍從第一對數開始比較（因為可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數），將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），第二趟結束，在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重復以上過程，直至最終完成排序。
由於在排序過程中總是小數往前放，大數往後放，相當於氣泡往上升，所以稱作冒泡排序。
用二重循環實現，外循環變數設為i，內循環變數設為j。外循環重復9次，內循環依次重復9，8，...，1次。每次進行比較的兩個元素都是與內循環j有關的，它們可以分別用a[j]和a[j+1]標識，i的值依次為1,2,...,9，對於每一個i, j的值依次為1,2,...10-i。
產生
在許多程序設計中，我們需要將一個數列進行排序，以方便統計，而冒泡排序一直由於其簡潔的思想方法而倍受青睞。
排序過程
設想被排序的數組R［1..N］垂直豎立，將每個數據元素看作有重量的氣泡，根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組R，凡掃描到違反本原則的輕氣泡，就使其向上"漂浮"，如此反復進行，直至最後任何兩個氣泡都是輕者在上，重者在下為止。
演算法示例
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]：
49 38 65 97 76 13 27
第一趟冒泡排序過程
38 49 65 97 76 13 27
38 49 65 97 76 13 27
38 49 65 97 76 13 27
38 49 65 76 97 13 27
38 49 65 76 13 97 27
38 49 65 76 13 27 97 – 這是第一趟冒泡排序完的結果
第二趟也是重復上面的過程，只不過不需要比較最後那個數97，因為它已經是最大的
38 49 65 13 27 76 97 – 這是結果
第三趟繼續重復，但是不需要比較倒數2個數了
38 49 13 27 65 76 97
….
選擇排序
基本思想
n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果：
①初始狀態：無序區為R[1..n]，有序區為空。
②第1趟排序
在無序區R[1..n]中選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R[1]交換，使R[1..1]和R[2..n]分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
……
③第i趟排序
第i趟排序開始時，當前有序區和無序區分別為R[1..i-1]和R(1≤i≤n-1)。該趟排序從當前無序區中選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。
這樣，n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。
常見的選擇排序細分為簡單選擇排序、樹形選擇排序（錦標賽排序）、堆排序。上述演算法僅是簡單選擇排序的步驟。
排序過程
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]：
49 38 65 97 76 13 27
第一趟排序後 13 ［38 65 97 76 49 27]
第二趟排序後 13 27 ［65 97 76 49 38]
第三趟排序後 13 27 38 [97 76 49 65]
第四趟排序後 13 27 38 49 [76 97 65]
第五趟排序後 13 27 38 49 65 [97 76]
第六趟排序後 13 27 38 49 65 76 [97]
最後排序結果 13 27 38 49 49 65 76 97
快速排序演算法
演算法過程
設要排序的數組是A[0]……A[N-1]，首先任意選取一個數據（通常選用第一個數據）作為關鍵數據，然後將所有比它小的數都放到它前面，所有比它大的數都放到它後面，這個過程稱為一趟快速排序。一趟快速排序的演算法是：
1）設置兩個變數I、J，排序開始的時候：I=0，J=N-1；
2）以第一個數組元素作為關鍵數據，賦值給key，即 key=A[0]；
3）從J開始向前搜索，即由後開始向前搜索（J=J-1），找到第一個小於key的值A[J]，並與A[I]交換；
4）從I開始向後搜索，即由前開始向後搜索（I=I+1），找到第一個大於key的A[I]，與A[J]交換；
5）重復第3、4、5步，直到 I=J； (3,4步是在程序中沒找到時候j=j-1，i=i+1，直至找到為止。找到並交換的時候i， j指針位置不變。另外當i=j這過程一定正好是i+或j+完成的最後另循環結束)
例如：待排序的數組A的值分別是：（初始關鍵數據：X=49） 注意關鍵X永遠不變，永遠是和X進行比較，無論在什麼位子，最後的目的就是把X放在中間，小的放前面大的放後面。
A[0] 、 A[1]、 A[2]、 A[3]、 A[4]、 A[5]、 A[6]：
49 38 65 97 76 13 27
進行第一次交換後： 27 38 65 97 76 13 49
( 按照演算法的第三步從後面開始找)
進行第二次交換後： 27 38 49 97 76 13 65
( 按照演算法的第四步從前面開始找>X的值，65>49,兩者交換，此時：I=3 )
進行第三次交換後： 27 38 13 97 76 49 65
( 按照演算法的第五步將又一次執行演算法的第三步從後開始找
進行第四次交換後： 27 38 13 49 76 97 65
( 按照演算法的第四步從前面開始找大於X的值，97>49,兩者交換，此時：I=4,J=6 )
此時再執行第三步的時候就發現I=J，從而結束一趟快速排序，那麼經過一趟快速排序之後的結果是：27 38 13 49 76 97 65，即所以大於49的數全部在49的後面，所以小於49的數全部在49的前面。
快速排序就是遞歸調用此過程——在以49為中點分割這個數據序列，分別對前面一部分和後面一部分進行類似的快速排序，從而完成全部數據序列的快速排序，最後把此數據序列變成一個有序的序列，根據這種思想對於上述數組A的快速排序的全過程如圖6所示：
初始狀態 {49 38 65 97 76 13 27}
進行一次快速排序之後劃分為 {27 38 13} 49 {76 97 65}
分別對前後兩部分進行快速排序 {27 38 13} 經第三步和第四步交換後變成 {13 27 38} 完成排序。
{76 97 65} 經第三步和第四步交換後變成 {65 76 97} 完成排序。

『陸』 C語言編程中寫程序的思路和方法

我的經驗是隨時把握「一分為二」的編程思路，就是任何一個問題把她分解成子問題，然後在把子問題在向下分解直到可以用「演算法」實現，套用結構化程序設計的說法就是逐步求精的過程。

『柒』 C語言如何寫入文本文件

1、首先輸入下方的代碼

#include <stdio.h>

int main()

{

//下面是寫數據，將數字0~9寫入到data.txt文件中

FILE *fpWrite=fopen("data.txt","w");

if(fpWrite==NULL)

{

return 0;

}

for(int i=0;i<10;i++)

fprintf(fpWrite,"%d ",i);

fclose(fpWrite);

//下面是讀數據，將讀到的數據存到數組a[10]中，並且列印到控制台上

int a[10]={0};

FILE *fpRead=fopen("data.txt","r");

if(fpRead==NULL)

{

return 0;

}

for(int i=0;i<10;i++)

{

fscanf(fpRead,"%d ",&a[i]);

printf("%d ",a[i]);

}

getchar();//等待

return 1;

}

『捌』 C語言如何以插入方式寫入文件

一、以只讀的方式打開原文件fopen,"r"方式；
二、以只寫的方式新建一個文件fopen,"wt"方式；
三、將原文件自y字母前的九個位元組的字元寫入新文件配合用fgetc()和fputc()兩種函數；
四、再將四個『Z』寫入新文件，用fputc()或者fputs()均可；
五、繼續將原文件未讀完的部分寫入新文件，同三
六、將原文件刪除，再將新文件改名為原文件即可，用rename()函數

『玖』 C語言如何實現對txt文件的讀取和寫入

1、使用VS新建空工程，直接點擊確定，如下所示。

『拾』 C語言：如何將數據寫入文件

原因:
使用fopen時參數不正確,你是用 w參數,若文件存在則文件長度清為0，即該文件內容會消失。每次都是重新清空並寫數據, 將w修改為a即可.
fopen函數說明見下方:
---------------
FILE * fopen(const char * path,const char * mode);
[編輯本段]函數說明
參數path字元串包含欲打開的文件路徑及文件名，參數mode字元串則代表著流形態。
mode有下列幾種形態字元串:
r 打開只讀文件，該文件必須存在。
r+ 打開可讀寫的文件，該文件必須存在。
rb+ 讀寫打開一個二進制文件，只允許讀寫數據。
rt+ 讀寫打開一個文本文件，允許讀和寫。
w 打開只寫文件，若文件存在則文件長度清為0，即該文件內容會消失。若文件不存在則建立該文件。
w+ 打開可讀寫文件，若文件存在則文件長度清為零，即該文件內容會消失。若文件不存在則建立該文件。
a 以附加的方式打開只寫文件。若文件不存在，則會建立該文件，如果文件存在，寫入的數據會被加到文件尾，即文件原先的內容會被保留。（EOF符保留）
a+ 以附加方式打開可讀寫的文件。若文件不存在，則會建立該文件，如果文件存在，寫入的數據會被加到文件尾後，即文件原先的內容會被保留。 （原來的EOF符不保留）
wb 只寫打開或新建一個二進制文件；只允許寫數據。
wb+ 讀寫打開或建立一個二進制文件，允許讀和寫。
wt+ 讀寫打開或著建立一個文本文件；允許讀寫。
at+ 讀寫打開一個文本文件，允許讀或在文本末追加數據。
ab+ 讀寫打開一個二進制文件，允許讀或在文件末追加數據。