⑴ 求高手用C寫一段線性表的順序存儲（包括創建，插入，刪除和查找），不用很復雜，最簡單的就可以了！
#include<malloc.h> /* malloc()等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<stdlib.h> /* atoi() */
#include<io.h> /* eof() */
/* 函數結果狀態代碼 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status; /* Status是函數的類型,其值是函數結果狀態代碼，如OK等 */
typedef int Boolean; /* Boolean是布爾類型,其值是TRUE或FALSE */
typedef int ElemType;
#define LIST_INIT_SIZE 10 /* 線性表存儲空間的初始分配量 */
#define LISTINCREMENT 2 /* 線性表存儲空間的分配增量 */
typedef struct
{
ElemType *elem; /* 存儲空間基址 */
int length; /* 當前長度 */
int listsize; /* 當前分配的存儲容量(以sizeof(ElemType)為單位) */
}sqlist;
Status InitList(SqList *L) //創建
{ /* 操作結果：構造一個空的順序線性表 */
(*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!(*L).elem)
exit(OVERFLOW); /* 存儲分配失敗 */
(*L).length=0; /* 空表長度為0 */
(*L).listsize=LIST_INIT_SIZE; /* 初始存儲容量 */
return OK;
}
Status DestroyList(SqList *L) //銷毀
{ /* 初始條件：順序線性表L已存在。操作結果：銷毀順序線性表L */
free((*L).elem);
(*L).elem=NULL;
(*L).length=0;
(*L).listsize=0;
return OK;
}
Status ClearList(SqList *L) //置空
{ /* 初始條件：順序線性表L已存在。操作結果：將L重置為空表 */
(*L).length=0;
return OK;
}
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)
exit(ERROR);
*e=*(L.elem+i-1);
return OK;
}
int LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType)) //查找
{ /* 初始條件：順序線性表L已存在，compare()是數據元素判定函數(滿足為1,否則為0) */
/* 操作結果：返回L中第1個與e滿足關系compare()的數據元素的位序。 */
/* 若這樣的數據元素不存在，則返回值為0。*/
ElemType *p;
int i=1; /* i的初值為第1個元素的位序 */
p=L.elem; /* p的初值為第1個元素的存儲位置 */
while(i<=L.length&&!compare(*p++,e))
++i;
if(i<=L.length)
return i;
else
return 0;
}
Status ListInsert(SqList *L,int i,ElemType e) //插入
{ /* 初始條件：順序線性表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+LISTINCREMENT)*sizeof(ElemType));
if(!newbase)
exit(OVERFLOW); /* 存儲分配失敗 */
(*L).elem=newbase; /* 新基址 */
(*L).listsize+=LISTINCREMENT; /* 增加存儲容量 */
}
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) //刪除
{ /* 初始條件：順序線性表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; /* 表尾元素的位置 */
for(++p;p<=q;++p) /* 被刪除元素之後的元素左移 */
*(p-1)=*p;
(*L).length--; /* 表長減1 */
return OK;
}
void main()//主函數自己寫
{
}
//想學好編程數據結構還是要多練練的，平時自己也試著寫一下
⑵ 數據結構 線性表 用c語言
#define MAXSIZE 100 //表中元素的最大個數
typedef int ElemType；//元素類型
typedef struct list{
ElemType elem[MAXSIZE];//靜態線性表
int length; //表的實際長度
}SqList;//順序表的類型名
⑶ 線性表的基本操作c語言實現
代碼如下：
頭文件：
2_1.h
#ifndef _2_1_H
#define _2_1_H
typedef void SeqList;
typedef void SeqListNode;
//創建線性表
SeqList * SeqList_Create(int capacity);
//銷毀線性表
void SeqList_DesTroy(SeqList * list);
void SeqList_Clear(SeqList* list);
int SeqList_Length(SeqList* list);
int SeqList_Capacity(SeqList* list);
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);
SeqListNode* SeqList_Get(SeqList* list, int pos);
SeqListNode* SeqList_Delete(SeqList* list, int pos);
#endif
源文件：
// 順序線性表.cpp : 定義控制台應用程序的入口點。
//
#include "stdafx.h"
#include <malloc.h>
#include <stdlib.h>
#include "2_1.h"
typedef unsigned int TSeqListNode;
typedef struct {
int len; //長度
int capacity;//總長度
TSeqListNode * node;//每個節點的指針
} TSeqList;
int main()
{
SeqList* list = SeqList_Create(5);//創建線性表
int i = 6;//賦值6個變數，已超過線性表最大值 5
int j = 1;
int k = 2;
int x = 3;
int y = 4;
int z = 5;
int index = 0;
SeqList_Insert(list, &i, 7); //將這6個變數插入線性表中
SeqList_Insert(list, &j, 0);
SeqList_Insert(list, &k, 0);
SeqList_Insert(list, &x, 0);
SeqList_Insert(list, &y, 0);
SeqList_Insert(list, &z, 0);
//遍歷
for(index=0; index<SeqList_Length(list); index++)
{
int* p = (int*)SeqList_Get(list, index);
printf("%d ", *p);
}
printf(" ");
//刪除操作
while( SeqList_Length(list) > 0 )
{
int* p = (int*)SeqList_Delete(list, 0);
printf("刪除了： %d ", *p);
}
SeqList_Clear(list);
SeqList_DesTroy(list);
system("pause");
return 0;
}
//創建線性表
SeqList * SeqList_Create(int capacity)
{
TSeqList* ret = NULL ;
if(capacity >= 0)
{
ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity); //為線性表分配空間，包含結 //構體和節點的總大小
}
if(NULL != ret)
{
ret->len = 0;
ret->capacity = capacity;
ret->node = (TSeqListNode*)(ret + 1);//將節點指向上述分配到的空間的後部分
}
return ret;
}
//銷毀
void SeqList_DesTroy(SeqList * list)
{
free(list);
}
//清空
void SeqList_Clear(SeqList* list)
{
TSeqList * ret = (TSeqList*)list;
if(NULL != ret)
{
ret->len = 0;
}
}
//獲得線性表的長度
int SeqList_Length(SeqList* list)
{
TSeqList * ret = (TSeqList*)list;
int len = -1;
if(NULL != ret)
{
len = ret->len;
}
return len;
}
//線性表的總長度
int SeqList_Capacity(SeqList* list)
{
TSeqList * ret = (TSeqList*)list;
int capacity = -1;
if(NULL != ret)
{
ret->capacity = capacity;
}
return capacity;
}
//插入
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
TSeqList * sList = (TSeqList*)list;
int i,ret = -1;
if((sList != NULL) &&(pos >= 0) && sList->capacity >= sList->len+1)
{
if(pos >= sList->len)
{
pos = sList->len;
}
for(i = sList->len; i > pos; i--)
{
sList->node[i] = sList->node[i-1];
}
sList->node[i] = (TSeqListNode)node;
++sList->len;
ret = 1;
}
return ret;
}
//獲得指定位置的節點
SeqListNode* SeqList_Get(SeqList* list, int pos)
{
TSeqList * sList = (TSeqList*)list;
TSeqListNode* node = NULL;
if(NULL != sList && pos>=0 && pos < sList->len)
{
node = (TSeqListNode*)sList->node[pos];
}
return node;
}
//刪除
SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
TSeqList * sList = (TSeqList*)list;
SeqListNode * node = SeqList_Get( list, pos);
int i;
if(sList != NULL && pos >= 0 && pos< sList->len)
{
for( i=pos+1; i<sList->len; i++)
{
sList->node[i-1] = sList->node[i];
}
sList->len--;
}
return node;
}
演示：
資料拓展：
線性表是最基本、最簡單、也是最常用的一種數據結構。
線性表中數據元素之間的關系是一對一的關系，即除了第一個和最後一個數據元素之外，其它數據元素都是首尾相接的（注意，這句話只適用大部分線性表，而不是全部。比如，循環鏈表邏輯層次上也是一種線性表（存儲層次上屬於鏈式存儲），但是把最後一個數據元素的尾指針指向了首位結點）。
我們說「線性」和「非線性」，只在邏輯層次上討論，而不考慮存儲層次，所以雙向鏈表和循環鏈表依舊是線性表。
在數據結構邏輯層次上細分，線性表可分為一般線性表和受限線性表。一般線性表也就是我們通常所說的「線性表」，可以自由的刪除或添加結點。受限線性表主要包括棧和隊列，受限表示對結點的操作受限制。
線性表的邏輯結構簡單，便於實現和操作。因此，線性表這種數據結構在實際應用中是廣泛採用的一種數據結構。
⑷ 數據結構c語言版 使用線性表的順序儲存結構定義(靜態)實現線性表的初
直接上源碼吧。
/*線性表功能的實現*/
#include<stdio.h>
//定義常量 存儲空間的初始化分配
#define MAXSIZE 20
#define TRUE 1
#define ERROR -1
#define FALSE 0
#define OK 1
//用typedef定義類型
typedef int Status;
typedef int ElemType;
//定義一個結構體類型
typedef struct{
ElemType data[MAXSIZE];
int length;
} SqList;
//初始化函數
Status initList(SqList *L){
L->length = 0;
return OK;
}
//返回線性表的長度
Status getListLength(SqList L){
return L.length;
}
//線性表為空返回true,否則返回false
Status listEmpty(SqList L){
if(L.length == 0){
return TRUE;
}
return FALSE;
}
//線性表清空,長度為0
Status clearList(SqList *L){
L->length = 0;
return OK;
}
//獲取指定的元素的值,返回下標為i - 1的元素,賦值給e
Status getElem(SqList L, int i, ElemType *e){
//判斷元素位置是否合法[i]
if(i > L.length || i < 1){
printf("查找的位置不正確 \n");
return ERROR;
}
//判斷線性表是否為空
if(listEmpty(L)){
return ERROR;
}
*e = L.data[i - 1];
return OK;
}
//在線性表中查找指定的e相等的元素,如果查找成功,返回該元素的下標,否則返回ERROR
Status locateElem(SqList L, ElemType e){
int i;
for(i = 0; i < L.length - 1; i++){
if(L.data[i] == e){
return i;
}
}
printf("沒有查找到元素 %d 指定的下標\n",e);
return ERROR;
}
//自動創建 MAXSIZE 個元素,並賦值為0
Status createList(SqList *L){
int i;
for(i = 0; i < 10; i++){
L->data[i] = 0;
}
L->length = 10;
return OK;
}
//在線性表中第i個位置前插入新元素e
Status listInsert(SqList *L, int i, ElemType e){
//判斷長度是否可以允許插入新的數據
if(L->length >= MAXSIZE){
printf("空間已滿,不能再插入數據\n");
return FALSE;
}
//判斷插入位置的合法性
if(i < 1 || i > L->length) {
printf("插入位置不正確\n");
return FALSE;
}
int j;
for(j = L->length - 1; j >= i; j--){
L->data[j] = L->data[j - 1];
}
L->data[i - 1] = e;
L->length++;
return TRUE;
}
//刪除線性表中第i個元素,成功後表長減1,用e返回其值
Status deleteList(SqList *L, int i, ElemType *e){
//判斷線性表是否為空
if(listEmpty(*L)){
return ERROR;
}
//判斷刪除的位置是否合法
if(i < 1 || i > L->length) {
printf("刪除位置不合法\n");
return ERROR;
}
*e = L->data[i - 1];
for(i; i < L->length; i++){
L->data[i - 1] = L->data[i];
}
L->length--;
return TRUE;
}
//遍歷線性表
Status listTraverse(SqList L){
int i;
for(i = 0; i < L.length; i++){
printf("%d ",L.data[i]);
}
printf("\n");
return OK;
}
//主程序
int main(void){
SqList L;
ElemType e;
initList(&L);
int option = 1;
int input_number;
int res;
ElemType input_value;
printf("\n1.遍歷線性表 \n2.創建線性表 \n3.清空線性表 \n4.線性表插入 \n5.查找表中元素 \n6.判斷元素是否在表中 \n7.刪除某個元素 \n8.線性表長度\n9.線性表是否為空\n0.退出 \n請選擇你的操作：\n");
while(option){
scanf("%d",&option);
switch(option){
case 0:
return OK;
break;
case 1:
listTraverse(L);
break;
case 2:
createList(&L);
listTraverse(L);
break;
case 3:
clearList(&L);
listTraverse(L);
break;
case 4:
printf("請輸入插入的位置:");
scanf("%d",&input_number);
printf("\n");
printf("請輸入插入的值:");
scanf("%d",&input_value);
printf("\n");
listInsert(&L, input_number, input_value);
listTraverse(L);
break;
case 5:
printf("請輸入要查找的位置:");
scanf("%d",&input_number);
printf("\n");
getElem(L, input_number, &input_value);
printf("第%d個元素的值為:%d\n",input_number,input_value);
break;
case 6:
printf("請輸入要查找的元素:");
scanf("%d",&input_value);
printf("\n");
res = locateElem(L, input_value);
if(res != ERROR){
printf("值為%d在表中的第%d個位置\n",input_value,input_number);
}
break;
case 7:
printf("要刪除第幾個元素？");
scanf("%d",&input_number);
printf("\n");
deleteList(&L, input_number, &input_value);
listTraverse(L);
break;
case 8:
res = getListLength(L);
printf("線性表的長度是:%d",res);
break;
case 9:
res = listEmpty(L);
if(res){
printf("線性表的是空的");
}else{
printf("線性表的是不是空的");
}
break;
}
}
return OK;
}
線性表的特徵是:
1. 元素之間是有序的,如果元素存在多個,則第一個元素無前驅,最後一個無後繼,其它元素都有且只有一個前驅和後繼.
2. 元素個數是有限的. 當n=0是,稱為空表
線性表實現方式有兩種,分別是順序存儲結構和鏈式存儲結構,它們之間各有優缺點 . 根據需求的不同進行選擇不同的存儲結構.
線性表存儲結構的優缺點
優點:
1. 無須為表中元素之前的邏輯關系而增加額外的存儲空間
2. 可以快速的存取表中的任一位置的元素
缺點:
1. 插入和刪除操作需要移動大量元素
2. 當線性表長度變化較大時,難以確定存儲空間的容量.
3. 造成存儲空間的」碎片」.
⑸ 誰能給一個簡單的線性表操作C語言完整程序
1、線性表有兩種：
typedefstruct{
ElemType*elem;
intlength;
intlistsize;
}SqList;//順序表
voidInitList_Sq(SqList&l){
l.elem=newElemType[LIST_INIT_SIZE];
l.length=0;
l.listsize=LIST_INIT_SIZE;
}//初始化順序表
然後SqListLa;
InitList_Sq(La);
就可以
typedefstructLnode{
intdata;
structLnode*next;
}Lnode,*LinkList;//線性鏈表
//單鏈表可以有效的利用主存的碎片,它的數據域不是連續的
2、常式：
#include"stdio.h"
#include<malloc.h>
typedefcharElemType;
typedefstructLNode
{ElemTypedata;
structLNode*next;
}LinkList;
voidCreatListF(LinkList*&L,ElemTypea[],intn)//頭插法建表
{
LinkList*s;inti;
L=(LinkList*)malloc(sizeof(LinkList));
L->next=NULL;
for(i=0;i<n;i++)
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data=a[i];
s->next=L->next;
L->next=s;
}
}
voidCreateListR(LinkList*&L,ElemTypea[],intn)//尾插法建表
{
LinkList*s,*r;inti;
L=(LinkList*)malloc(sizeof(LinkList));
r=L;
for(i=0;i<n;i++)
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
voidInitList(LinkList*&L)//初始化線性表
{
L=(LinkList*)malloc(sizeof(LinkList));
L->next=NULL;
}
voidDestroyList(LinkList*&L)//銷毀線性表
{
LinkList*p=L,*q=p->next;
while(q!=NULL)
{
free(p);
p=q;
q=p->next;
}
free(p);
}
intListEmpty(LinkList*L)//判斷線性表是否為空
{
return(L->next==NULL);
}
intListLength(LinkList*L)//求線性表的長度
{
LinkList*p=L;intn=0;
while(p->next!=NULL)
{
n++;p=p->next;
}
return(n);
}
voidDispList(LinkList*L)//輸出線性表
{
LinkList*p=L->next;
while(p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
}
intGetElem(LinkList*L,inti,ElemType&e)//求線性表中某個數據元素值
{
intj=0;
LinkList*p=L;
while(j<i&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)
return0;
else
{
e=p->data;return1;
}
}
intLocateElem(LinkList*L,ElemTypee)//按元素值查找
{
LinkList*p=L->next;
inti=1;
while(p!=NULL&&p->data!=e)
{
p=p->next;i++;
}
if(p==NULL)return(0);
elsereturn(i);
}
intListInsert(LinkList*&L,inti,ElemTypee)//插入數據元素
{
intj=0;
LinkList*p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)return0;
else
{
s=(LinkList*)malloc(sizeof(LinkList));
s->data=e;s->next=p->next;p->next=s;
return1;
}
}
intListDelete(LinkList*&L,inti,ElemType&e)//刪除數據元素
{
intj=0;
LinkList*p=L,*q;
while(j<i-1&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)
return0;
else
{
q=p->next;
if(q==NULL)return0;
e=q->data;
p->next=q->next;
free(q);
return1;
}
}
intmain()
{
ElemTypee,a[5]={'a','b','c','d','e'};
LinkList*h;
InitList(h);//初始化順序表h
CreateListR(h,&a[0],5);//依次採用尾插入法插入a，b，c，d，e元素
printf("單鏈表為：");
DispList(h);printf(" ");//輸出順序表h
printf("該單鏈表的長度為：");
printf("%d",ListLength(h));printf(" ");//輸出順序表h的長度
if(ListEmpty(h))printf("該單鏈表為空。 ");
elseprintf("該單鏈表不為空。 ");//判斷順序表h是否為空
GetElem(h,3,e);printf("該單鏈表的第3個元素為：");
printf("%c",e);printf(" ");//輸出順序表h的第3個元素
printf("該單鏈表中a的位置為：");
printf("%d",LocateElem(h,'a'));printf(" ");//輸出元素'a'的位置
ListInsert(h,4,'f');//在第4個元素位置插入'f'素
printf("在第4個元素位置上插入'f'後單鏈表為：");
DispList(h);printf(" ");//輸出順序表h
ListDelete(h,3,e);//刪除L的第3個元素
printf("刪除第3個元素後單鏈表為：");
DispList(h);printf(" ");//輸出順序表h
DestroyList(h);//釋放順序表h
return0;
}
⑹ 求一個簡單的線性表（鏈式的，用C語言）
#include<stdio.h>
#include <stdlib.h>
#include <math.h>
/************************************************************************/
/* 常量定義 */
/************************************************************************/
#define ElemType int
#define Status int
#define TRUE 1
#define OK 1
#define FALSE 0
#define ERROR -1
/************************************************************************/
/* 線性表的單鏈表存儲結構*/
/************************************************************************/
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode, *LinkList;
//////////////////////////////////////////////////////////////////////////
//
// 帶有頭結點的單鏈表的基本操作(13個)
//
//////////////////////////////////////////////////////////////////////////
/************************************************************************/
/* 操作結果：構造一個空的線性表L */
/************************************************************************/
void InitList(LinkList *L)
{
*L = (LinkList)malloc(sizeof(struct LNode)); /* 產生頭結點，並使L指向此頭結點 */
if( !*L ) /* 存儲分配失敗 */
exit(OVERFLOW);
(*L)->next = NULL; /* 指針域為空 */
}
/************************************************************************/
/* 初始條件：線性表L已存在。*/
/* 操作結果：銷毀線性表L */
/************************************************************************/
void DestroyList(LinkList *L)
{
LinkList q;
while(*L)
{
q = (*L)->next;
free(*L);
*L=q;
}
}
/************************************************************************/
/* 初始條件：線性表L已存在。*/
/* 操作結果：將L重置為空表 */
/************************************************************************/
void ClearList(LinkList L) /* 不改變L */
{
LinkList p, q;
p = L->next; /* p指向第一個結點 */
while(p) /* 沒到表尾 */
{
q = p->next;
free(p);
p = q;
}
L->next = NULL; /* 頭結點指針域為空 */
}
/************************************************************************/
/* 初始條件：線性表L已存在。*/
/* 操作結果：若L為空表，則返回TRUE，否則返回FALSE */
/************************************************************************/
Status ListEmpty(LinkList L)
{
/* 非空 */
return (L->next) ? FALSE : TRUE;
}
/************************************************************************/
/* 初始條件：線性表L已存在。操作結果：返回L中數據元素個數 */
/************************************************************************/
int ListLength(LinkList L)
{
int i = 0;
LinkList p = L->next; /* p指向第一個結點 */
while(p) /* 沒到表尾 */
{
i++;
p = p->next;
}
return i;
}
/************************************************************************/
/* L為帶頭結點的單鏈表的頭指針。*/
/* 當第i個元素存在時，其值賦給e並返回OK，否則返回ERROR */
/************************************************************************/
Status GetElem(LinkList L, int i, ElemType *e) /* 演算法2.8 */
{
int j = 1; /* j為計數器 */
LinkList p = L->next; /* p指向第一個結點 */
while(p && j < i) /* 順指針向後查找，直到p指向第i個元素或p為空 */
{
p = p->next;
j++;
}
if( !p || j > i) return ERROR; /* 第i個元素不存在 */
*e = p->data; /* 取第i個元素 */
return OK;
}
/************************************************************************/
/* 初始條件: 線性表L已存在，compare()是數據元素判定函數(滿足為1，否則為0)*/
/* 操作結果: 返回L中第1個與e滿足關系compare()的數據元素的位序。 */
/* 若這樣的數據元素不存在，則返回值為0 */
/************************************************************************/
int LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
int i = 0;
LinkList p = L->next;
while(p)
{
i++;
if(compare(p->data,e)) /* 找到這樣的數據元素 */
return i;
p=p->next;
}
return 0;
}
/************************************************************************/
/* 初始條件: 線性表L已存在 */
/* 操作結果: 若cur_e是L的數據元素，且不是第一個，則用pre_e返回它的前驅 */
/* 返回OK；否則操作失敗，pre_e無定義，返回INFEASIBLE */
/************************************************************************/
Status PriorElem(LinkList L, ElemType cur_e, ElemType *pre_e)
{
LinkList q, p = L->next; /* p指向第一個結點 */
while(p->next) /* p所指結點有後繼 */
{
q = p->next; /* q為p的後繼 */
if(q->data == cur_e)
{
*pre_e = p->data;
return OK;
}
p = q; /* p向後移 */
}
return ERROR;
}
/*************************************************************************/
/* 初始條件：線性表L已存在 */
/* 操作結果：若cur_e是L的數據元素，且不是最後一個，則用next_e返回它的後繼*/
/* 返回OK; 否則操作失敗，next_e無定義，返回INFEASIBLE */
/*************************************************************************/
Status NextElem(LinkList L, ElemType cur_e, ElemType *next_e)
{
LinkList p = L->next; /* p指向第一個結點 */
while(p->next) /* p所指結點有後繼 */
{
if(p->data == cur_e)
{
*next_e = p->next->data;
return OK;
}
p = p->next;
}
return ERROR;
}
/************************************************************************/
/* 在帶頭結點的單鏈線性表L中第i個位置之前插入元素e */
/************************************************************************/
Status ListInsert(LinkList L, int i, ElemType e)
{
int j = 0;
LinkList p = L, s;
while( p && j < i-1) /* 尋找第i-1個結點 */
{
p = p->next;
j++;
}
if( !p|| j > i-1) return ERROR;/* i小於1或者大於表長 */
s = (LinkList)malloc(sizeof(struct LNode)); /* 生成新結點 */
s->data = e; /* 插入L中 */
s->next = p->next;
p->next = s;
return OK;
}
/************************************************************************/
/* 在帶頭結點的單鏈線性表L中，刪除第i個元素，並由e返回其值 */
/************************************************************************/
Status ListDelete(LinkList L, int i, ElemType *e)
{
int j = 0;
LinkList p = L, q;
while(p->next && j < i-1) /* 尋找第i個結點，並令p指向其前嶇 */
{
p = p->next;
j++;
}
if( !p->next || j > i-1) /* 刪除位置不合理 */
return ERROR;
q = p->next; /* 刪除並釋放結點 */
p->next = q->next;
*e = q->data;
free(q);
return OK;
}
/************************************************************************/
/* 初始條件：線性表L已存在。操作結果：依次對L的每個數據元素調用函數vi() */
/************************************************************************/
void ListTraverse(LinkList L, void(*vi)(ElemType))
{
LinkList p = L->next;
while(p)
{
vi(p->data);
p = p->next;
}
printf("\n");
}
/************************************************************************/
/* 初始條件：線性表L已存在。列印鏈表的data域 */
/************************************************************************/
void ListPrint(LinkList L)
{
LinkList p = L->next;
while(p)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
void printInt(int data)
{
printf("%d ", data);
}
/************************************************************************/
/* 插入排序 */
/************************************************************************/
void ListSort(LinkList L)
{
LinkList first, p, q; //為原鏈表剩下用於直接插入排序的節點頭指針
LinkList t; //臨時指針變數：插入節點
//原鏈表剩下用於直接插入排序的節點鏈表
first = L->next;
//只含有一個節點的鏈表的有序鏈表
L->next = NULL;
//遍歷剩下無序的鏈表
while (first != NULL)
{
//無序節點在有序鏈表中找插入的位置
for (t = first, q = L; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);
//退出for循環，就是找到了插入的位置
first = first->next;
p->next = t;
//完成插入動作
t->next = q;
}
}
//排序，指針交換法
void ListSort1(LinkList L)
{
LinkList head = L->next;//head指向除頭結點以外的鏈表
LinkList pre_p; //p的前驅結點
LinkList pre_q; //q的前驅結點
LinkList min; //最小的結點
LinkList p, q, temp;
for(p = head; p->next; pre_p = min, p = min->next)
{
//找出最小的結點
for(min = p, q = p; q->next; q = q->next)
{
if(q->next->data < min->data)
{
pre_q = q;
min = q->next;
}
}
//如果最小是自己 就不需要交換
if(min == p) continue;
//如果p是指向head的結點，則鏈表直接指向min
if(p == head)
L->next = min;
else
pre_p->next = min;
temp = min->next;
if(p->next == min)
{
min->next = p;
p->next = temp;
}
else
{
min->next = p->next;
pre_q->next = p;
p->next = temp;
}
}
}
//排序，數據選擇法排序
void ListSort2(LinkList L)
{
LinkList head = L->next;//head指向除頭結點以外的鏈表
LinkList min; //最小的結點
LinkList p, q; //遍歷鏈表指針
int temp;
for (p = head; p->next; p = p->next)
{
//在p指針後的鏈表選取最小的結點
for (min = p, q = p->next; q; q = q->next)
{
if (q->data < min->data)
min = q;
}
//兩者結點值不相等，數據交換
if (min->data != p->data)
{
temp = min->data;
min->data = p->data;
p->data = temp;
}
}
}
void ListSort3(LinkList L)
{
LinkList first; //指向鏈表L第一個結點，除頭結點
LinkList pre; //指向first的前驅結點
LinkList last; //指向first指向排好序的最後一個結點
LinkList rest; //指向未排好序的第一個結點，即鏈表第二個結點
LinkList curr; //指向當前結點
first = L->next; //指向第一個結點
if(first == NULL) return;
pre = L ; //pre指向first的前驅結點
last = first; //last指向排好序的最後一個結點
rest = first->next; //指向剩餘的結點
first->next = NULL; //first斷鏈
while (rest) //當餘下的結點不為空
{
//保存當前結點
curr = rest;
//取下一個結點
rest = rest->next;
//當結點小於第一個結點，則鏈接到first前面
if( curr->data < first->data )
{
pre->next = curr;
curr->next = first;
pre = curr;
}
//當前結點大於第一個結點，則鏈接到last後
else if(curr->data > first->data)
{
curr->next = last->next;
last->next = curr;
last = curr;
}
//當前結點與第一個結點相等，則鏈接到first後面
else
{
curr->next = first->next;
first->next = curr;
}
}
}
void main()
{
LinkList L;
InitList(&L);
ListInsert(L, 1, 6);
ListInsert(L, 2, 3);
ListInsert(L, 3, 67);
ListInsert(L, 4, 2);
ListInsert(L, 5, 15);
ListInsert(L, 6, 13);
ListInsert(L, 7, 10);
ListInsert(L, 8, 6);
ListInsert(L, 9, 4);
ListSort3(L);
ListTraverse(L, printInt);
}
⑺ 急求助高手大蝦：C語言數據結構順序線性表的實現
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<iostream.h>
#define LIST_INIT_SIZE 50
#define LISTINCREMENT 10
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define CANCEL 0
typedef struct{
int *elem;
int length;
int listsize;
}sqlist;
int compare(int X,int Y)
{if(X==Y)
return X;
else return FALSE;
}//compare的關系判斷
void visit(int &y)
{
y=2*y;
cout<<y<<" ";
}//將y值增加為原來的2倍
int initlist(sqlist &L)
{
L.elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
if(!L.elem)
return ERROR;
else
L.length=0;
L.listsize=LIST_INIT_SIZE;
return OK;
}//構造一個空的線性表L
int destroylist(sqlist &L)
{
free(L.elem);
return OK;
}//銷毀線性表L
int clearlist(sqlist &L)
{
L.length=0;
return OK;
}//將L重置為空表
int listempty(sqlist L)
{
if (0==L.length)
return TRUE;
else
return FALSE;
}//求當前表L是否為空
int listlength(sqlist L)
{
return L.length;
}//求當前線性表L的長度
int getelem(sqlist L,int i,int &e)
{
if(i<1||i>L.length)
exit(ERROR);
e=*(L.elem+i-1);
return OK;
}//用e返回L中第i個數據元素的值
int locateelem(sqlist L,int e,int(*compare)(int x1,int x2))
{
int i=1,j=0,*p;
p=L.elem;
while(i<=L.length&&!j)
{
j=compare(*p++,e);
++i;
}
if(i<=L.length)
return i-1;
else
return FALSE;
}//求L中第一個與e滿足關系compare()的數據元素的位序，若不存在則返回0
int priorelem(sqlist L,int cur_e,int &pre_e)
{
int i=2,*p;
p=L.elem+1;
while(i<=L.length&&(*p++)!=cur_e)
i++;
if (i>L.length)
return FALSE;
else
{
pre_e=*p-2;
return OK;
}
}//若cur_e是L的數據元素，且不是第一個，則用pre_e返回它的前驅，否則操作失敗，pre_e無定義
int nextelem(sqlist L,int cur_e,int &next_e)
{
int i=1,*p;
p=L.elem;
while(i<L.length&&(*p++)!=cur_e)
i++;
if (i>=L.length)
return FALSE;
else
{
next_e=*p;
return OK;
}
}//若cur_e是L的數據元素，且不是最後一個，則用next_e返回它的後繼，否則操作失敗，next_e無定義
int listinsert(sqlist &L,int i,int e)
{
int *newbase,*p,*q;
if((i<1)||(i>L.length+1))
return ERROR;
if (L.length>=L.listsize)
{
newbase=(int *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));
if(!newbase)
{
exit(0);
}
L.elem=newbase;
L.listsize=L.listsize+LISTINCREMENT;
}
q=L.elem+i-1;
for(p=L.elem+L.length-1;p>=q;--p)
*(p+1)=*p;
*q=e;
++L.length;
return OK;
}//在線性表L中第i個位置插入元素e
int listdelete(sqlist &L,int i,int &e)
{
int *p,*q;
if(i<1||i>L.length)
return ERROR;
else
{
p=L.elem+i-1;
e=*p;
q=L.elem+L.length-1;
for(++p;p<=q;++p)
{
*(p-1)=*p;
}
L.length--;
return OK;
}
}//將線性表中的第i個元素刪除並返回其值
int listtraverse(sqlist L,void(*visit)(int &p))
{
int i=1,*p;
p=L.elem;
while(i<=L.length)
{
visit(*p);
p++;
i++;
}
return OK;
}//依次對L中的每一個元素調用函數visit(),一旦visit()失敗，則操作失敗
void main()
{sqlist L;
int i,j,k,b,n,e,m,a,cur_e,pre_e,next_e;
initlist(L);
cout<<"初始化後的基值地址:"<<L.elem<<" L.length=:"<<L.length<<" L.listsize=:"<<L.listsize<<endl;
cout<<"新建一順序表."<<endl;
cout<<"當前表是否為空表"<<listempty(L)<<endl;
cout<<"定義該線性表長度:"<<endl;
cin>>a;
cout<<"分別輸入線性表的各個元素,按ENTER"<<endl;
for(k=1;k<=a;k++){
cin>>j;
i=listinsert(L,k,j);}
for(b=1;b<=10;b++)
cout<<L.elem[b-1]<<endl;
listlength(L);
cout<<"當前表長:"<<L.length<<endl;
cout<<"輸入要取的數的位置n(n<=10)"<<endl;
cin>>n;
getelem(L,n,e);
cout<<L.elem[n-1]<<endl;
cout<<"與該數相等的的一個數的位序為:"<<locateelem(L,e,compare)<<endl;
cout<<"輸入要取前驅的數的位置m(<=10)"<<endl;
cin>>m;
getelem(L,m,cur_e);
if(priorelem(L,cur_e,pre_e))
cout<<"cur_e的前驅為:"<<pre_e<<endl;
else
cout<<"該元素沒前驅"<<endl;
nextelem(L,cur_e,next_e);
if(nextelem(L,cur_e,next_e))
cout<<"cur_e的後繼為:"<<next_e<<endl;
else
cout<<"該元素沒後繼"<<endl;
cout<<"輸入要刪元素的位序m(<=10)"<<endl;
cin>>m;
listdelete(L,m,e);
cout<<"被刪的元素為:"<<e<<endl;
cout<<"刪除元素後表長為"<<L.length<<endl;
listtraverse(L,visit);
cout<<"置為空表"<<clearlist(L)<<endl;
cout<<"銷毀線性表"<<destroylist(L)<<endl;
}
⑻ 用c語言寫一個程序，初始化一個線性表。跪求
#include <stdio.h>
#include <malloc.h>
# define MaxSize 50
typedef struct{
ElemType data[MaxSize];//存放順序表元素
int length;//存放順序表長度
}SqList;//順序表類型定義
//建立順序表
void CreateList(SqList *&L,ElemType a[],int n){
int i;
for(i=0;i<n;i++){
L->data [i]=a[i];
}
L->length =n;
}
//順序表基本運算演算法
//初始化線性表InitList（L）
void InitList(SqList *&L){
L=(SqList *)malloc(sizeof(SqList));//分配存放線性表的空間
L->length =0;
}//本演算法的時間復雜度為O(1)
//銷毀線性表
void DestroyList(SqList *&L){
free(L);
}//本演算法的時間復雜度為O(1)
//判斷線性表是否為空
int ListEmpty(SqList *L){
return (L->length ==0);
}//本演算法的時間復雜度為O(1)
//求線性表的長度
int ListLength(SqList *L){
return (L->length);
}//本演算法的時間復雜度為O(1)
//輸出線性表
void DispList(SqList *L)
{
int i;
if(ListEmpty(L)) return;
for(i=0;i<L->length;i++){
printf(nn,L->data[i]);
}
printf("\n");
}//本演算法的時間復雜度為O(L->length)
//求線性表中某個數據的元素值
int GetElem(SqList *L,int i,ElemType &e)
{
if(i<1||i>L->length)
return 0;
e=L->data[i-1];//這兒體現了數組的優點，可以直接通過下標訪問
return 1;
}//本演算法的時間復雜度為O(1)
//按元素的值查找
int LocateElem(SqList *L,ElemType e){
int i=0;
while(i<L->length && L->data[i]!=e)i++;
if(i>=L->length)
return 0;
else
return i+1;
}//本演算法中基本運算為while循環中的i++語句，故時間復雜度為O(L->length)
//插入數據元素
int ListInsert(SqList *&L,int i,ElemType e){
int j;
if(i<1 || i>L->length+1)
return 0;//參數錯誤，返回0
i--;//將順序邏輯位序變為物理位序
for(j=L->length;j>i;j--){
L->data[j]=L->data[j-1];//將data[i]及後面的元素後移一個位置
}
L->data[i]=e;//插入元素e
L->length++;//增加長度
return 1;
}//本演算法的平均時間復雜度為O(n)
//刪除數據元素
int ListDelete(SqList *&L,int i,ElemType &e){
int j;
if(i<1 || i>L->length)
return 0;
i--;//將順序邏輯位序變為物理位序
e=L->data[i];
for(j=i;j<L->length-1;j++){
L->data[j]=L->data[j+1];//將data[i]之後的元素前移一個位置，這就是數組中的刪除思想
}
L->length--;
return 1;
}//本演算法的平均時間復雜度為O(n)
⑼ 用C語言實現線性表的順序存儲（創建，插入，刪除和查找）
//C++課程設計---學生成績管理系統
#include <stdio.h>
#include <string.h>
#include <iostream.h>
#include <stdlib.h>
#include <windows.h>
typedef struct studentinfo //結構體定義
{
int num;//學號
char name[64];//姓名
int sex;//性別，1為男性，0為女性
float math;//數學
float english;//英語
float politic;//政治
float chinese;//語文
float total;//總成績
struct studentinfo *next;
}STUDENT;
#define FILENAME "D:\\1.txt"
//定義默認的資料庫文件
#define DELAYTIME 1500
//顯示信息，延時
void create_menu();
STUDENT * new_student();
STUDENT* create_linkbyfile(char *);
STUDENT *del_info(STUDENT *);
int save_info(char *,STUDENT *,int);
int find_infile_printf(char *);
int pri_whole_link(STUDENT *);
STUDENT* printf_sort(STUDENT *);
void free_link(STUDENT *);
void main() //主函數
{
create_menu();
}
STUDENT * reverse(STUDENT *head)
//功能：鏈表反轉順序
//參數：head鏈表頭結點指針
{
STUDENT *ptemp,*p1;
if(head==NULL)
{
return 0;
}
p1=head;//p1使之永遠指向排好序的第一個結點，初值為head，head使之永遠是已經排好序的最後一個結點
while(head->next!=NULL)//本次循環使ptemp排好序
{
ptemp=head->next;//ptemp指向未排好序的第一個結點
head->next=ptemp->next;//
ptemp->next=p1;//ptemp也排好序了，ptemp變成排好序的第一個結點了
p1=ptemp;//再次讓p1成為第一個排好序的結點
}
return p1;//頭結點為第一個結點
}
void create_menu()
//功能：輸出功能菜單，提供人-機介面
{
char menu_Num;
STUDENT *head=NULL;
char ch;
char file_name[256];
while(1)
{
system("cls");
cout<<"\t\t學生成績管理系統\n";
cout<<"##########################################\n";
cout<<"#\t\t 1.新增學生信息\t\t #\n";
cout<<"#\t\t 2.載入資料庫\t\t #\n";
cout<<"#\t\t 3.刪除學生信息\t\t #\n";
cout<<"#\t\t 4.保存學生信息\t\t #\n";
cout<<"#\t\t 5.資料庫查詢\t\t #\n";
cout<<"#\t\t 6.原序輸出\t\t #\n";
cout<<"#\t\t 7.排序輸出\t\t #\n";
cout<<"#\t\t 8.退出\t\t\t #\n";
cout<<"##########################################\n";
cout<<"請輸入操作編號：";
cin>>menu_Num;
switch (menu_Num)
{
case '1':
free_link(head);//釋放鏈表空間
head=new_student();//新增學生信息
break;
case '2':
free_link(head);//釋放鏈表空間
cout<<"請輸入要載入的資料庫文件的路徑"<<endl;
cin>>file_name;
head=create_linkbyfile(file_name);//讀取數據文件
if(head!=NULL)
{
cout<<"資料庫"<<file_name<<"已載入"<<endl;
Sleep(DELAYTIME);
}
break;
case '3':
del_info(head);//刪除學生信息
break;
case '4'://保存學生信息
if (head==NULL)
{
cout<<"請先生成學生信息"<<endl;
Sleep(DELAYTIME);
}
else
{
cout<<"想將學生信息保存到哪個資料庫文件？";
cin>>file_name;
cout<<"請選擇保存方式：0追加到文件末尾 1覆蓋文件\n";
cin>>menu_Num;
if(save_info(file_name,head,menu_Num-'0')==0)//0表示追加，1表示覆蓋
{
cout<<"信息保存失敗\n";
}
else
{
cout<<"數據已保存到"<<file_name<<endl;
Sleep(DELAYTIME);
}
}
break;
case '5':
find_infile_printf(FILENAME);//資料庫查詢
break;
case '6'://原序輸出信息
pri_whole_link(head);
cout<<"返回主菜單？ Y/N\t";
do
{
cin>>ch;
}while(ch!='Y'&&ch!='y');
break;
case '7'://排序輸出信息
do
{
if((head=printf_sort(head))==NULL)
{
cout<<"資料庫未載入"<<endl;
Sleep(DELAYTIME);
break;
}
else
{
cout<<"選擇其他方式排序？ Y/N\t";
cin>>ch;
}
}while(ch=='Y'||ch=='y');
break;
case '8':
free_link(head);//釋放鏈表空間
exit(0);
break;
default:
cout<<"輸入有誤！請重新輸入！"<<endl;
Sleep(DELAYTIME);
break;
}
}
}
STUDENT * new_student()
//功能：創建學生信息（通過鏈表）
//返回值：頭結點指針
{
STUDENT *pnew,*p,*head;
float *pfloat;
char ch;
head=NULL;
do
{
system("cls");
pnew=(STUDENT *)malloc(sizeof(STUDENT)*1);
cout<<"請輸入學生的學號(0表示取消)： ";
cin>>pnew->num;
if(0>=pnew->num)
{
break;
}
cout<<"請輸入學生的姓名：";
cin>>pnew->name;
while(1)
{
cout<<"請輸入學生的性別：0/1\t";
cin>>pnew->sex;
if(pnew->sex&&pnew->sex-1)
{
cout<<"性別輸入錯誤，0表示女性，1表示男性，請重新輸入"<<endl;
}
else
{
break;
}
}
cout<<"請依次輸入學生的數學、英語、政治、語文成績："<<endl;
for(pnew->total=0,pfloat=&pnew->math;pfloat<&pnew->math+4;)
{
cin>>*pfloat;
if(*pfloat<0||*pfloat>150)
{
cout<<"成績輸入錯誤，只能為0~150"<<endl;
}
else
{
pnew->total+=*pfloat;
pfloat++;
}
}
if(head==NULL)
{
head=pnew;
}
else
{
p->next=pnew;
}
p=pnew;
pnew->next=NULL;
cout<<"##########################該學生信息已生成#########################\n";
cout<<"建立另一個學生的信息？ Y/N\t";
cin>>ch;
}while(ch=='Y'||ch=='y');
return head;
}
STUDENT* create_linkbyfile(char *filename)
//功能：讀取文件，創建鏈表
//參數：如果filename不為空，則打開該文件，如果filename為空，要求輸入文件位置
//創建的鏈表的所有結點的next全部修改，指向物理地址上的下一個結點
{
system("cls");
FILE *fp;
STUDENT *head,*ptemp,*pnew;
head=NULL;//初始化head為空
if(filename==NULL)//若filename為空，要求輸入文件絕對地址
{
char file_name[256];
cout<<"請輸入資料庫文件的路徑："<<endl;
cin>>file_name;
if(NULL==(fp=fopen(file_name,"rb")))
{
cout<<"資料庫連接失敗\n";
return 0;
}
}
else
{
if(NULL==(fp=fopen(filename,"rb")))
{
cout<<"資料庫連接失敗\n";
return 0;
}
}
for(ptemp=NULL;;)
{
pnew=(STUDENT *)malloc(sizeof(STUDENT)*1);
if(fread(pnew,sizeof(STUDENT),1,fp)!=NULL)
{
if(ptemp!=NULL)
{
ptemp->next=pnew;
}
else
{
head=pnew;
}
ptemp=pnew;
}
else
{
if(ptemp!=NULL)
{
ptemp->next=NULL;
}
else
{
head=NULL;
}
free(pnew);
break;
}
}
fclose(fp);
return head;
}
STUDENT *del_info(STUDENT *head)
//根據學號，刪除鏈表的結點
{
system("cls");
STUDENT *p1,*p2;
int num;
if (head==NULL)
{
cout<<"資料庫未載入"<<endl;
Sleep(DELAYTIME);
return 0;
}
cout<<"請輸入要刪除學生的學號：";
cin>>num;
for(p1=head;p1!=NULL;)
{
if(p1->num==num)//找到
{
if(p1==head)//要刪除的結點是頭結點
{
head=p1->next;
}
else
{
p2->next=p1->next;
}
cout<<"成功刪除！！";
}
p2=p1;
p1=p1->next;
}
return head;
}
int save_info(char *filename,STUDENT *head,int flag)
//功能：將鏈表按Binary寫入文件末尾
//參數：
//1.filename文件名，絕對地址
//2.head指向鏈表的頭結點
//3.flag 0追加或1覆蓋數據
//返回值：失敗則返回0
{
system("cls");
FILE *fp;
STUDENT *p;
char openmethod[8];
if(flag==0)
{
strcpy(openmethod,"ab+");//追加
}
else
{
strcpy(openmethod,"w");//覆蓋
}
if(NULL==(fp=fopen(filename,openmethod)))//
{
cout<<"資料庫連接失敗"<<endl;
Sleep(DELAYTIME);
return 0;
}
else
{
for(p=head;p;p=p->next)
{
if((fwrite(p,sizeof(STUDENT),1,fp))==NULL)
{
cout<<"資料庫創建失敗"<<endl;
return 0;
}
}
}
fclose(fp);
return 1;
}
int find_infile_printf(char *filename)
//功能：根據學號和姓名來查詢某個學生
//參數：filename資料庫文件
//返回值：失敗返回0
//直接搜索文件，缺點是速度慢
//也可先根據文件創建鏈表，再搜索鏈表，缺點是如果文件較大，佔用內存多
{
system("cls");
FILE *fp;
STUDENT stu;
int num;
char stu_name[64];
char ch;
if(filename==NULL)
{
return 0;
}
do
{
memset(stu_name,0,sizeof(stu_name));
cout<<"查詢學號或查詢姓名？ 1查詢學號 0查詢姓名";
//flag=1根據學號來查詢，flag=0根據姓名來查詢
cin>>num;
if(num==1)
{
cout<<"輸入要查詢的學號：";
cin>>num;
cout<<"正在為您查詢學號為"<<num<<"的學生……"<<endl;
}
else if(num==0)
{
cout<<"輸入要查詢的姓名：";
cin>>stu_name;
cout<<"正在為您查詢姓名為"<<stu_name<<"的學生……"<<endl;
}
else
{
cout<<"輸入有誤"<<endl;
return 0;
}
if(NULL==(fp=fopen(filename,"rw")))
{
cout<<"資料庫連接失敗\n";
return 0;
}
else
{
while(fread(&stu,sizeof(STUDENT),1,fp)!=NULL)
{
if(strcmp(stu.name,stu_name)==0||stu.num==num)
{
cout<<"學號\t姓名\t性別\t數學\t英語\t政治\t語文\t總成績\n";
//輸出該學生的所有信息
cout<<stu.num<<"\t"<<stu.name<<"\t"<<stu.sex<<"\t"<<stu.math<<"\t"<<stu.english<<"\t"<<stu.politic<<"\t"<<stu.chinese<<"\t"<<stu.total<<endl;
//不加break;可支持多個相同數據的索引
}
}
}
cout<<"##########################查詢完畢#########################\n";
cout<<"查詢另一個學生的信息？ Y/N\t";
cin>>ch;
}while(ch=='Y'||ch=='y');
fclose(fp);
return 1;
}
int pri_whole_link(STUDENT *head)
//功能：顯示整條鏈表的學生信息
//參數：head 頭結點指針，如果head為空，返回空
{
system("cls");
STUDENT* p;
if (head==NULL)
{
cout<<"資料庫未載入"<<endl;
Sleep(DELAYTIME);
return 0;
}
cout<<"學號\t姓名\t性別\t數學\t英語\t政治\t語文\t總成績\n";
for(p=head;p;p=p->next)
{
cout<<p->num<<"\t"<<p->name<<"\t"<<p->sex<<"\t"<<p->math<<"\t"<<p->english<<"\t"<<p->politic<<"\t"<<p->chinese<<"\t"<<p->total<<endl;
}
return 1;
}
STUDENT* printf_sort(STUDENT *head)
//功能：根據學號|某科目成績|總成績對鏈表進行排序，然後輸出
//參數：head鏈表頭指針，如果head為空，返回空
//返回值：返回新的鏈表的頭結點指針
{
system("cls");
STUDENT *p1,*p2,*ptemp,*pfinished=NULL;
char num;
char flag;
if (head==NULL)
{
return 0;
}
cout<<"選擇排序依據 0.數學成績1.英語成績2.政治成績3.語文成績4.總成績\n";
while(1)
{
cin>>num;
if(num>'4'||num<'0')
{
cout<<"輸入有誤，請重新輸入 0~4"<<endl;
}
else
{
break;
}
}
cout<<"升序/降序輸出？ 0.降序1.升序";
while(1)
{
cin>>flag;
if(flag>'1'||flag<'0')
{
cout<<"輸入有誤，請重新輸入 0~1"<<endl;
}
else
{
break;
}
}
for(p1=head;p1->next!=pfinished;)//對鏈表進行從大到小排序（這里用冒泡法）
//p1使之總是指向頭結點，pfinished使之總是指向已排序好的最前面的結點
//ptemp作為中介，保存p2的上一個結點
{
for(p2=p1;p2->next!=pfinished;)
{
if(*(&(p2->math)+num-'0')<*(&(p2->next->math)+num-'0'))//p2的值小於p2->next的值，交換 ptemp p2 p2->next
{
if(p2==p1)//頭結點要交換
{
p1=p2->next;
p2->next=p1->next;
p1->next=p2;
ptemp=p1;
}
else
{
ptemp->next=p2->next;
ptemp=p2->next;
p2->next=ptemp->next;
ptemp->next=p2;
}
}
else//不需要交換，則p2、ptemp前進1位
{
ptemp=p2;
p2=p2->next;
}
}
pfinished=p2;
}
if(flag=='1')
{
p1=reverse(p1);
}
pri_whole_link(p1);
cout<<"##########################信息顯示完畢#########################\n";
return p1;
}
void free_link(STUDENT *head)
//釋放鏈表空間，如果head，什麼都不做
{
STUDENT *p1,*p2;
for(p1=head;p1;p1=p2)
{
p2=p1->next;//先保存,否則
free(p1);//free後 p1->next數據丟失
}
}
⑽ 用C語言建線性鏈表
struct LNode
{
ElemType data;
LNode *next;
};
typedef LNode *LinkList; // 另一種定義LinkList的方法 12種基本操作Status InitList(LinkList &L)
{ // 操作結果：構造一個空的線性表L
L=(LinkList)malloc(sizeof(LNode)); // 產生頭結點,並使L指向此頭結點
if(!L) // 存儲分配失敗
exit(OVERFLOW);
L->next=NULL; // 指針域為空
return OK;
} Status DestroyList(LinkList &L)
{ // 初始條件：線性表L已存在。操作結果：銷毀線性表L
LinkList q;
while(L)
{
q=L->next;
free(L);
L=q;
}
return OK;
} Status ClearList(LinkList L) // 不改變L
{ // 初始條件：線性表L已存在。操作結果：將L重置為空表
LinkList p,q;
p=L->next; // p指向第一個結點
while(p) // 沒到表尾
{
q=p->next;
free(p);
p=q;
}
L->next=NULL; // 頭結點指針域為空
return OK;
} Status ListEmpty(LinkList L)
{ // 初始條件：線性表L已存在。操作結果：若L為空表，則返回TRUE，否則返回FALSE
if(L->next) // 非空
return FALSE;
else
return TRUE;
} int ListLength(LinkList L)
{ // 初始條件：線性表L已存在。操作結果：返回L中數據元素個數
int i=0;
LinkList p=L->next; // p指向第一個結點
while(p) // 沒到表尾
{
i++;
p=p->next;
}
return i;
} Status GetElem(LinkList L,int i,ElemType &e) // 演算法2.8
{ // L為帶頭結點的單鏈表的頭指針。當第i個元素存在時,其值賦給e並返回OK,否則返回ERROR
int j=1; // j為計數器
LinkList p=L->next; // p指向第一個結點
while(p&&j<i) // 順指針向後查找,直到p指向第i個元素或p為空
{
p=p->next;
j++;
}
if(!p||j>i) // 第i個元素不存在
return ERROR;
e=p->data; // 取第i個元素
return OK;
} int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
{ // 初始條件: 線性表L已存在,compare()是數據元素判定函數(滿足為1,否則為0)
// 操作結果: 返回L中第1個與e滿足關系compare()的數據元素的位序。
// 若這樣的數據元素不存在,則返回值為0
int i=0;
LinkList p=L->next;
while(p)
{
i++;
if(compare(p->data,e)) // 找到這樣的數據元素
return i;
p=p->next;
}
return 0;
} Status PriorElem(LinkList L,ElemType cur_e,ElemType &pre_e)
{ // 初始條件: 線性表L已存在
// 操作結果: 若cur_e是L的數據元素,且不是第一個,則用pre_e返回它的前驅,
// 返回OK;否則操作失敗,pre_e無定義,返回INFEASIBLE
LinkList q,p=L->next; // p指向第一個結點
while(p->next) // p所指結點有後繼
{
q=p->next; // q為p的後繼
if(q->data==cur_e)
{
pre_e=p->data;
return OK;
}
p=q; // p向後移
}
return INFEASIBLE;
} Status NextElem(LinkList L,ElemType cur_e,ElemType &next_e)
{ // 初始條件：線性表L已存在
// 操作結果：若cur_e是L的數據元素，且不是最後一個，則用next_e返回它的後繼，
// 返回OK;否則操作失敗，next_e無定義，返回INFEASIBLE
LinkList p=L->next; // p指向第一個結點
while(p->next) // p所指結點有後繼
{
if(p->data==cur_e)
{
next_e=p->next->data;
return OK;
}
p=p->next;
}
return INFEASIBLE;
} Status ListInsert(LinkList L,int i,ElemType e) // 演算法2.9。不改變L
{ // 在帶頭結點的單鏈線性表L中第i個位置之前插入元素e
int j=0;
LinkList p=L,s;
while(p&&j<i-1) // 尋找第i-1個結點
{
p=p->next;
j++;
}
if(!p||j>i-1) // i小於1或者大於表長
return ERROR;
s=(LinkList)malloc(sizeof(LNode)); // 生成新結點
s->data=e; // 插入L中
s->next=p->next;
p->next=s;
return OK;
} Status ListDelete(LinkList L,int i,ElemType &e) // 演算法2.10。不改變L
{ // 在帶頭結點的單鏈線性表L中，刪除第i個元素,並由e返回其值
int j=0;
LinkList p=L,q;
while(p->next&&j<i-1) // 尋找第i個結點,並令p指向其前趨
{
p=p->next;
j++;
}
if(!p->next||j>i-1) // 刪除位置不合理
return ERROR;
q=p->next; // 刪除並釋放結點
p->next=q->next;
e=q->data;
free(q);
return OK;
} Status ListTraverse(LinkList L,void(*vi)(ElemType))
// vi的形參類型為ElemType，與bo2-1.cpp中相應函數的形參類型ElemType&不同
{ // 初始條件：線性表L已存在
// 操作結果:依次對L的每個數據元素調用函數vi()。一旦vi()失敗,則操作失敗
LinkList p=L->next;
while(p)
{
vi(p->data);
p=p->next;
}
printf("\n");
return OK;
}