c語言數據結構考試題
㈠ c語言題型，數據結構題
#include <stdio.h>
#include <malloc.h>
typedef struct student
{
char name[20];
long num;
char sex;
struct student *pNext;
}Stu, *pStu;
void creatInfo(pStu *stu);
int deletInfo(pStu stu, long numTemp);
void printInfo(pStu stu);
int main(void)
{
long numTemp = 0;
pStu myStu = NULL;
creatInfo(&myStu);
scanf("%ld", &搏御numTemp);
if(1 == deletInfo(myStu, numTemp))
printInfo(myStu);
return 0;
}
void creatInfo(pStu *stu)
{
int n = 1;
pStu pNew = NULL, pTail = NULL;
*stu = (pStu)malloc(sizeof(Stu));
if(*stu == NULL)
return ;
(*stu)->pNext = NULL;
pTail = *stu;
while(n <= 10)
{
pNew = (pStu)malloc(sizeof(Stu));
if(NULL == pNew)
return ;
pNew->pNext = NULL;
scanf("%s", pNew->name);
if('#' == pNew->name[0])
{
free(pNew);
pNew = NULL;
return ;
}
scanf("%ld %c", &pNew->num, &pNew->sex);
pTail->薯行pNext = pNew;
pTail = pNew;
++n;
}
}
int deletInfo(pStu stu, long numTemp)
{
pStu pTail = NULL, pHead = NULL;
pHead = stu;
pTail = stu->pNext;
while(pTail)
{
if(pTail->num == numTemp)
{
pHead->pNext = pTail->pNext;
free(pTail);
pTail = NULL;
return 1;
}
pTail = pTail->pNext;
pHead = pHead->pNext;
}
printf("鏈表中唔基手岩該學生！ ");
return 0;
}
void printInfo(pStu stu)
{
while(stu = stu->pNext)
printf("%s, %d, %c ", stu->name, stu->num, stu->sex);
}
㈡ 急需數據結構C語言版（清華大學出版社）的期末考試試題及答案
《數據結構》期末考試試卷（ A ）
一、 選擇題（每小題2分，共24分）
1．計算機識別、存儲和加工處理的對象被統稱為( A )
A.數據 B.數據元素
C.數據結構 D.數據類型
2．棧和隊列都是（ A ）
A．限制存取位置的線性結構 B．順序存儲的線性結構
C．鏈式存儲的線性結構 D．限制存取位置的非線性結構
3．鏈棧與順序棧相比，比較明顯的優點是( D )
A.插入操作更加方便 B.刪除操作更加方便
C.不會出現下溢的情況 D.不會出現上溢的情況
4．採用兩類不同存儲結構的字元串可分別簡稱為( B )
A.主串和子串 B.順序串和鏈串
C.目標串和模式串 D.變數串和常量串
5． 一個向量第一個元素的存儲地址是100，每個元素的長度為2，則第5個元素的地址是：B
A. 110 B .108
C. 100 D. 120
6．串是一種特殊的線性表，其特殊性體現在：B
A.可以順序存儲 B .數據元素是一個字元
C. 可以鏈接存儲 D. 數據元素可以是多個字元
7．設高度為h的二叉樹上只有度為0和度為2的結點，則此類二叉樹中所包含的結點數至少為： C
A. 2h B .2h-1
C. 2h+1 D. h+1
軟體開發網
8．樹的基本遍歷策略可分為先根遍歷和後根遍歷；二叉樹的基本遍歷策略可分為先序遍歷、中序遍歷和後序遍歷。這里，我們把 由樹轉化得到的二叉樹叫做這棵樹對應的二叉樹。下列結論哪個正確？ A
A. 樹的先根遍歷序列與其對應的二叉樹的先序遍歷序列相同
B .樹的後根遍歷序列與其對應的二叉樹的後序遍歷序列相同
C. 樹的先根遍歷序列與其對應的二叉樹的中序遍歷序列相同
D. 以上都不對
9．一個有n個頂點的無向圖最多有多少邊？C
A. n B .n(n-1)
C. n(n-1)/2 D. 2n
10．在一個圖中，所有頂點的度數之和等於所有邊數的多少倍?C
A. 1/2 B .1
C. 2 D. 4
11．當在二叉排序樹中插入一個新結點時，若樹中不存在與待插入結點的關鍵字相同的結點，且新結點的關鍵字小於根結點的關鍵字，則新結點將成為（ A ）
A．左子樹的葉子結點 B．左子樹的分支結點
C．右子樹的葉子結點 D．右子樹的分支結點
軟體開發網
12．對於哈希函數H(key)=key%13,被稱為同義詞的關鍵字是( D )
A.35和41 B.23和39
C.15和44 D.25和51
二、已知某棵二叉樹的前序遍歷結果為A,B,D,E,G,C,F,H,I,J，其中中序遍歷的結果為D,B,G,E,A,H,F,I,J,C。請畫出二叉的具體結構。（注意要寫出具體步驟）（10分）
原理見課本128頁
三、有圖如下，請寫出從頂點c0出發的深度優先及寬度優先遍歷的結果。(10分)
深度優先；C0-C1-C3-C4-C5-C2
寬度優先：C0-C1-C2-C3-C4-C5
四、有圖如下，按Kruskal演算法求出其最小生成樹。要求寫出完整的步驟。（10分）
原理見課本250頁
五、給定線性表（12，23，45，66，76，88，93，103，166），試寫出在其上進行二分查找關鍵字值12，93，166的過程。並寫出二分查找的演算法。（20分）
0 1 2 3 4 5 6 7 8
12 23 45 66 76 88 93 103 166
過程：
mid=(0+8)/2=4
high=3,low=0 mid=1
high=0,low=0 mid=0（找到12）
high=8,low=5,mid=6（找到93）
high=8,low=7,mid=7
high=8 low=8 mid=8
演算法：見課本84頁上
六、知單鏈表的結點結構為
Data next
下列演算法對帶頭結點的單鏈表L進行簡單選擇排序，使得L中的元素按值從小到大排列。
請在空缺處填入合適的內容，使其成為完整的演算法。 (可用文字說明該演算法的基本思想及執行的過程，10分)
void SelectSort(LinkedList L)
{
LinkedList p,q,min;
DataType rcd;
p= (1) ;
while(p!=NULL) {
min=p;
q=p->next;
while(q!=NULL){
if( (2) )min=q;
q=q->next;
}
if( (3) ){
rcd=p->data;
p->data=min->data;
min->data=rcd;
}
(4) ;
}
}
本題不會。嘿嘿。。。。
七、一個完整的演算法應該具有哪幾個基本性質？分別簡要說明每一性質的含意。(5分)
輸入：
四個基本性質：1.輸入：有零個或多個有外部提供的量作為演算法的輸入
2：輸出：演算法產生至少一個量作為輸出
3.：確定性：組成演算法的每條指令是清晰的，無歧異的。
4.：有限性：演算法中每條指令的執行次數是有限的，執行每條指令的時間也是有限的
八、何謂隊列的"假溢"現象？如何解決？（5分）
隊列的假溢現象是指數組實現的順序隊列中，隊尾指針已到達數組的下表上界產生上溢而隊頭指針之前還有若干 空間閑置的現象。解決的辦法之一是利用循環隊列技術使數組空間的首尾相連。
九、說明並比較文件的各種物理結構。（6分）
㈢ 數據結構（c語言版）題目求答案
3.28
void InitCiQueue(CiQueue&Q)//初始化循環鏈表表示的隊列Q
{
Q=(CiLNode*)malloc(sizeof(CiLNode));
Q->next=Q;
}//InitCiQueue
voidEnCiQueue(CiQueue&Q,int x)//把元素x插入循環列表表示的隊列Q,Q指向隊尾元素，Q->next指向頭結點，Q->next->next指向隊尾元素
{
p=(CiLNode*)malloc(sizeof(CiLNode));
p->data=x;
p->next=Q->next;//直接把p加在Q的後面
Q->next=p;
Q=p;//修改尾指針
}
Status DeCiQueue(CiQueue&Q,int x)//從循環鏈表表示的隊列Q頭部刪除元素x
{
if(Q==Q->next)return INFEASIBLE;//隊列已空
p=Q->next->next;
x=p->data;
Q->next->next=p->next;
free(p);
rturn OK;
}//DeCiqueue
3.31
int Palindrome_Test()
{
InitStack(S);InitQueue(Q);
while((c=getchar())!='@')
{
Push(S,c);EnQueue(Q,c);
}
while(!StackEmpty(S))
{
pop(S,a);DeQueue(Q,b);
if(a!=b)return ERROR;
}
return OK;
}
㈣ c語言編程 數據結構題
參考代碼如下：（手打不易，望採納！）
/*
創建線性順序表其最大長度為20，
在順序表中節點的值為{1，4，6，7，10}，
然後在下標為2的位置插入5列印輸出，
然後刪除值為7的元素並列印輸出。
*/
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
typedefstructnode
{
inta;
structnode*next;
}NODE;
//創建順序鏈表，長度listSize，並初始化
NODE*createlist(NODE*head,intlistSize,intarr[]);
//插入一個節點
intinsertnode(NODE*head,intindex,intval);
//刪除一個節點
intdelnode(NODE*head,intval);
//列印鏈表信息
voidprintlist(NODE*head);
//主函數
intmain(intargc,charconst*argv[])
{
intarr[5]={1,4,6,7,10};
intarrlen;
arrlen=(int)sizeof(arr)/(int)sizeof(int);
NODE*head=NULL;
head=createlist(head,arrlen,arr);
if(NULL==head)
{
printf("Failedtocreatelist.ProgramEixt. ");
return0;
}
printf(" ");
printlist(head);
if(1==insertnode(head,2,5))
{
printf(" Insertedanodebeforeindex2, ");
printlist(head);
}
else
{
printf(" FailedtoInsertanode. ");
}
if(1==delnode(head,7))
啟數{
printf(" Deletedanodewithvalueof7, ");
printlist(head);
}
else
{
printf(" Nonodedeleted:valueisnot悄瞎首exist. ");
}
return0;
}
//創建順序鏈表，長度listSize，並初始化
NODE*createlist(NODE*head,intlistSize,intarr[])
{
head=(NODE*)malloc(sizeof(NODE));
if(NULL==head)
{
printf("Oops!MallocFailed!ProgramExit! ");
returnNULL;
}
NODE*p,*q;
p=head;
for(inti=0;i<listSize;i++)
{
q=(NODE*)malloc(sizeof(NODE));
if(NULL==q)
{
printf("Oops!MallocFailed!ProgramExit! ");
returnNULL;
}
q->next=NULL;
if(i<5)
{
q->a=arr[i];
}
p->next=q;
神笑p=q;
q=q->next;
}
returnhead;
}
//插入一個節點
intinsertnode(NODE*head,intindex,intval)
{
NODE*p=head;
NODE*q=NULL;
inti,count=0;
while(NULL!=p->next)
{
count++;
p=p->next;
}
if(index>count||index<0)
{
printf("Lengthoflistis%d,.[0,%d] ",count,count);
printf("Nothinghasbeenadded. ");
return0;
}
p=head->next;
q=head;
for(i=0;i<=index;i++)
{
if(index==i)
{
NODE*n=(NODE*)malloc(sizeof(NODE));
if(NULL==n)
{
printf("Oops!MallocFailed!ProgramExit! ");
return0;
}
n->a=val;
n->next=p;
q->next=n;
return1;
}
p=p->next;
q=q->next;
}
return0;
}
//刪除一個節點
intdelnode(NODE*head,intval)
{
NODE*p,*q;
p=head->next;
q=head;
while(p!=NULL)
{
if(val==p->a)
{
p=p->next;
q->next=p;
return1;
}
else
{
p=p->next;
q=q->next;
}
}
return0;
}
//列印鏈表信息
voidprintlist(NODE*head)
{
NODE*p;
p=head->next;
inti=0;
if(NULL!=p)
{
printf("PrintListinfoasbelow: ");
while(NULL!=p)
{
printf("NodeatIndex%d,valueis%d. ",i,p->a);
i++;
p=p->next;
}
}
else
{
printf("Listisempty. ");
}
}
Linux環境運行截圖：
以上，如有幫助，煩請點採納，謝謝！
㈤ c語言編程 數據結構題
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
#defineelemTypeint /*單鏈表元素數據類型*/
#defineLNODE_SIZEsizeof(structlNode) /*單鏈表結點空間大小*/
#definestatusint /*狀態型變數*/
#defineOVERFLOW-1 /*內存溢出狀態碼*/
#defineERROR0 /*錯誤狀態碼*/
#defineOK1 /*正確狀態碼*/
/*單鏈表數據結構*/
typedefstructlNode{
elemTypedata;
structlNode*next;
}lNode,*linkList;
/*初始化首帶*/
/*操作結果：構造一個空的單鏈表L*/
voidinitList(linkList*L){
*L=(linkList)malloc(LNODE_SIZE);/*產生頭結點，並使L指向此頭結點*/
if(!*L)/*內存分配失敗*/
exit(OVERFLOW);
(*L)->next=NULL;/*指針域為空*/
}
/*銷毀*/
/*初始條件：單鏈表L已存在。操作結果：銷毀單鏈表L*/
voiddestroyList(linkListL){
linkListp,q;
p=毀芹前L->next;/*p指向第一個結點*/
while(p){/*沒到表尾*/
q=p->next;
free(p);
p=q;
}
free(L);
}
/*判斷單鏈表是否為空*/
/*初始條件：單鏈表L已存在。操作結果：若L為空表，則返回TRUE，否則返回FALSE*/
intlistIsEmpty(linkListL){
returnL->next==NULL;
}
/*尋找指定特徵(compare)元素的位序*/
/*初始條件:線性表L已存在，compare()是數據元素判定函數(滿足為1，否則為0)*/
/*操作結果:返回L中第1個與e滿足關系compare()的數據元素的位序*/
/*若這樣的數據纖清元素不存在，則返回值為0*/
intlocateElem(linkListL,elemTypee,status(*compare)(elemType,elemType)){
inti=0;
linkListp=L->next;
while(p){
i++;
if(compare(p->data,e))/*找到這樣的數據元素*/
returni;
p=p->next;
}
return0;
}
/*數據元素判定*/
/*滿足為1，否則為0*/
intcompare(elemTypedes,elemTypesrc){
returndes==src;
}
/*單鏈表指定位置插入新元素*/
/*操作結果：在帶頭結點的單鏈表L中第i個位置之前插入元素e*/
statuslistInsertNode(linkListL,inti,elemTypee){
intj=0;
linkListp=L,s;
while(p&&j<i-1){/*尋找第i-1個結點*/
p=p->next;
j++;
}
if(!p||j>i-1)/*插入位置不合理：i小於1或者大於表長*/
returnERROR;
/*生成新結點，並插入L中*/
s=(linkList)malloc(LNODE_SIZE);
if(!s)/*內存分配失敗*/
exit(OVERFLOW);
s->data=e;
s->next=p->next;
p->next=s;
returnOK;
}
/*刪除單鏈表指定位置元素*/
/*操作結果：在帶頭結點的單鏈線性表L中，刪除第i個元素，並由e返回其值*/
statuslistDeleteNode(linkListL,inti,elemType*e){
intj=0;
linkListp=L,q;
while(p->next&&j<i-1){/*尋找第i個結點，並令p指向其前驅結點*/
p=p->next;
j++;
}
if(!p->next||j>i-1)/*刪除位置不合理：i小於1或者大於表長*/
returnERROR;
/*刪除並釋放結點*/
q=p->next;
p->next=q->next;
*e=q->data;
free(q);
returnOK;
}
/*列印鏈表內容*/
/*初始條件：單鏈表L已存在。操作結果：當鏈表不為空時，列印鏈表內容並返回OK，否則返回ERROR*/
statusprintList(linkListL){
linkListp=L->next;/*p指向第一個結點*/
if(listIsEmpty(L)){
puts("Thelinklistisempty!");
returnERROR;
}
while(p){
printf("%d ",p->data);
p=p->next;
}
putchar(' ');
returnOK;
}
intmain(void){
linkListL;
elemTypee;
intindex;
/*初始化鏈表*/
initList(&L);
/*插入若干元素*/
listInsertNode(L,1,1);
listInsertNode(L,2,4);
listInsertNode(L,3,6);
listInsertNode(L,4,7);
listInsertNode(L,5,10);
printf("初始鏈表內容： ");
printList(L);
putchar(' ');
/*尋找數據為6的結點位置*/
index=locateElem(L,6,&compare);
printf("數據為6的結點位置： %d ",index);
putchar(' ');
/*在數據為6的結點之前插入數據為5的結點*/
listInsertNode(L,index,5);
printf("當前鏈表內容： ");
printList(L);
destroyList(L);
getch();/*屏幕暫留*/
return0;
}
㈥ c語言數據結構（考題，測試你的能力）－－編寫源代碼
考考自己吧
人不能總能依靠別人.
㈦ 數據結構(C語言)題：循環單鏈表L中,指針P所指結點為尾結點的條件是（ ）。
如果存在空頭結點：
p->next
head
->next
如果不存在空廳型頭結點：
p->next
head
判斷空鏈表的條件是：
head==head->next；
rear==rear->next；
(7)c語言數據結構考試題擴展閱讀：
用尾指針rear表示的單循環鏈表對開始結點a1和終端結點an查找時間都是O(1)。而表的操作常常是在表的首尾位置上進行，因此，實用中多採用尾指針表示單循環鏈表。
在單鏈表中，從一已知結點出發，只能訪問到該結點及其後續結點，無法找到該結點之前的其它結點。而在單循環鏈表中，從任一結點出發都可訪問到表中所有結點，這一優點使某些運算在單循環鏈表上易於扮皮猜實現。握拍
㈧ 求解一道數據結構的題目，用C語言解，考試用的，急，謝謝。
特別說明：
把c1.h,C2-1.H,Bo2-1.cpp,Func2-2.cpp,
Main2-1.cpp 它們分別單獨存為文件，然後把他們放在一拆野喚個文件夾中，最後雙擊Main2-1.cpp。
// c1.h (文件名)
#include<string.h> // 字元串函數頭文件
#include<ctype.h> // 字元函數頭文件
#include<malloc.h> // malloc()等
#include<limits.h> // INT_MAX等
#include<stdio.h> // 標准輸入輸出頭文件，包括EOF(=^Z或F6)，NULL等
#include<stdlib.h> // atoi()，exit()
#include<io.h> // eof()
#include<math.h> // 數學函數頭文件，包括floor()，ceil()，abs()等
#include<sys/timeb.h> // ftime()
#include<stdarg.h> // 提供宏va_start，va_arg和va_end，用於存取變長參數表
// 函數結果狀態代碼。
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
/脊豎/ #define INFEASIBLE -1 沒使用
// #define OVERFLOW -2 因為在math.h中已定義OVERFLOW的值為3，故去掉此行
typedef int Status; // Status是函數的類型，其值是函數結果狀態代碼，如OK等
typedef int Boolean; // Boolean是布爾類型旅凱，其值是TRUE或FALSE，
// c2-1.h 線性表的動態分配順序存儲結構。
#define LIST_INIT_SIZE 10 // 線性表存儲空間的初始分配量
#define LIST_INCREMENT 2 // 線性表存儲空間的分配增量
struct SqList
{ ElemType *elem; // 存儲空間基址
int length; // 當前長度
int listsize; // 當前分配的存儲容量(以sizeof(ElemType)為單位)
};
// bo2-1.cpp 順序存儲的線性表(存儲結構由c2-1.h定義)的基本操作(12個)，包括演算法2.3～2.6
void InitList(SqList &L) // 演算法2.3
{ // 操作結果：構造一個空的順序線性表L
L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem) // 存儲分配失敗
exit(OVERFLOW);
L.length=0; // 空表長度為0
L.listsize=LIST_INIT_SIZE; // 初始存儲容量
}
void DestroyList(SqList &L)
{ // 初始條件：順序線性表L已存在。操作結果：銷毀順序線性表L
free(L.elem); // 釋放L.elem所指的存儲空間
L.elem=NULL; // L.elem不再指向任何存儲單元
L.length=0;
L.listsize=0;
}
void ClearList(SqList &L)
{ // 初始條件：順序線性表L已存在。操作結果：將L重置為空表
L.length=0;
}
Status ListEmpty(SqList L)
{ // 初始條件：順序線性表L已存在。
// 操作結果：若L為空表，則返回TRUE；否則返回FALSE
if(L.length==0)
return TRUE;
else
return FALSE;
}
int ListLength(SqList L)
{ // 初始條件：順序線性表L已存在。操作結果：返回L中數據元素的個數
return L.length;
}
Status GetElem(SqList L,int i,ElemType &e)
{ // 初始條件：順序線性表L已存在，1≤i≤ListLength(L)
// 操作結果：用e返回L中第i個數據元素的值
if(i<1||i>L.length) // i不在表L的范圍之內
return ERROR;
e=*(L.elem+i-1); // 將表L的第i個元素的值賦給e
return OK;
}
int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType))
{ // 初始條件：順序線性表L已存在，compare()是數據元素判定函數(滿足為1，否則為0)
// 操作結果：返回L中第1個與e滿足關系compare()的數據元素的位序。
// 若這樣的數據元素不存在，則返回值為0。演算法2.6
int i=1; // i的初值為第1個元素的位序
ElemType *p=L.elem; // p的初值為第1個元素的存儲位置
while(i<=L.length&&!compare(*p++,e)) // i未超出表的范圍且未找到滿足關系的數據元素
++i; // 繼續向後找
if(i<=L.length) // 找到滿足關系的數據元素
return i; // 返回其位序
else // 未找到滿足關系的數據元素
return 0;
}
Status PriorElem(SqList L,ElemType cur_e,ElemType &pre_e)
{ // 初始條件：順序線性表L已存在
// 操作結果：若cur_e是L的數據元素，且不是第一個，則用pre_e返回它的前驅；
// 否則操作失敗，pre_e無定義
int i=2; // 從第2個元素開始
ElemType *p=L.elem+1; // p指向第2個元素
while(i<=L.length&&*p!=cur_e) // i未超出表的范圍且未找到值為cur_e的元素
{ p++; // p指向下一個元素
i++; // 計數加1
}
if(i>L.length) // 到表結束處還未找到值為cur_e的元素
return ERROR; // 操作失敗
else // 找到值為cur_e的元素，並由p指向其
{ pre_e=*--p; // p指向前一個元素(cur_e的前驅)，將所指元素的值賦給pre_e
return OK; // 操作成功
}
}
Status NextElem(SqList L,ElemType cur_e,ElemType &next_e)
{ // 初始條件：順序線性表L已存在
// 操作結果：若cur_e是L的數據元素，且不是最後一個，則用next_e返回它的後繼，
// 否則操作失敗，next_e無定義
int i=1; // 從第1個元素開始
ElemType *p=L.elem; // p指向第1個元素
while(i<L.length&&*p!=cur_e) // i未到表尾且未找到值為cur_e的元素
{ p++; // p指向下一個元素
i++; // 計數加1
}
if(i==L.length) // 到表尾的前一個元素還未找到值為cur_e的元素
return ERROR; // 操作失敗
else // 找到值為cur_e的元素，並由p指向其
{ next_e=*++p; // p指向下一個元素(cur_e的後繼)，將所指元素的值賦給next _e
return OK; // 操作成功
}
}
Status ListInsert(SqList &L,int i,ElemType e) // 演算法2.4
{ // 初始條件：順序線性表L已存在，1≤i≤ListLength(L)+1
// 操作結果：在L中第i個位置之前插入新的數據元素e，L的長度加1
ElemType *newbase,*q,*p;
if(i<1||i>L.length+1) // i值不合法
return ERROR;
if(L.length==L.listsize) // 當前存儲空間已滿，增加分配，修改
{ newbase=(ElemType*)realloc(L.elem,(L.listsize+LIST_INCREMENT)*sizeof(ElemType));
if(!newbase) // 存儲分配失敗
exit(OVERFLOW);
L.elem=newbase; // 新基址賦給L.elem
L.listsize+=LIST_INCREMENT; // 增加存儲容量
}
q=L.elem+i-1; // q為插入位置
for(p=L.elem+L.length-1;p>=q;--p) // 插入位置及之後的元素右移(由表尾元素開始移)
*(p+1)=*p;
*q=e; // 插入e
++L.length; // 表長增1
return OK;
}
Status ListDelete(SqList &L,int i,ElemType &e) // 演算法2.5
{ // 初始條件：順序線性表L已存在，1≤i≤ListLength(L)
// 操作結果：刪除L的第i個數據元素，並用e返回其值，L的長度減1
ElemType *p,*q;
if(i<1||i>L.length) // i值不合法
return ERROR;
p=L.elem+i-1; // p為被刪除元素的位置
e=*p; // 被刪除元素的值賦給e
q=L.elem+L.length-1; // q為表尾元素的位置
for(++p;p<=q;++p) // 被刪除元素之後的元素左移(由被刪除元素的後繼元素開始移)
*(p-1)=*p;
L.length--; // 表長減1
return OK;
}
void ListTraverse(SqList L,void(*visit)(ElemType&))
{ // 初始條件：順序線性表L已存在
// 操作結果：依次對L的每個數據元素調用函數visit()
// visit()的形參加'&'，表明可通過調用visit()改變元素的值
ElemType *p=L.elem; // p指向第1個元素
int i;
for(i=1;i<=L.length;i++) // 從表L的第1個元素到最後1個元素
visit(*p++); // 對每個數據元素調用visit()
printf("\n");
}
// func2-2.cpp 幾個常用的函數
Status equal(ElemType c1,ElemType c2)
{ // 判斷是否相等的函數
if(c1==c2)
return TRUE;
else
return FALSE;
}
int comp(ElemType a,ElemType b)
{ // 根據a<、=或>b，分別返回-1、0或1
if(a==b)
return 0;
else
return (a-b)/abs(a-b);
}
void print(ElemType c)
{ // 以十進制整型的格式輸出元素的值
printf("%d ",c);
}
void print1(ElemType &c)
{ // 以十進制整型的格式輸出元素的值(設c為引用類型)
printf("%d ",c);
}
void print2(ElemType c)
{ // 以字元型的格式輸出元素的值
printf("%c ",c);
}
// main2-1.cpp 檢驗bo2-1.cpp的主程序
#include"c1.h"
typedef int ElemType; // 定義ElemType為整型
#include"c2-1.h" // 線性表的順序存儲結構
#include"bo2-1.cpp" // 線性表順序存儲結構的基本操作
#include"func2-2.cpp" // 包括equal()、comp()、print()、print1()和print2()函數
Status sq(ElemType c1,ElemType c2)
{ // 數據元素判定函數(平方關系)，LocateElem()調用的函數
if(c1==c2*c2)
return TRUE;
else
return FALSE;
}
void dbl(ElemType &c)
{ // ListTraverse()調用的另一函數(元素值加倍)
c*=2;
}
void main()
{
SqList L;
ElemType e,e0;
Status i;
int j,k;
InitList(L); // 初始化線性表L
printf("初始化L後，L.length=%d，L.listsize=%d，L.elem=%u\n",L.length,
L.listsize,L.elem);
for(j=1;j<=5;j++)
i=ListInsert(L,1,j); // 在L的表頭插入j
printf("在L的表頭依次插入1～5後，*L.elem=");
for(j=1;j<=5;j++)
printf("%d ",*(L.elem+j-1)); // 依次輸出表L中的元素
printf("\n調用ListTraverse()函數，依次輸出表L中的元素：");
ListTraverse(L,print1); // 依次對表L中的元素調用print1()函數(輸出元素的值)
i=ListEmpty(L); // 檢測表L是否空
printf("L.length=%d(改變)，L.listsize=%d(不變)，",L.length,L.listsize);
printf("L.elem=%u(不變)，L是否空？i=%d(1:是 0:否)\n",L.elem,i);
ClearList(L); // 清空表L
i=ListEmpty(L); // 再次檢測表L是否空
printf("清空L後，L.length=%d，L.listsize=%d，",L.length,L.listsize);
printf("L.elem=%u，L是否空？i=%d(1:是 0:否)\n",L.elem,i);
for(j=1;j<=10;j++)
ListInsert(L,j,j); // 在L的表尾插入j
printf("在L的表尾依次插入1～10後，L=");
ListTraverse(L,print1); // 依次輸出表L中的元素
printf("L.length=%d，L.listsize=%d，L.elem=%u\n",L.length,L.listsize,L.elem);
ListInsert(L,1,0); // 在L的表頭插入0，增加存儲空間
printf("在L的表頭插入0後，L.length=%d(改變)，L.listsize=%d(改變)，"
"L.elem=%u(有可能改變)\n",L.length,L.listsize,L.elem);
GetElem(L,5,e); // 將表L中的第5個元素的值賦給e
printf("第5個元素的值為%d\n",e);
for(j=10;j<=11;j++)
{ k=LocateElem(L,j,equal); // 查找表L中與j相等的元素，並將其位序賦給k
if(k) // k不為0，表明有符合條件的元素
printf("第%d個元素的值為%d，",k,j);
else // k為0，沒有符合條件的元素
printf("沒有值為%d的元素\n",j);
}
for(j=3;j<=4;j++) // 測試2個數據
{ k=LocateElem(L,j,sq); // 查找表L中與j的平方相等的元素，並將其位序賦給k
if(k) // k不為0，表明有符合條件的元素
printf("第%d個元素的值為%d的平方，",k,j);
else // k為0，沒有符合條件的元素
printf("沒有值為%d的平方的元素\n",j);
}
for(j=1;j<=2;j++) // 測試頭2個數據
{ GetElem(L,j,e0); // 將表L中的第j個元素的值賦給e0
i=PriorElem(L,e0,e); // 求e0的前驅，如成功，將值賦給e
if(i==ERROR) // 操作失敗
printf("元素%d無前驅，",e0);
else // 操作成功
printf("元素%d的前驅為%d\n",e0,e);
}
for(j=ListLength(L)-1;j<=ListLength(L);j++) // 最後2個數據
{ GetElem(L,j,e0); // 將表L中的第j個元素的值賦給e0
i=NextElem(L,e0,e); // 求e0的後繼，如成功，將值賦給e
if(i==ERROR) // 操作失敗
printf("元素%d無後繼\n",e0);
else // 操作成功
printf("元素%d的後繼為%d，",e0,e);
}
k=ListLength(L); // k為表長
for(j=k+1;j>=k;j--)
{ i=ListDelete(L,j,e); // 刪除第j個數據
if(i==ERROR) // 表中不存在第j個數據
printf("刪除第%d個元素失敗。",j);
else // 表中存在第j個數據，刪除成功，其值賦給e
printf("刪除第%d個元素成功，其值為%d",j,e);
}
ListTraverse(L,dbl); // 依次對元素調用dbl()，元素值乘2
printf("L的元素值加倍後，L=");
ListTraverse(L,print1); // 依次輸出表L中的元素
DestroyList(L); // 銷毀表L
printf("銷毀L後，L.length=%d，L.listsize=%d，L.elem=%u\n",L.length,
L.listsize,L.elem);
}
㈨ 高分求數據結構（C語言）高手做題！（200懸賞+50追加+20採納=270分）
1．數據結構在計算機中的表示稱為數據的（ B ）。
A）存儲結構 B）抽象結構 C）順序結構 D）邏輯結構
12．在下列序列中，不是線性表的是（ D ）。
A）('a','b','c') B）('AB','CD') C）('a',true,'c') D）(a,b,c,d)
13．線性鏈表中各鏈結點之間的地址（ D ）。
A）必須連續 B）部分地址必須連續 C）不一定連續 D）連續與否無所謂
14．如某鏈表中最常用的操作是在最後一個結點後插入一個結點和刪除最後一個結點，則（ D ）存儲方式最節省運行時間。
A）單鏈表 B）帶頭結點的單鏈表 C）單循環鏈表 D）帶頭結點的雙循環鏈表
26．從一個具有頭結點的單鏈表中查找數據元素值為x的結點時，在查找成功的情況下，平均比較次數是（ B）。
A）n B）n/2 C）(n-1)/2 D）(n+1)/2
27．對於長度為n的順序線性表進行刪除元素操作，如刪除每個元素的概率相同，則刪除一個元素移動元素的平均次數是（ B ）。
A）n/2 B）(n-1)/2 C）(n+1)/2 D）Dn
38．串是（ B ）。
A）不少於一個字元的序列 B）有限個字元的序列
C）不少於一個字母的序列 D）任意個字母的序列
40．當矩陣非零元素的位置或個數經常變動時，採用（ C ）存儲結構更為恰當。
A）順序表 B）三元組表 C）十字鏈表 D）廣義表
41．一個三對角矩陣An×n已按行壓縮存儲到一維數組B中，則B的長度至少為（C）。
A）3n+1 B）3n C）3n-1 D）3n-2
42．廣義表((a,b),(c,d))的表尾是( A )。
A）(c,d) B）((c,d)) C）(d) D）d
44．設一棵二叉樹中沒有度為1的結點，已知葉子結點數為n，此樹的結點數為（ B ）。
A）2n+2 B）2n+1 C）2n D）2n-1
45．設二叉樹中有n2個度為2的結點，n1個度為1的結點，n0個葉子結點，則此二叉樹中空指針域個數為（ D ）。
A）n0+n1+n2 B）n2+n1+2n0 C）2n2+n1 D）2n0+n1
48． A、B兩個結點可以構成（ C ）棵不等價的二叉樹。
A）2 B）3 C）4 D）5
49．設哈夫曼樹的葉結點數為n，則它的結點總數為（ A ）。
A）2n-1 B）2n C）2n+1 D）不確定
50．採用鄰接表存儲的圖按深度優先搜索方法進行遍歷的演算法類似於二叉樹的（D ）。
A）先序遍歷 B）中序遍歷 C）後序遍歷 D）層次遍歷
59．快速排序執行一遍之後，已經到位的元素個數是（ A ）。
A）1 B）3 C） D）
60．在下列演算法中，操作時間不隨文件的初始狀態變化的排序演算法是（ B ）。
A）堆排序 B）折半插入排序 C）基數排序 D）快速排序
61．數據表中有10000個元素，如果僅需求出其中最大的10個元素，則採用（ D )
A）快速排序 B）希爾排序 C）堆排序 D）直接選擇排序
62．快速排序在最壞情況下時間復雜度是O(n2)，比（ D ）的性能差。
A）堆排序 B）起泡排序 C）選擇排序 D）直接插入排序
63．下列排序演算法中一趟結束後未必能選出一個元素放在其最終位置上的演算法是（A）。
A）快速排序 B）冒泡排序 C）樹形選擇排序 D）歸並排序
64．若需在O(nlogn)的時間內完成對數組的排序，且要求排序是穩定的，則可選擇的排序方法是（ B ）。
A）快速排序 B）堆排序 C）歸並排序 D）直接插入排序
65．初始文件中有兩個關鍵字相同的記錄，通過不穩定的排序方法排序後，（D）。
A）使得領先關系不發生變化 B）領先關系一定發生變化
C）兩個位置都不會發生變化 D）領先關系可能發生變化
66．如果只想得到1000個元素組成的序列中第5個最小元素之前的部分排序的序列，用（ B ）方法平均時間最少。
A）起泡排序 B）簡單選擇排序 C）Shell排序 D）堆排序問題補充：
77．一組記錄的排序碼為(48,24,18,53,16,26,40)，採用冒泡排序法進行排序，則第一趟排序需要進行記錄交換的次數是（C）。
A）3 B）4 C）5 D）6
78．在下列排序方式中，關鍵碼比較次數與記錄的初始排列無關的是（D）。
A）直接選擇排序 B）冒泡排序 C）堆排序 D）歸並排序
79．倒排文件的最大優點是（ B）。
A）便於進行文件的歸並 B）有利於文件的插入與刪除
C）能大大地提高主關鍵字的查找速度 D）能大大地提高次關鍵字的查找速度
80．文件中可使用的數據的最小單位是（B ）。
A）記錄 B）字元 C）數據項 D）數據元素
81．ISAM文件和VASM文件屬於（C ）。
A）索引非順序文件 B）索引順序文件 C）順序文件 D）散列文件
A）先序遍歷 B）中序遍歷 C）後序遍歷 D）按層遍歷
181．使用散列函數hashf(x)=x MOD 11，把一個整數值轉換成散列表下標，現要把數據 1、13、12、34、38、33、27、22插入到散列表中。
（1）使用線性探查再散列法來構造散列表並同時列出每個數據的比較次數。
（2）使用鏈地址法來構造散列
㈩ 系列數據結構（C語言題），感激不盡
1、234
2、*+A+BCDE*FG -+*A-BD/H+DE/S*NT *-AC+BD/-EF+GH
3、1/（n-1）
4、3.3
5、禪悄集合，線性，樹形滾襲好和圖
6、bceda
15、
void SelectSort(int a[],int n)
{
int l=n,k,x;
for(int i=1;i<=l-1;++i)
{
k=i;
for(int j=i+1;j<=l;++j)
{
if(a[j]<大鉛a[k]) k=j;
if(k!=j)
{ x=a[i];r[i]=r[k];r[k]=x; }
}
}
}
16、這個就不知道了 自己好好想想啊