數據結構課程設計c
㈠ 求數據結構課程設計 馬踏棋盤 C語言
沒看見你說的是非遞歸的。
其實我也不懂，碰巧知道答案，在上下的。 不能插圖。
9.3 馬踏棋盤（1）
【題目要求】
國際象棋的棋盤為8*8的方格棋盤。現將"馬"放在任意指定的方格中，按照"馬"走棋的規則將"馬"進行移動。要求每個方格只能進入一次，最終使得"馬"走遍棋盤的64個方格。編寫一個C程序，實現馬踏棋盤操作，要求用1～64這64個數字標注馬移動的路徑，也就是按照求出的行走路線，將數字1，2，……64依次填入棋盤的方格中，並輸出。
國際象棋中，"馬"的移動規則如圖9-4所示。
圖9-4 "馬"的移動規則
如圖9-4所示，圖中實心的圓圈代表"馬"的位置，它下一步可移動到圖中空心圓圈標注的8個位置上，該規則叫做"馬走日"。但是如果"馬"位於棋盤的邊界附近，它下一步可移動到的位置就不一定有8個了，因為要保證"馬"每一步都走在棋盤中。
【題目分析】
馬踏棋盤的問題其實就是要將1，2，…，64填入到一個8*8的矩陣中，要求相鄰的兩個數按照"馬"的移動規則放置在矩陣中。例如數字a放置在矩陣的(i,j)位置上，數字a+1隻能放置在矩陣的(i-2,j+1)，(i-1,j+2)，(i+1,j+2)，(i+2,j+1)，(i+2,j-1)，(i+1,j-2)，(i-1,j-2)，(i-2,j-1)之中的一個位置上。將矩陣填滿並輸出。這樣在矩陣中從1，2…遍歷到64，就得到了馬踏棋盤的行走路線。因此本題的最終目的是輸出一個8*8的矩陣，在該矩陣中填有1，2…64這64個數字，相鄰數字之間遵照"馬走日"的規則。
解決馬踏棋盤問題的一種比較容易理解的方法是應用遞歸的深度優先搜索的思想。因為"馬"每走一步都是盲目的，它並不能判斷當前的走步一定正確，而只能保證當前這步是可走的。"馬"走的每一步棋都是從它當前位置出發，向下一步的8個位置中的1個行走（在它下一步有8個位置可走的情況下）。因此"馬"當前所走的路徑並不一定正確，因為它可能還有剩下的可選路徑沒有嘗試，如圖9-5所示。
圖9-5 "馬"的可選路徑
如圖9-5所示，假設最開始"馬"位於棋盤的(0,0)的位置，接下來"馬"有兩處位置可走，即(1,2)和(2,1)。這時"馬"是無法確定走2的位置最終是正確的，還是走3的位置最終是正確的。因此"馬"只能任意先從一個路徑走下去（例如從2的位置）。如果這條路是正確的，那當然是幸運的，如果不正確，則"馬"要退回到第一步，繼續從3的位置走下去。以後"馬"走的每一步行走都遵循這個規則。這個過程就是一種深度搜索的過程，同時也是一種具有重復性操作的遞歸過程。可以用一棵"探索樹"來描述該深度優先搜索過程，如圖9-6所示。
圖9-6 深度優先搜索過程
"馬"的行走過程實際上就是一個深度探索的過程。如圖9-6所示，"探索樹"的根結點為"馬"在棋盤中的初始位置（這里用4*4的棋盤示意）。接下來"馬"有兩種行走方式，於是根結點派生出兩個分支。而再往下一步行走，根結點的兩個孩子又能夠分別派生出其他不同的"行走路線"分支，如此派生下去，就得到了"馬"的所有可能的走步狀態。可以想見，該探索樹的葉子結點只可能有兩種狀態：一是該結點不能再派生出其他的"走步"分支了，也就是"馬"走不通了；二是棋盤中的每個方格都被走到，即"馬"踏遍棋盤。於是從該探索樹的根結點到第二種情況的葉結點構成的路徑就是馬踏棋盤的行走過程。
如何才能通過搜索這棵探索樹找到這條馬踏棋盤的行走路徑呢？可以採用深度優先搜索的方法以先序的方式訪問樹中的各個結點，直到訪問到葉結點。如果葉結點是第二種情況的葉結點，則搜索過程可以結束，因為找到了馬踏棋盤的行走路徑；如果葉結點為第一種情況的葉結點，即走不通了，則需要返回到上一層的結點，順著該結點的下一條分支繼續進行深度優先搜索下去。
因此在設計"馬踏棋盤"的演算法時可以借鑒前面講過的圖的深度優先遍歷演算法和二叉樹的先序遍歷演算法。但是在這里並不需要真正地構建這樣一棵探索樹，我們只需要借用探索樹的思想。在實際的操作過程中，所謂的探索樹實際就是深度優先搜索的探索路徑，每個結點實際就是當前的棋盤狀態，而所謂的葉結點要麼就是在當前棋盤狀態下，"馬"無法再進行下一步行走；要麼就是馬踏棋盤成功。該演算法描述可如下：
int TravelChess Board (int x,int y,int tag)
{
chess[x][y] = tag;
if(tag == 64) { return 1;}
找到"馬"的下一個行走坐標（x1,y1），如果找到返回flag=1,否則返回flag=0；
while(flag ){
if(TravelChessBoard (x1,y1,tag+1))return 1; /*遞歸調用TravelChess ， 從x1,y1向下搜索；如果從 x1,y1往下馬踏棋盤成功，返回1*/
else
繼續找到"馬"的下一個行走坐標（x1,y1），如果找到返回flag=1,否則返回flag=0；
}
if(flag == 0)
chess[x][y] = 0;
return 0;
}
9.3 馬踏棋盤（2）
http://book.51cto.com 2010-03-17 08:57 楊峰 清華大學出版社 我要評論(0)
摘要：《妙趣橫生的演算法（C語言實現）》第9章綜合題，，本章將列舉一些經典的綜合題編程實例。這些題目生動有趣，同時具有一定的難度，因此作者盡量做到講解深入淺出，把問題講透徹，講清楚。同時希望讀者能從中得到啟發，啟迪思維，提高自身的編程水平。本節為大家介紹馬踏棋盤。
標簽：妙趣橫生 C語言實現 妙趣橫生的演算法（C語言實現）
Oracle幫您准確洞察各個物流環節
9.3 馬踏棋盤（2）
該演算法中通過函數TravelChess()遞歸地搜索"馬"的每一種走法。其中參數x，y指定 "馬" 當前走到棋盤中的位置，tag是標記變數，每走一個棋盤方格，tag自動增1，它標識著馬踏棋盤的行走路線。
演算法首先將當前"馬"處在棋盤中的位置上添加標記tag，然後判斷tag是否等於64，如果等於64，說明這是馬踏棋盤的最後一步，因此搜索成功，程序應當結束，返回1。否則，找到"馬"下一步可以走到的位置(x1,y1)，如果找到這個位置坐標，flag置1，否則flag置0。
下面在flag為1的條件下（即找到x1,y1），遞歸地調用函數TravelChess()。也就是從x1,y1指定的棋盤中的位置繼續向下深度搜索。如果從x1,y1向下搜索成功，即程序一直執行下去，直到tag等於64返回1，那就說明"馬"已經踏遍棋盤（馬踏棋盤的過程是：先走到棋盤的(x,y）位置，再從(x1,y1)向下深度搜索，走遍全棋盤），於是搜索結束，返回1；否則繼續找到"馬"的下一個可以行走的坐標(x1,y1)，如果找到這個位置坐標，flag置1，並從(x1,y1)向下重復上述的遞歸搜索，否則flag置0，本次遞歸結束。
如果找遍當前位置(x,y)的下一個坐標(x1,y1)（一般情況是8種），但是從(x1,y1)向下繼續深度優先搜索都不能成功地"馬踏棋盤"（此時flag等於0），則表明當前所處的狀態並不處於馬踏棋盤的"行走路徑"上，也就是說"馬"本不應該走到(x,y)的位置上，因此將chess[x][y]置0，表明棋盤中該位置未被走過（擦掉足跡），同時返回0，程序退到上一層的探索狀態。
這里應當知道，所謂當前位置(x,y)的下一個坐標(x1,y1)是指"馬"下一步可以走到的地方，用坐標(x1,y1)返回。在探索樹中它處在(x,y)所在的結點的子結點中，如圖9-7所示。
圖9-7 (x,y)的下一個坐標(x1,y1)
當前位置(x,y)的下一個坐標(x1,y1)的可選個數由當前棋盤的局面決定。一般情況下是有8種可走的位置（如圖9-7所示），但是如果"馬"位於棋盤的邊緣（如圖9-7所示的探索樹的根結點）或者8個可選位置中有的已被"馬"前面的足跡所佔據，在這兩種情況下(x1,y1)的可選個數就不是8個了。
上述搜索演算法相當於先序遍歷探索樹，只不過它不一定是將探索樹完整地遍歷，而是當tag等於64時，也就是棋盤被全部"踏遍"時就停止繼續搜索了。
下面給出完整的程序清單供讀者參考。
程序清單9-3
/*--------------------------------- 9-3.c --------------------------*/
#include "stdio.h"
#define X 8
#define Y 8
int chess[X][Y];
int nextxy(int *x,int *y,int count) /*找到基於x、y位置的下一個可走的位置*/
{
switch(count)
{
case 0: if(*x+2<=X-1 && *y-1>=0 && chess[*x+2][*y-1]==0) {*x =*x+2;*y = *y-1;return 1; } break;
case 1: if(*x+2<=X-1 && *y+1<=Y-1 && chess[*x+2][*y+1]==0) {*x = *x+2; *y = *y+1 ;
return 1;}break;
case 2: if(*x+1<=X-1 && *y-2>=0 && chess[*x+1][*y-2]==0) {*x = *x+1; *y = *y-2; return 1;} break;
case 3: if(*x+1<=X-1 && *y+2<=Y-1 &&chess[*x+1][*y+2]==0) {*x = *x+1; *y = *y+2;
return 1;}break;
case 4: if(*x-2>=0 && *y-1>=0 && chess[*x-2][*y-1]==0) {*x = *x-2; *y = *y-1; return 1;} break;
case 5: if(*x-2>=0 && *y+1<=Y-1 && chess[*x-2][*y+1]==0){*x = *x-2; *y = *y+1; return 1;} break;
case 6:if(*x-1>=0 && *y-2>=0 && chess[*x-1][*y-2]==0) {*x = *x-1; *y = *y-2;return 1;}break;
case 7: if(*x-1>=0 && *y+2<=Y-1 && chess[*x-1][*y+2]==0) {*x = *x-1; *y = *y+2;
return 1;}break;
default: break ;
}
return 0;
}
int TravelChessBoard(int x,int y,int tag) /*深度優先搜索地"馬踏棋盤"*/
{
int xx1 = x, yy1 = y, flag = 0,a,b ,count = 0 ;
chess[x][y] = tag;
if(tag == X*Y) { return 1;}
flag = nextxy(&x1,&y1,count);
while(flag == 0 && count <7){
countcount = count + 1;
flag = nextxy(&x1,&y1,count);
}
while(flag ){
if(TravelChessBoard(x1,y1,tag+1))return 1;
xx1 = x;yy1 = y;
countcount = count +1;
flag = nextxy(&x1,&y1,count); /*尋找下一個(x,y)*/
while(flag == 0 && count <7){ /*循環地尋找下一個(x,y)*/
countcount = count + 1;
flag = nextxy(&x1,&y1,count);
}
}
if(flag == 0)
chess[x][y] = 0;
return 0;
}
main()
{
int i,j;
for(i=0;i<X;i++)
for(j=0;j<Y;j++)
chess[i][j] = 0;
if(TravelChessBoard(2,0,1)) {
for(i=0;i<X;i++) {
for(j=0;j<Y;j++)
printf("%d ",chess[i][j]);
printf("\n");
}
printf("The horse has travelled the chess borad\n");
}
else
printf("The horse cannot travel the chess board\n");
getche();
}
9.3 馬踏棋盤（3）
http://book.51cto.com 2010-03-17 08:57 楊峰 清華大學出版社 我要評論(0)
摘要：《妙趣橫生的演算法（C語言實現）》第9章綜合題，，本章將列舉一些經典的綜合題編程實例。這些題目生動有趣，同時具有一定的難度，因此作者盡量做到講解深入淺出，把問題講透徹，講清楚。同時希望讀者能從中得到啟發，啟迪思維，提高自身的編程水平。本節為大家介紹int nextxy(int *x,int *y,int count)。
標簽：妙趣橫生 C語言實現 妙趣橫生的演算法（C語言實現）
Oracle幫您准確洞察各個物流環節
9.3 馬踏棋盤（3）
【程序說明】
本程序中應用二維數組chess[8][8]作為8*8的棋盤，"馬"每走到棋盤的(i,j)處，就將當前的步數tag賦值給chess[i][j]。為了方便起見，將數組chess設置為外部變數。另外定義字元常量X，Y，它規定棋盤的大小。本程序清單中將X和Y都設置為8。
函數TravelChessBoard()是上述馬踏棋盤演算法的具體實現。本程序中初始的(x,y)位置為(2,0)，說明"馬"從chess[8][8]的chess[2][0]位置開始進行"馬踏棋盤"的。在函數TravelChessBoard()中要調用函數nextxy()。
int nextxy(int *x,int *y,int count)
函數nextxy()包含3個參數：x和y為傳遞下來的"馬"當前踏到棋盤上的位置，它是指針變數。變數count的作用是標記調用nextxy()過程的次數，根據count值的不同，返回基於(x,y)的下一個不同的坐標，以此來避免返回同一個坐標，真正實現尋找"針對當前位置(x,y)的下一個位置"的目的。函數nextxy()的作用是找到"馬"當前的位置(x,y)的下一個可以行走的位置，並通過指針修改x、y的內容，將下一個位置坐標用變數x、y返回。
"尋找(x,y)的下一個位置坐標"的操作通過代碼：
xx1 = x; yy1 = y; /*將坐標(x1,y1)初始化為當前訪問的坐標 (x,y)，因為(x,y)不能被改動*/
flag = nextxy(&x1,&y1,count); /*尋找(x,y)下一個位置坐標(x1,y1)*/
while(flag == 0 && count <7){ /*循環地尋找(x,y)的下一個坐標*/
countcount = count + 1;
flag = nextxy(&x1,&y1,count);
}
實現。程序最開始將(x1,y1)初始化為當前坐標(x,y)，因為"馬"的當前位置坐標(x,y)不能被輕易改動。然後將&x1、&y1作為函數nextxy的參數傳遞，並通過參數&x1和&y1返回當前坐標(x,y)的第count個下一個坐標(x1,y1)。只有當flag為1時，才表明找到了下一個坐標，於是循環可以停止。但是如果count的值超過了7，則說明無法找到(x,y)的下一個坐標，也就說明棋走不通了。所謂當前位置(x,y)的"下一個位置"，如圖9-8所示。
（點擊查看大圖）圖9-8 (x,y)的"下一個位置"示意
圖中實心的圓圈的坐標為(x,y)，它周圍的8個空心的圓圈1～8，為當前坐標(x,y)的可選的"下一個"坐標(x1,y1)。每次調用nextxy()都可能得到這8個坐標其中的一個，當參數count為i時，返回圓圈i所處的坐標。這樣就保證了不返回同一個坐標。
如果像本程序這樣將字元常量X和Y都設置為8，那麼程序就執行8*8的馬踏棋盤。但是這樣一來會非常費時，實踐證明應用本程序運算出8*8的馬踏棋盤的結果要花幾分鍾的時間。因此讀者在調試程序時可以通過設置X和Y的值減小棋盤的規格，從而更快地得到結果。
本程序的運行結果如圖9-9所示。
（點擊查看大圖）圖9-9 程序9-3的運行結果
㈡ c語言數據結構課程設計 順序表源碼
我幫你做好!
㈢ c語言 數據結構課程設計 圖書管理系統
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//
#define MAXSIZE 100 //最大值定義為100
#define LIST_INIT_SIZE 100//圖書證使用者最大值定義為100
//借書人的結構體
typedef struct Boro//借書行為
{
char BNum[20];//借書的書號
char RetDate[8];//歸還日期
struct Boro *next;
}Bor;
typedef struct LinkBook
{
Bor *next; //該圖書證的借書行為
char CNum[20]; //卡號
int Total; //借書的數量
}lend[LIST_INIT_SIZE];//借書人數組
//圖書的結構體信息
typedef struct LNode
{
char CardNum[20];//圖書證號
struct LNode *next;
}LinkList; //借書人
typedef struct book
{//每種圖書需要登記的內容包括書號ISBN、書名、作者、出版社、總庫存量和現庫存量。
char num[20];//書號
char name[20];//書名
char auth[20];//作者
char pub[20];//出版社
int TotNum;//總庫存
int NowNum;//現庫存
LinkList *next;//借了該書的人
}ook[MAXSIZE];
//
int Retotal;//讀者數量
int total; //定義外部變數.書的種類數
//
//結構體初始化
void InitBo(ook &boo) //初始化圖書信息
{
for(int i=0;i<MAXSIZE;i++)
{
boo[i].NowNum=0;
boo[i].TotNum=0;
boo[i].next=NULL;
}
}
void InitRe(lend &Lin) //初始化借閱者信息
{
for(int i=0;i<LIST_INIT_SIZE;i++)
Lin[i].next=NULL;
}
//
int mid=0;//外部函數mid，用來返回查找到的位置
bool BinarySearch(ook boo,char SearchNum[]) //二分法查找比較書號
{ //用bool函數，但由於函數不能有兩個返回值,所以設置一個外部變數mid，用來返回查找到的位置
int low=0,high=total-1;
int found=0;
while(low<=high)
{
mid=(low+high)/2; //中間點
if(strcmp(boo[mid].num,SearchNum)==0) //書號相同
{
found=1;
return true;
}//查找成功
if(strcmp(boo[mid].num,SearchNum)!=0)//書號不同
high=mid-1;
else low=mid+1;
}
if(found==0)
return false; //查找失敗
}
void Buy(ook &boo, char BuyNum[])
{//1、 采編入庫：新購入一種書，如果該書在圖書賬目中已經存在，則將其庫存量增加（包
//括總庫存量和現庫存量），如果該書不存在，則在圖書賬目中增加一種書，總庫存量和現庫存量均為1。
if(BinarySearch(boo,BuyNum)) //如果書庫中有此書
{
boo[mid].TotNum++; //總庫存加1
boo[mid].NowNum++; //現庫存加1
printf("入庫成功.\n");
printf("已更改書庫中該書的信息。編號 %s 的書 %s 作者是 %s ,出版社是 %s ,目前的總庫存是 %d ,現庫存是 %d 。\n",boo[mid].num,boo[mid].name,boo[mid].auth,boo[mid].pub,boo[mid].TotNum,boo[mid].NowNum);
}
if(!BinarySearch(boo,BuyNum))
{
int i;
for(i=total;i>mid&&total;i--) //插在適合位置 保持有序
boo[i]=boo[i-1]; //空出插入位置
printf("該書在書庫中不存在。設立新書目，請補全書的詳細信息。\n");
strcpy(boo[i].num,BuyNum);
printf("該書購入的數量是:");
scanf(" %d",&boo[i].NowNum);
boo[i].TotNum=boo[i].NowNum;
printf("該書的名字是:");
scanf(" %s",&boo[i].name);
printf("該書的作者是:");
scanf(" %s",&boo[i].auth);
printf("該書的出版社是:");
scanf(" %s",&boo[i].pub);//補全信息
boo[i].next=NULL;
total++;//總量+1
printf("已增加該書的信息。編號 %s 的書 %s 作者是 %s ,出版社是 %s ,目前的總庫存是 %d ,現庫存是 %d 。\n",boo[i].num,boo[i].name,boo[i].auth,boo[i].pub,boo[i].TotNum,boo[i].NowNum);
printf("入庫成功.\n");
}
}
void Delete(ook &boo,char DeleteNum[])
{//2、 清空庫存：某一種書已無保留價值，將它從圖書賬目中注銷。
if(BinarySearch(boo,DeleteNum)==false||total==0) //如果無此書
printf("書庫中沒有該書.\n");
if(BinarySearch(boo,DeleteNum))//若有
{
if(!boo[mid].next)
{
int j;
for( j=mid;j<total;j++)
boo[j]=boo[j+1];
strcpy(boo[j].num,boo[j+1].num);
strcpy(boo[j].name,boo[j+1].name);
strcpy(boo[j].auth,boo[j+1].auth);
strcpy(boo[j].pub,boo[j+1].pub);
boo[j].TotNum=boo[j+1].TotNum;
boo[j].NowNum=boo[j+1].NowNum;
printf("已成功刪除該書.\n");
}
else printf("該書有借閱者，無法刪除。\n");
}
}
void Borrow(ook &boo,lend &Lin,char BorrowNum[],char CaNum[])
{//3、 借閱：如果一種書的現庫存量大於零，則借出一本書，將現庫存量減1，
//並登記借閱者的圖書證號和歸還期限。
Bor *p,*q;
LinkList *m,*n;
if(!BinarySearch(boo,BorrowNum)||total==0) //如果沒有找到此書
printf("書庫里沒這書。\n");//如果有這書
if(BinarySearch(boo,BorrowNum)) //書庫里有
{
if(boo[mid].NowNum>0) //看現庫存是否大於0
{
boo[mid].NowNum--;//借出一本，少1
if(boo[mid].next==NULL) //若該書信息下顯示該種書還沒被人借過
{
m=(LinkList *)malloc(sizeof(LNode));//分配
boo[mid].next=m;//該圖書信息中的鏈表的第一個結點
strcpy(m->CardNum,CaNum);
m->next=NULL;//後一個結點為空
}
else //如果已經有人在借這書了
{
m=boo[mid].next;
while(m->next) //遍歷到最後一個結點
m=m->next;
n=(LinkList *)malloc(sizeof(LNode));//分配空間，增加1個結點
m->next=n;
strcpy(n->CardNum,CaNum);//記錄證號
n->next=NULL;
}
int i=0;
for(i=0;i<Retotal;i++)//
{
if(!strcmp(Lin[i].CNum,CaNum))//如果已經有該圖書證的信息
{
p=Lin[i].next;
while(p->next)p=p->next;//遍歷到最後一個結點
q=(Bor *)malloc(sizeof(Boro));//分配空間
p->next=q;
strcpy(q->BNum,BorrowNum); //記錄書號
printf("輸入歸還日期:");
scanf("%s",&q->RetDate);
q->next=NULL;
printf("借閱成功.\n");
break; //找到證了就跳出循環
}
}
if(i==Retotal)//如果沒有這張證的信息
{
strcpy(Lin[i].CNum,CaNum); //記錄證號
p=(Bor *)malloc(sizeof(Boro)); //分配空間
Lin[i].next=p;
strcpy(p->BNum,BorrowNum);
printf("輸入歸還日期:");
scanf(" %s",&p->RetDate);
p->next=NULL;
Retotal++; //借閱證號信息總數加1
printf("借閱成功.\n");
}
}
else printf("借閱失敗.該書現在庫存為0.\n");
}
}
void Return(ook &boo,lend &Lin,char ReturnNum[],char BorrowerNum[])
{//4、 歸還：注銷對借閱者的登記，改變該書的現存量。
Bor *p,*q;
LinkList *m,*n;
int flag=0;//設置一個參數
if(!BinarySearch(boo,ReturnNum)||!total) //沒書
printf("書庫中無此書.\n");
if(BinarySearch(boo,ReturnNum)) //有書
{
m=boo[mid].next;
if(!strcmp(m->CardNum,BorrowerNum)) //如果是第一個借的人還的
{
boo[mid].NowNum++; //現庫存加1
boo[mid].next=m->next; //刪除結點
free(m); //釋放該結點的空間空間
}
else
{
while(m->next) //查找歸還者的借閱者結點
{
if(!strcmp(m->next->CardNum,BorrowerNum)) //如果找到
{
n=m->next; //n為歸還者的借閱結點
m->next=n->next; //m指向歸還者的借閱結點的下一結點
free(n); //釋放空間
boo[mid].NowNum++; //現庫存加1
break;
}
m=m->next;
}
}
}
//在借閱者表裡查找借閱者信息
for(int i=0;i<Retotal;i++)
{
if(!strcmp(Lin[i].CNum,BorrowerNum)) //如果找到借閱者
{
p=Lin[i].next;
if(!strcmp(p->BNum,ReturnNum)) //如果是歸還的是借的第一本書
{
Lin[i].next=p->next; //指向下一借書結點
free(p); //釋放結點空間
printf("成功歸還該書.\n");
flag=1;
break;
}
else //找不到
{
while(p->next) //找到歸還書的借書結點
{
if(!strcmp(p->next->BNum,ReturnNum)) //如果找到
{
q=p->next; //q為歸還書的借書結點
p->next=q->next; //p指向下一借書結點
free(q); //釋放空間
printf("成功歸還該書.\n");
flag=1;
break;
}
p=p->next;
}
}
}
}
for(int k=0;k<Retotal;k++)
if(!Lin[k].next)
{
int j;
for(j=k;j<Retotal;j++)
Lin[j]=Lin[j+1]; //其後都往前移一位，覆蓋掉當前信息
strcpy(Lin[j].CNum," "); //刪除圖書證號
Retotal--; //圖書證數減1
} //刪除當前狀態下沒借書的圖書證的信息，節省空間
if(flag==0) printf("無該證信息.\n");
}
//5、 查找：實現按三種查詢條件之一查找：按書號查找、
//按書名查找、按作者查找。註：可不實現組合查找，即幾個條件組合查找。
void SearchByNum(ook &boo,char SeaNum[])
{//BY NUM 根據書號查找
LinkList *p;
p=boo[mid].next;
if(BinarySearch(boo,SeaNum)==false)printf("對不起，未找到您想查找的書。\n");//二分查找 沒找到
else//找到了的話
{
{
printf("┏━━━━━━━┳━━━━━━━┳━━━━━━━━┳━━━━━━━━┳━━━━━┳━━━━━┓\n");
printf("┃ 書號 ┃ 書名 ┃ 作者 ┃ 出版社 ┃ 現庫存 ┃ 總庫存 ┃\n");
printf("┣━━━━━━━╋━━━━━━━╋━━━━━━━━╋━━━━━━━━╋━━━━━╋━━━━━┫\n");
printf("┃%14s┃%14s┃%16s┃%16s┃%10d┃%10d┃\n",boo[mid].num,boo[mid].name,boo[mid].auth,boo[mid].pub,boo[mid].NowNum,boo[mid].TotNum);
printf("┗━━━━━━━┻━━━━━━━┻━━━━━━━━┻━━━━━━━━┻━━━━━┻━━━━━┛\n");
if(boo[mid].next!=NULL)
{
printf("┏━━━━━━━┓\n");
printf("┃ 已借該書的 ┃\n");
printf("┃ 圖書證號 ┃\n");
while(p)
{
printf("┣━━━━━━━┫\n");
printf("┃%14s┃\n",p->CardNum);
p=p->next;
}
printf("┗━━━━━━━┛\n");
}
}
while(p)
{
printf(" %s ",p->CardNum);//在按書號查找的函數里也顯示借了這本書的借閱者的證號
p=p->next;
}
printf(" \n");
}//顯示查找的書籍的信息
}
void SearchByName(ook &boo)
{//BY NAME 根據書名查找
char SeaName[20];
printf("輸入想查找的書的書名:\n");
scanf(" %s",&SeaName);
printf("找到符合該書名的書的詳細信息如下：\n");
for(int i=0;i<total;i++)
{
if(strcmp(SeaName,boo[i].name)==0)//如果書名一樣
{
printf("書號：%s\n書名：%s\n作者：%s\n出版社：%s\n總庫存量：%d\n現庫存量：%d\n\n",boo[i].num,boo[i].name,boo[i].auth,boo[i].pub,boo[i].TotNum,boo[i].NowNum);
}//顯示符合信息的所有書籍的信息
}
}
void SearchByAuth(ook &boo)
{// BY AUTH 根據作者查找
char SeaAuth[20];
printf("輸入想查找的書的作者:\n");
scanf(" %s",&SeaAuth);
printf("找到符合該作者的書的詳細信息如下：\n");
for(int i=0;i<total;i++)
{
if(strcmp(SeaAuth,boo[i].auth)==0)//如果作者一樣
{
printf("書號：%s\n書名：%s\n作者：%s\n出版社：%s\n總庫存量：%d\n現庫存量：%d\n\n",boo[i].num,boo[i].name,boo[i].auth,boo[i].pub,boo[i].TotNum,boo[i].NowNum);
}//顯示符合信息的所有書籍的信息
}
}
//6、 查看：可查看某圖書證號的借閱者借閱的全部圖書，可查看全部超期未還的圖書。
void ViewCard(ook &boo,lend &Lin)
{//查看某圖書證號的借閱者借閱的全部圖書
char Num[20];
printf("請輸入您所想要查看的圖書證號:\n");
scanf(" %s",&Num);
Bor *p;
int qqq=0;
for(int i=0;i<Retotal;i++)
{
if(strcmp(Lin[i].CNum,Num)==0) //找到該證
{
printf("這個證借的書有：\n");
p=Lin[i].next;
while(p)
{
printf(" %s ",p->BNum); //書號
p=p->next;
}
printf("\n");
qqq=1;
break;
}
}
if(qqq==0)
printf("該證不存在.\n");
}
void ViewBook(ook &boo,lend &Lin)
{//查看全部超期未還的圖書
char date[8];
Bor *p;
printf("請輸入日期（請按格式20060605輸入）:\n");
scanf(" %s",&date);
printf("所有超期未還的書有:\n");
for(int i=0;i<Retotal;i++)
{
p=Lin[i].next;
while(p)//當p不空時
{
if(strcmp(p->RetDate,date)<0) //超過日期
{
printf("書號為 %s 證號為 %s 應歸還日期為 %s \n",p->BNum,Lin[i].CNum,p->RetDate);
}//顯示所有超期未還的書的信息
p=p->next;
}
}
}
void Menu() //菜單
{
printf("┏—————————————————M E N U————————————————┓\n");
printf("│ │\n");
printf("│ 1. 采編入庫：新購入一種書，如果該書在圖書賬目中已經存在， │\n");
printf("│ 則將其庫存量增加(包括總庫存量和現庫存量)。 │\n");
printf("│ 如果該書不存在，則在圖書賬目中增加一種書， │\n");
printf("│ 總庫存量和現庫存量均為輸入的數字。 │\n");
printf("│ 2. 清空庫存：某一種書已無保留價值，將它從圖書賬目中注銷。 │\n");
printf("│ 3. 借閱：如果一種書的現庫存量大於零，則借出一本書，將現庫存量減1， │\n");
printf("│ 並登記借閱者的圖書證號和歸還期限。 │\n");
printf("│ 4. 歸還：注銷對借閱者的登記，改變該書的現存量。 │\n");
printf("│ 5. 按書號查找。 │\n");
printf("│ 6. 按書名查找。 │\n");
printf("│ 7. 按作者查找。 │\n");
printf("│ 8. 查看某圖書證號的借閱者借閱的全部圖書。 │\n");
printf("│ 9. 查看全部超期未還的圖書。 │\n");
printf("│ 0. 退出圖書管理系統。 │\n");
printf("│ │\n");
printf("┗—————————————請 選 擇 你 需 要 的 操 作————————————┛\n");
}
void main()
{
ook Bo;
lend Lin;
char BNum[20];
char CNum[20];
printf("-----------------------歡 迎 進 入 圖 書 管 理 系 統!---------------------------\n\n");
int choice=10;
int SearchCho=10,ViewCho=10;
while(choice!=0)
{
Menu();//顯示菜單
scanf(" %d",&choice);
switch(choice)
{
case 1://采編入庫
printf("請輸入入庫的書的書號:");
scanf(" %s",BNum);
Buy(Bo,BNum);
break;
case 2://清空庫存
printf("請輸入想要清除的書的書號:");
scanf(" %s",BNum);
Delete(Bo,BNum);
break;
case 3://借閱
printf("請輸入想要借閱的書的書號:\n");
scanf(" %s",&BNum);
printf("請輸入圖書證號:");
scanf(" %s",&CNum);
Borrow(Bo,Lin,BNum,CNum);
break;
case 4://歸還
printf("請輸入想要歸還的書的書號:\n");
scanf(" %s",&BNum);
printf("請輸入圖書證號:");
scanf(" %s",&CNum);
Return(Bo,Lin,BNum,CNum);
break;
case 5://查找//根據書號查找
printf("請輸入書號:");//輸入書號查找
scanf(" %s",&BNum);
SearchByNum(Bo,BNum);
break;
case 6://根據書名查找
SearchByName(Bo);
break;
case 7://根據作者查找
SearchByAuth(Bo);
break;
case 8://查看某圖書證所借的所有書
ViewCard(Bo,Lin);
break;
case 9: //查看全部超期未還的書
ViewBook(Bo,Lin);
break;
case 0://退出系統
exit(0);break;
default:printf("輸入錯誤!\n");exit(0);break;
}
}
}
㈣ 數據結構課程設計(C語言）
我這個和你要的差不多吧,,我做實驗用的..筆視收費
#include <iostream>
#include <string.h>
#include <string> //字元串操作
#include <iomanip>
using namespace std;
#define N 50 //學生數
#define M 10 //課程數
struct student
{ char name[20];
int number;
int score[8];
}stu[60];
string kechengming[M];
void changesort(struct student a[],int n,int j)
{int flag=1,i;
struct student temp;
while(flag)
{flag=0;
for(i=1;i<n-1;i+=2)
if(a[i].score[j]<a[i+1].score[j]) /*奇數項比較*/
{temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
flag=1;
}
for(i=0;i<n-1;i+=2)
if(a[i].score[j]<a[i+1].score[j]) /*偶數項比較*/
{temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
flag=1;
}
}
}
void print(struct student a[],int n,int j)
{
int i,k;
cout<<kechengming[j]<<"前5名數據如下："<<endl;
cout<<setw(8)<<"名次"<<setw(8)<<"學號"<<setw(8)<<"姓名"<<setw(8)<<kechengming[j]<<endl;
k=1;
for(i=0;k<=5 && i<n;i++)
{if(i>0 && a[i].score[j]!=a[i-1].score[j])
k++;
cout<<setw(8)<<k;
cout<<setw(8)<<a[i].number;
cout<<setw(8)<<a[i].name;
cout<<setw(8)<<a[i].score[j];
cout<<endl;
}
}
int main()
{
int i,j,k,n,m;
struct student temp;
cout<<"請輸入學生數(最多為"<<N<<"個)：";
cin>>n;
cout<<"請輸入課程數(最多為"<<M-2<<"個)：";
cin>>m;
kechengming[m]="sum";kechengming[m+1]="avg";
for(i=0;i<m;i++)
{cout<<"請輸入第"<<i+1<<"個課程名:";
cin>>kechengming[i]; //輸入課程名
}
for(i=0;i<n;i++)
{cout<<"請輸入第"<<i+1<<"個同學的姓名:";
cin>>stu[i].name;
cout<<"請輸入第"<<i+1<<"個同學的學號:";
cin>>stu[i].number;
for(j=0;j<m;j++)
{cout<<"請輸入"<<kechengming[j]<<"的成績:";
cin>>stu[i].score[j];
}
}
for(i=0;i<n;i++)
{stu[i].score[m]=0;
for(j=0;j<m;j++)
stu[i].score[m]+=stu[i].score[j];
stu[i].score[m+1]=stu[i].score[m]/m;
}
changesort(stu,n,m);
cout<<"學生成績如下："<<endl;
cout<<setw(6)<<"名次";
cout<<setw(6)<<"姓名";
cout<<setw(6)<<"學號";
for(i=0;i<m+2;i++)
cout<<setw(6)<<kechengming[i];
cout<<endl;
k=1;
for(i=0;i<n;i++)
{if(i>0 && stu[i].score[m]!=stu[i-1].score[m])
k++;
cout<<setw(6)<<k;
cout<<setw(6)<<stu[i].name;
cout<<setw(6)<<stu[i].number;
for(j=0;j<m+2;j++)
cout<<setw(6)<<stu[i].score[j];
cout<<endl;
}
j=0;
cout<<"請輸入您要對第幾個成績進行排序(1~"<<m<<")：";
cin>>i;
while(i>=0 && j==0)
{ if(i>0 && i<m+1)
{
changesort(stu,n,i-1);
print(stu,n,i-1);
cout<<"請輸入您要對第幾個成績進行排序：(1~"<<m<<",輸入0退出)";
cin>>i;
}
else if(i==0)
j=1;
else
{cout<<"輸入有誤，請重新輸入：";
cin>>i;
}
}
return 0;
}
㈤ C語言與數據結構課程設計求指導
你可以用結構體數組，給你一個例子：
#include <stdio.h>
//定義結構體Student,學生姓名不超過10個字元
//三門課程成績均為百分制，只取整數；平均分帶小數
struct Student
{
char name[11];
int A;
int B;
int C;
float aver;
};
int main()
{
struct Student stud[3];//定義結構體數組stud[3]
//對input()、average()、print()三個函數進行聲明
void input(Student s[], int n);
void average(Student s[], int n);
void print(Student s[], int n);
//調用input()、average()、print()三個函數
input(stud,3);
average(stud,3);
print(stud,3);
return 0;
}
//定義輸入n名學生的姓名、三門課程成績的函數
void input(Student s[], int n)
{
int i;
for(i=0;i<n;i++)
{
printf("請輸入第 %d 名學生數據：\n",i+1);
printf("姓 名："); scanf("%s",s[i].name);
printf("A課程成績："); scanf("%d",&(s[i].A));
printf("B課程成績："); scanf("%d",&(s[i].B));
printf("C課程成績："); scanf("%d",&(s[i].C));
printf("\n");
}
}
//定義計算n名學生三門課程總分的函數
void average(Student s[], int n)
{
int i;
for(i=0;i<n;i++)
s[i].aver=(s[i].A+s[i].B+s[i].C)/3.0f;
}
//定義輸出n名學生的姓名、三門課程成績、總分的函數
void print(Student s[], int n)
{
int i;
printf("\n學生成績列表：\n");
for(i=0;i<n;i++)
{
printf("姓名：%s, ",s[i].name);
printf("A課程成績：%d, ",s[i].A);
printf("B課程成績：%d, ",s[i].B);
printf("C課程成績：%d，",s[i].C);
printf("平均分：%f。\n",s[i].aver);
}
printf("\n");
}
㈥ 跪求數據結構課程設計（C語言版）代碼，感激不盡
在C語言中，結構體(struct)指的是一種數據結構，是C語言中聚合數據類型(aggregate data type)的一類。結構體可以被聲明為變數、指針或數組等，用以實現較復雜的數據結構。結構體同時也是一些元素的集合，這些元素稱為結構體的成員(member)，且這些成員可以為不同的類型，成員一般用名字訪問。[1]
定義與聲明
結構體的定義如下所示，struct為結構體關鍵字，tag為結構體的標志，member-list為結構體成員列表，其必須列出其所有成員；variable-list為此結構體聲明的變數。[1]
struct tag {
member-list
} variable-list ;
在一般情況下，tag、member-list、variable-list這3部分至少要出現2個。以下為示例：[1]
//此聲明聲明了擁有3個成員的結構體，分別為整型的a，字元型的b和雙精度的c
//同時又聲明了結構體變數s1
//這個結構體並沒有標明其標簽
struct {
int a;
char b;
double c;
} s1;
//同上聲明了擁有3個成員的結構體，分別為整型的a，字元型的b和雙精度的c
//結構體的標簽被命名為SIMPLE,沒有聲明變數
struct SIMPLE{
int a;
char b;
double c;
};
//用SIMPLE標簽的結構體，另外聲明了變數t1、t2、t3
struct SIMPLE t1, t2[20], *t3;
//也可以用typedef創建新類型
typedef struct{
int a;
char b;
double c;
} Simple2;
//現在可以用Simple2作為類型聲明新的結構體變數
Simple2 u1, u2[20], *u3;
在上面的聲明中，第一個和第二聲明被編譯器當作兩個完全不同的類型，即使他們的成員列表是一樣的，如果令t3=&s1，則是非法的。[1]
結構體的成員可以包含其他結構體，也可以包含指向自己結構體類型的指針，而通常這種指針的應用是為了實現一些更高級的數據結構如鏈表和樹等。[1]
//此結構體的聲明包含了其他的結構體
struct COMPLEX{
char string[100];
struct SIMPLE a;
};
//此結構體的聲明包含了指向自己類型的指針
struct NODE{
char string[100];
struct NODE *next_node;
};
如果兩個結構體互相包含，則需要對其中一個結構體進行不完整聲明，如下所示：[1]
struct B;
//對結構體B進行不完整聲明
//結構體A中包含指向結構體B的指針
struct A{
struct B *partner;
//other members;
};
//結構體B中包含指向結構體A的指針，在A聲明完後，B也隨之進行聲明
struct B{
struct A *partner;
//other members;};
結構體作用
結構體和其他類型基礎數據類型一樣，例如int類型，char類型 只不過結構體可以做成你想要的數據類型。以方便日後的使用。[1]
在實際項目中，結構體是大量存在的。研發人員常使用結構體來封裝一些屬性來組成新的類型。由於C語言內部程序比較簡單，研發人員通常使用結構體創造新的「屬性」，其目的是簡化運算。[1]
結構體在函數中的作用不是簡便，其最主要的作用就是封裝。封裝的好處就是可以再次利用。讓使用者不必關心這個是什麼，只要根據定義使用就可以了。[1]
結構體的大小與內存對齊
結構體的大小不是結構體元素單純相加就行的，因為我們主流的計算機使用的都是32bit字長的CPU，對這類型的CPU取4個位元組的數要比取一個位元組要高效，也更方便。所以在結構體中每個成員的首地址都是4的整數倍的話，取數據元素時就會相對更高效，這就是內存對齊的由來。每個特定平台上的編譯器都有自己的默認「對齊系數」(也叫對齊模數)。程序員可以通過預編譯命令#pragma pack(n)，n=1,2,4,8,16來改變這一系數，其中的n就是你要指定的「對齊系數」。[1]
規則：
1、數據成員對齊規則：結構(struct)(或聯合(union))的數據成員，第一個數據成員放在offset為0的地方，以後每個數據成員的對齊按照#pragma pack指定的數值和這個數據成員自身長度中，比較小的那個進行。[1]
2、結構(或聯合)的整體對齊規則：在數據成員完成各自對齊之後，結構(或聯合)本身也要進行對齊，對齊將按照#pragma pack指定的數值和結構(或聯合)最大數據成員長度中，比較小的那個進行。[1]
3、結合1、2可推斷：當#pragma pack的n值等於或超過所有數據成員長度的時候，這個n值的大小將不產生任何效果。
㈦ 數據結構c語言版的 課程設計
一、問題描述：
利用哈夫曼編碼進行信息通信可以大大提高信道利用率，縮簡訊息傳輸時間，降低傳輸成本。但是，這要求在發送端通過一個編碼系統對待傳數據預先編碼，在接收端將傳來的數據進行解碼（復原）。對於雙工信道（即可以雙向傳輸信息的信道），每端都需要一個完整的編／解碼系統。試為這樣的信息收發站寫一個哈夫曼碼的編／解碼系統。
二、基本要求：
1、I：初始化（Initialization），從終端讀入字元集大小n，以及n個字元和n個權值，建立哈夫曼樹，並將它存於文件hfmTree中。
2、E：編碼（Encoding），利用已建好的哈夫曼樹（如不在內存，則從文件hfmTree中讀人），對文件ToBeTran中的正文進行編碼，然後將結果存入文件CodeFile中。
3、D：解碼（Decoding），利用已建好的哈夫曼樹將文件CodeFile中的代碼進行解碼，結果存入文件TextFile中。
4、P：輸出代碼文件（Print），將文件CodeFile以緊湊格式顯示在終端上，每行50個代碼。同時將此字元形式的編碼文件寫入文件CodePrin中。
5、T：輸出哈夫曼樹（TreePrinting），將已在內存中的哈夫曼樹以直觀的方式（樹或凹人表形式）顯示在終端上，同時將此字元形式的哈夫曼樹寫入文件TreePrint中。
三、測試數據：]
用下表給出的字元集和頻度的實際統計數據建立哈夫曼樹，並實現以下報文的編碼和解碼：「THIS PROGRAM IS MY FAVORITE」。
字元 A B C D E F G H I J K L M
頻度 186 64 13 22 32 103 21 15 47 1 5 32 20 20
字元 N O P Q R S T U V W X Y Z
頻度 57 63 15 1 48 51 80 23 8 18 1 16 1
四、實現提示：
1、哈夫曼編碼採用一個字元串數組存儲。
2、用戶界面可以設計為「菜單」方式：顯示上述功能符號，再加上「Q」，表示退出運行Quit。請用戶鍵入一個選擇功能符。此功能執行完畢後再顯示此菜單，直至某次用戶選擇了「Q」為止。
3、在程序的一次執行過程中，第一次執行I、D或C命令之後，哈夫曼樹已經在內存了，不必再讀入。每次執行中不一定執行I命令，因為文件hfmTree可能早已建好。
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
int n;
struct node{
int w;
int flag;
char c;
struct node *plink,*llink,*rlink;
char code[50];
}*num[100],*root;
FILE *fp;
char tmpcode[50];
int t=0;
void main(void)
{
int i;
void settree(void); //建立樹
void code(void); //對文件編碼
void decode(void); // 解碼
void disp(void);
root=(struct node*)malloc(sizeof(struct node));
puts("*******************哈夫曼編/解碼器演示******************************");
while(1){
start:
puts("1. 初始化 2. 編碼 3. 解碼 4.顯示編碼表 5. 退出");
while(scanf("%d",&i)!=1)
{
while(getchar()!='\n')
continue;
puts("輸入錯誤!");
puts("請重新輸入！");
puts("1. 初始化 2. 編碼 3. 解碼 4.顯示編碼表 5. 退出");
}
switch (i)
{
case 1:
settree();
break;
case 2:
code();
break;
case 3:
decode();
break;
case 4:
disp();
break;
case 5:
exit(0);
default:
puts("輸入錯誤！");
puts("請重新輸入！");
goto start;
}
}
}
void settree(void)
{
int i,j,k;
struct node *p1,*p2,*tmp,*p;
void go(struct node *);
void setcode(struct node *);//建立每一個字元的編碼
void printtree(struct node *);
puts("輸入字元集的大小：");
scanf("%d",&n);
while(getchar()!='\n')
continue;
for(i=0;i<n;i++)
{
p=(struct node *)malloc(sizeof(struct node));
puts("請輸入一個字元");
scanf("%c",&p->c);
while(getchar()!='\n')
continue;
puts("請輸入該字元的權值:");
scanf("%d",&p->w);
while(getchar()!='\n')
continue;
p->plink=NULL;
p->rlink=NULL;
p->llink=NULL;
num[i]=p;
}
for(i=0;i<n-1;i++) //（遞增）排序
{
for(j=i+1;j<n;j++)
{
if(num[i]->w>num[j]->w)
{
tmp=num[i];
num[i]=num[j];
num[j]=tmp;
}
}
}
/*******************************開始建立樹***********************/
num[n]=NULL; //結束標志
k=n;
while(num[1]!=NULL)
{
p=(struct node *)malloc(sizeof(struct node));
p1=num[0];
p2=num[1];
p->llink=p1;
p->rlink=p2;
p->plink=NULL;
p1->plink=p;
p2->plink=p;
p->w=p1->w+p2->w;
for(i=1;i<k;i++)
{
num[i]=num[i+1];
}
k--;
num[0]=p;
for(i=0;i<k-1;i++) //排序
{
for(j=i+1;j<k;j++)
{
if(num[i]->w>num[j]->w)
{
tmp=num[i];
num[i]=num[j];
num[j]=tmp;
}
}
}
}
root=num[0];
/*建立完畢*/
/*寫入文件，前序*/
if((fp=fopen("c:\\hfmtree.wxl","wb"))==NULL)
{
puts("文件打開錯誤！");
getchar();
exit(0);
}
setcode(root);
go(root);
fclose(fp);
}
void setcode(struct node *p)
{
if(p->llink==NULL&&p->rlink==NULL)
{
tmpcode[t]='\0';
strcpy(p->code,tmpcode);
}
else
{
tmpcode[t++]='0';
setcode(p->llink);
t--;
tmpcode[t++]='1';
setcode(p->rlink);
t--;
}
}
void go(struct node *p)
{
if(p->llink==NULL&&p->rlink==NULL)
{
fputc('(',fp);
fputc(p->c,fp);
fputs(p->code,fp);
fputc(')',fp);
}
else
{
go(p->llink);
go(p->rlink);
}
}
void code(void)
{
FILE *fp1,*fp2,*fp3;
char ch1,ch2,c;
if((fp1=fopen("c:\\hfmtree.wxl","rb"))==NULL)
{
puts("文件打開錯誤！");
getchar();
exit(0);
}
if((fp2=fopen("c:\\tobetrans.txt","wb"))==NULL)
{
puts("文件打開錯誤！");
getchar();
exit(0);
}
if((fp3=fopen("c:\\codefile.wxl","wb"))==NULL)
{
puts("文件打開錯誤！");
getchar();
exit(0);
}
while((ch1=fgetc(fp2))!=EOF)
{
t=0;
while((ch2=fgetc(fp1))!=EOF)
{
if(ch1==ch2)
{
while((c=fgetc(fp1))!=')')
{
tmpcode[t++]=c;
}
tmpcode[t]='\0';
fputs(tmpcode,fp3);
fputc('@',fp3);
rewind(fp1);
break;
}
}
}
fclose(fp1);
fclose(fp2);
fclose(fp3);
}
void decode(void)
{
FILE *fp1,*fp2,*fp3;
char ch1,ch2,ch3;
char temp_3[20];
char temp_1[20];
int t1,t3;
if((fp1=fopen("c:\\hfmtree.wxl","rb"))==NULL)
{
puts("文件打開錯誤！");
getchar();
exit(0);
}
if((fp2=fopen("c:\\textfile.txt","wb"))==NULL)
{
puts("文件打開錯誤！");
getchar();
exit(0);
}
if((fp3=fopen("c:\\codefile.wxl","rb"))==NULL)
{
puts("文件打開錯誤！");
getchar();
exit(0);
}
while((ch3=fgetc(fp3))!=EOF)
{
t3=0;
while(ch3!='@')
{
temp_3[t3++]=ch3;
ch3=fgetc(fp3);
}
temp_3[t3]='\0';
while((ch1=fgetc(fp1))!=EOF)
{
if(isalpha(ch1))
{
ch2=ch1;
t1=0;
while((ch1=fgetc(fp1))!=')')
{
temp_1[t1++]=ch1;
}
temp_1[t1]='\0';
if(strcmp(temp_1,temp_3)==0)
{
fputc(ch2,fp2);
rewind(fp1);
break;
}
}
}
}
fclose(fp1);
fclose(fp2);
fclose(fp3);
}
void disp(void)
{
FILE *fp1,*fp2;
char ch1,ch2;
char tmp[20];
int t;
if((fp1=fopen("c:\\hfmtree.wxl","rb"))==NULL)
{
puts("文件打開錯誤！");
getchar();
exit(0);
}
if((fp2=fopen("c:\\hfmcode.txt","wb"))==NULL)
{
puts("文件打開錯誤！");
getchar();
exit(0);
}
while((ch1=fgetc(fp1))!=EOF)
{
if(ch1=='(')
{
t=0;
ch1=fgetc(fp1);
ch2=ch1;
while((ch1=fgetc(fp1))!=')')
{
tmp[t++]=ch1;
}
tmp[t]='\0';
printf("%c-----%s\n",ch2,tmp);
fputc(ch2,fp2);
fputc('-',fp2);
fputc('-',fp2);
fputc('-',fp2);
fputs(tmp,fp2);
fputc('\n',fp2);
}
}
fclose(fp1);
fclose(fp2);
}
㈧ 數據結構課程設計c/c++
圖書使用鏈表管理，數據都保存到txt中，
每次都從txt中讀取數據，對讀取的數據進行修改、刪除等操作。
很簡單的，不懂的話，si信我~~~~
㈨ 數據結構課程設計(基於C) 圖書管理系統
頭文件:
============
#ifndef _DATA_STRUCT_H_
#define _DATA_STRUCT_H_
/*圖書結構*/
struct Book
{
unsigned long BookID;/*圖書編號*/
char BookName[512];/*書名*/
char Writer[512];/*作者*/
int CurrentNumber;/*現存量*/
Book *pNext;/*下一個圖書信息*/
};
/*圖書索引結構*/
struct Index
{
unsigned long BookID;/*圖書編號*/
Index *pNext;/*下一個索引指針*/
};
/*借閱信息結構*/
struct Borrow
{
unsigned long BookID;/*借閱圖書編號*/
char BookName[512];/*書名*/
unsigned long StuID;/*圖書證號*/
char ReturnTime[512];/*歸還日期*/
Borrow *pNext;/*下一個借閱信息*/
};
#endif/*_DATA_STRUCT_H_*/
實現文件:
===============
// BookManage.cpp : 定義控制台應用程序的入口點。
//
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "DataStruct.h"
/*
數據結構課程設計(基於C) 圖書管理系統
懸賞分：100 - 離問題結束還有 14 天 23 小時
【問題描述】
圖書管理基本業務活動包括，對一本書的采編入庫、清楚庫存、借閱和歸還等等。試設計一個圖書管理系統，將上述業務活動藉助於計算機系統完成。
【基本要求】
（1） 每種書的登記至少包括書號書名作者現存量總庫存量5項
（2）對書號建立索引表（線性表）以提高查找效率
（3） 系統要實現的操作及其功能定義如下：
1 采編入庫：新購入一種書，經分類和確定數好之後登記到圖書館賬目中去。如果這種書在賬戶中已有，則只將總庫存量增加。
2借閱：如果一本書的現存量大於零，則借出一本，登出借閱者的圖書證號和歸還日期
3歸還：注銷對借閱者的登記，改變該書的現存量
*/
/*獲取輸入字元串*/
void GetInput(char *pInOutStr,int StrLen,bool OnlyGetNumber = false);
/*顯示主菜單 並返回選擇*/
int ShowMainMenu();
/*圖書入庫操作,傳入參數為圖書列表頭指針的指針和索引信息的頭指針的指針,因為在此函數內部可能會改變頭指針的值*/
void PutBookInLib(Book **pHead,Index **pIndex);
/*查詢圖書館庫存,查詢不改變數據,故傳入指針即可*/
void QueryBookLib(Book *pHead);
/*借閱圖書*/
void BorrowBook(Borrow **pBorrow,Book *pHead);
/*查詢借閱*/
void QueryBorrow(Borrow *pBorrow);
/*歸還圖書*/
void ReturnBook(Borrow **pBorrow,Book *pHead);
/*釋放圖書鏈表及索引鏈表及借閱信息鏈表*/
void DeleteBookList(Book **pHead);
void DeleteIndexList(Index **pIndex);
void DeleteBorrowList(Borrow **pBorrow);
int main()
{
/*圖書列表頭指針*/
Book *pBookHead = NULL;
/*圖書索引頭指針*/
Index *pIndexHead = NULL;
/*借閱信息頭指針*/
Borrow *pBorrowHead = NULL;
/*用來保存當前用戶的輸入*/
int ChoosedNum = -1;
while ( true )
{
ChoosedNum = ShowMainMenu();
switch(ChoosedNum)
{
case 0 :/*退出*/
{
return 0;
break;
}
case 1:/*圖書入庫*/
{
PutBookInLib(&pBookHead,&pIndexHead);
break;
}
case 2:/*查詢庫存*/
{
QueryBookLib(pBookHead);
printf("按回車鍵繼續...");
fflush(stdin);
getchar();
system("cls");
break;
}
case 3:/*借閱圖書*/
{
QueryBookLib(pBookHead);
BorrowBook(&pBorrowHead,pBookHead);
break;
}
case 4:/*查詢借閱*/
{
QueryBorrow(pBorrowHead);
printf("按回車鍵繼續...");
fflush(stdin);
getchar();
system("cls");
break;
}
case 5:/*歸還圖書*/
{
QueryBorrow(pBorrowHead);
ReturnBook(&pBorrowHead,pBookHead);
break;
}
}
}
DeleteBookList(&pBookHead);
DeleteIndexList(&pIndexHead);
DeleteBorrowList(&pBorrowHead);
fflush(stdin);
getchar();
return 0;
}
/*獲取輸入字元串*/
void GetInput(char *pInOutStr,int StrLen,bool OnlyGetNumber)
{
memset(pInOutStr,0x0,StrLen);
fflush(stdin);
int Count = 0;
while ( true )
{
char TmpC = 0;
fread(&TmpC,1,1,stdin);
if ( 10 == TmpC )
{
break;
}
if ( OnlyGetNumber && TmpC >= '0' && TmpC <= '9' )
{
pInOutStr[Count] = TmpC;
Count++;
}
else
{
pInOutStr[Count] = TmpC;
Count++;
}
}
}
/*顯示主菜單 並返回選擇*/
int ShowMainMenu()
{
char InPutStr[1024];
NO_INPUT:
printf("\n\n\n");
printf("******************************************************************\n");
printf("* 圖書管理系統 *\n");
printf("******************************************************************\n");
printf("\n");
printf("請選擇:\n");
printf("\t1.圖書入庫\n");
printf("\t2.查詢庫存\n");
printf("\t3.借閱圖書\n");
printf("\t4.查詢借閱\n");
printf("\t5.歸還圖書\n");
printf("\t0.退出\n");
printf("\n");
printf("\t輸入 : ");
GetInput(InPutStr,1024,true);
if ( strlen(InPutStr) < 1 )
{
system("cls");
goto NO_INPUT;
}
return atoi(InPutStr);
}
/*圖書入庫操作*/
void PutBookInLib(Book **pHead,Index **pIndex)
{
Book *pWork = *pHead;
unsigned long BookID = 1;
char InPutStr[1024];
/*先計算處當前入庫圖書的ID號*/
if ( NULL == pWork )
{
BookID = 1;
}
else
{
while ( pWork->pNext != NULL )
{
pWork = pWork->pNext;
}
BookID = pWork->BookID + 1;
}
Book *pTmpNewBook = (Book *)(malloc(sizeof(Book)));
memset(pTmpNewBook,0x0,sizeof(Book));
Index *pTmpIndex = (Index *)(malloc(sizeof(Index)));
memset(pTmpIndex,0x0,sizeof(Index));
pTmpNewBook->BookID = BookID;
pTmpIndex->BookID = BookID;
system("cls");
printf("輸入圖書名稱 : ");
GetInput(InPutStr,1024);
strcpy(pTmpNewBook->BookName,InPutStr);
system("cls");
printf("<<%s>>\n",pTmpNewBook->BookName);
printf("圖書作者 : ");
GetInput(InPutStr,1024);
strcpy(pTmpNewBook->Writer,InPutStr);
system("cls");
printf("<<%s>>\n",pTmpNewBook->BookName);
printf("作者:%s\n",pTmpNewBook->Writer);
printf("入庫數量 : ");
GetInput(InPutStr,1024,true);
pTmpNewBook->CurrentNumber = atoi(InPutStr);
if ( pTmpNewBook->CurrentNumber < 1 )
{
system("cls");
printf("入庫數量錯誤!(按回車鍵繼續...)");
fflush(stdin);
getchar();
system("cls");
return;
}
if ( NULL == *pHead )
{
*pHead = pTmpNewBook;
*pIndex = pTmpIndex;
}
else
{
Book *pWork = *pHead;
while ( pWork != NULL )
{
if ( strcmp(pWork->BookName,pTmpNewBook->BookName) == 0 && strcmp(pWork->Writer,pTmpNewBook->Writer) == 0 )
{
pWork->CurrentNumber += pTmpNewBook->CurrentNumber;
return;
}
pWork = pWork->pNext;
}
pWork = *pHead;
while ( pWork->pNext != NULL )
{
pWork = pWork->pNext;
}
pWork->pNext = pTmpNewBook;
Index *pWork2 = *pIndex;
while ( pWork2->pNext != NULL )
{
pWork2 = pWork2->pNext;
}
pWork2->pNext = pTmpIndex;
}
system("cls");
printf("圖書:<<%s>>\n作者:%s\n入庫數:%d\n\n入庫操作成功!(按回車鍵繼續...)",pTmpNewBook->BookName,pTmpNewBook->Writer,pTmpNewBook->CurrentNumber);
fflush(stdin);
getchar();
system("cls");
}
/*釋放圖書鏈表及索引鏈表*/
void DeleteBookList(Book **pHead)
{
Book *pWork = *pHead;
Book *pNext = pWork;
while ( NULL != pWork )
{
pNext = pWork->pNext;
free(pWork);
pWork = pNext;
}
}
void DeleteIndexList(Index **pIndex)
{
Index *pWork = *pIndex;
Index *pNext = pWork;
while ( NULL != pWork )
{
pNext = pWork->pNext;
free(pWork);
pWork = pNext;
}
}
void DeleteBorrowList(Borrow **pBorrow)
{
Borrow *pWork = *pBorrow;
Borrow *pNext = pWork;
while ( NULL != pWork )
{
pNext = pWork->pNext;
free(pWork);
pWork = pNext;
}
}
/*查詢圖書館庫存,查詢不改變數據,故傳入指針即可*/
void QueryBookLib(Book *pHead)
{
Book *pWork = pHead;
int TotalCount = 0;
while ( NULL != pWork )
{
TotalCount++;
pWork = pWork->pNext;
}
system("cls");
printf("當前庫存共%d種圖書,列表如下:\n=====================================================\n",TotalCount);
pWork = pHead;
while ( NULL != pWork )
{
printf("編號:[%d] 書名:<<%s>> 作者:%s 當前庫存:%d\n",pWork->BookID,pWork->BookName,pWork->Writer,pWork->CurrentNumber);
pWork = pWork->pNext;
}
printf("=====================================================\n",TotalCount);
}
/*借閱圖書*/
void BorrowBook(Borrow **pBorrow,Book *pHead)
{
char InPutStr[1024];
bool HadTheBook = false;
Borrow *pTmpBorrow = (Borrow *)(malloc(sizeof(Borrow)));
memset(pTmpBorrow,0x0,sizeof(Borrow));
printf("請輸入你想借書的編號 : ");
GetInput(InPutStr,1024,true);
pTmpBorrow->BookID = atoi(InPutStr);
Book *pWorkBook = pHead;
while ( pWorkBook != NULL )
{
if ( pWorkBook->BookID == pTmpBorrow->BookID )
{
HadTheBook = true;
break;
}
pWorkBook = pWorkBook->pNext;
}
if ( HadTheBook )
{
if ( pWorkBook->CurrentNumber < 1 )
{
system("cls");
printf("圖書<<%s>>當前無庫存,無法借閱!\n(按回車鍵繼續...)",pWorkBook->BookName);
fflush(stdin);
getchar();
system("cls");
free(pTmpBorrow);
return;
}
}
else
{
system("cls");
printf("圖書編號%d不存在!\n(按回車鍵繼續...)",pTmpBorrow->BookID);
fflush(stdin);
getchar();
system("cls");
free(pTmpBorrow);
return;
}
strcpy(pTmpBorrow->BookName,pWorkBook->BookName);
printf("請輸入借書證號 : ");
GetInput(InPutStr,1024,true);
pTmpBorrow->StuID = atoi(InPutStr);
if ( 0 == pTmpBorrow->StuID )
{
system("cls");
printf("借書證號不存在(借書證號輸入整數)!\n(按回車鍵繼續...)");
fflush(stdin);
getchar();
system("cls");
free(pTmpBorrow);
return;
}
time_t ltime;
struct tm *today;
time(<ime);
ltime += 60 * 60 * 24 * 30;
today = localtime(<ime);
sprintf(pTmpBorrow->ReturnTime,"%d年%d月%d日", today->tm_year+1900,
today->tm_mon+1,
today->tm_mday);
if ( *pBorrow == NULL )
{
*pBorrow = pTmpBorrow;
}
else
{
Borrow *pWork = *pBorrow;
while ( NULL != pWork->pNext )
{
pWork = pWork->pNext;
}
pWork->pNext = pTmpBorrow;
}
pWorkBook->CurrentNumber--;
system("cls");
printf("借書證號:%d\n借閱圖書:<<%s>>\n\n操作成功!(按回車鍵繼續...)",pTmpBorrow->StuID,pTmpBorrow->BookName);
fflush(stdin);
getchar();
system("cls");
}
/*查詢借閱*/
void QueryBorrow(Borrow *pBorrow)
{
Borrow *pWork = pBorrow;
int TotalCount = 0;
while ( NULL != pWork )
{
TotalCount++;
pWork = pWork->pNext;
}
system("cls");
printf("當前借閱信息共%d條,列表如下:\n=====================================================\n",TotalCount);
pWork = pBorrow;
while ( NULL != pWork )
{
printf("借數證號:[%d] 借書名:<<%s>> 圖書編號:%d 歸還日期:%s\n",pWork->StuID,pWork->BookName,pWork->BookID,pWork->ReturnTime);
pWork = pWork->pNext;
}
printf("=====================================================\n",TotalCount);
}
/*歸還圖書*/
void ReturnBook(Borrow **pBorrow,Book *pHead)
{
char InPutStr[1024];
Borrow TmpBorrow;
bool HasFindBorrwo = false;
memset(&TmpBorrow,0x0,sizeof(TmpBorrow));
printf("請輸入借書證號 : ");
GetInput(InPutStr,1024,true);
TmpBorrow.StuID = atoi(InPutStr);
printf("請輸入所還圖書編號 : ");
GetInput(InPutStr,1024,true);
TmpBorrow.BookID = atoi(InPutStr);
Borrow *pWorkBorrow = *pBorrow;
Borrow *pDeletePre = NULL;
while ( NULL != pWorkBorrow )
{
if ( pWorkBorrow->BookID == TmpBorrow.BookID && pWorkBorrow->StuID == TmpBorrow.StuID )
{
HasFindBorrwo = true;
break;
}
pDeletePre = pWorkBorrow;
pWorkBorrow = pWorkBorrow->pNext;
}
if ( ! HasFindBorrwo )
{
system("cls");
printf("你輸入的借書信息不存在!\n(按回車鍵繼續...)");
fflush(stdin);
getchar();
system("cls");
return;
}
if ( NULL == pDeletePre )
{
*pBorrow = pWorkBorrow->pNext;
}
else
{
pDeletePre->pNext = pWorkBorrow->pNext;
}
Book *pWorkBook = pHead;
while ( NULL != pWorkBook )
{
if ( pWorkBook->BookID == pWorkBorrow->BookID )
{
pWorkBook->CurrentNumber ++;
}
pWorkBook = pWorkBook->pNext;
}
system("cls");
printf("借書證號:%d\n歸還圖書:<<%s>>\n\n操作成功!(按回車鍵繼續...)",pWorkBorrow->StuID,pWorkBorrow->BookName);
fflush(stdin);
getchar();
system("cls");
free(pWorkBorrow);
}