線性表順序存儲及實現

⑴ 用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語言實現

#include<stdio.h>
//以下為函數運行結果狀態代碼
#defineOK1
#defineERROR0
#defineINFEASIBLE-1
#defineOVERFLOW-2
#defineLIST_INIT_SIZE100//線性表存儲空間的初始分配量
#defineLISTINCREMENT10//線性表存儲空間分配增量
typedefintStatus;//函數類型，其值為為函數結果狀態代碼
typedefintElemType;//假設數據元素為整型
typedefstruct
{
ElemType*elem;//存畢碰儲空間基址
intlength;//當前長度
intlistsize;//當前分配的存儲容量
}sqlist;
//實現線性表的順序存儲結嫌譽構的類型定義
//函數聲明開手者談始
StatusInitList_Sq(SqList&L);
voidDestroyList_Sq(SqList&L);
voidClearList_Sq(SqList&L);
voidListEmpty_Sq(SqListL);
StatusGetElem_Sq(SqListL,i,&e);
intLocateElem_Sq(SqListL,e,compare());
StatusPriorElem_Sq(SqListL,cur_e,&pre_e);
StatusNextElem_Sq(SqListL,cur_e,&next_e);
StatusListInsert_Sq(SqList&L,i,e);
StatusListDelete_Sq(SqList&L,i,&e);
ListTravel_Sq(SqListL,visit());
//函數聲明結束
intmain(void)
{
return0;
}
//函數定義開始
///////////////////////////////////////
//函數名：InitList_Sq()
//參數：SqList*L
//初始條件：無
//功能：構造一個空線性表
//返回值：存儲分配失敗：OVERFLOW
//存儲分配成功：OK
///////////////////////////////////////
StatusInitList_Sq(SqList*L)
{
L.elem=(ElemType*)malloc((LIST_INIT_SIZE*sizeof(ElemType));//分配空間
if(!L.elem)
exit(OVERFLOW);//若存儲分配失敗，返回OVERFLOW
L.length=0;//空表，長度為0
L.listsize=LIST_INIT_SIZE;//初始存儲容量
returnOK;
}
///////////////////////////////////////
//函數名：DestroyList_Sq()
//參數：SqList*L
//初始條件：線性表L已存在
//功能：銷毀線性表
//返回值：無
///////////////////////////////////////
voidDestroyList_Sq(SqList*L)
{
if(L->elem)
free(L->elem);//釋放線性表占據的所有存儲空間
}
///////////////////////////////////////
//函數名：ClearList_Sq()
//參數：SqList*L
//初始條件：線性表L已存在
//功能：清空線性表
//返回值：無
///////////////////////////////////////
voidClearList_Sq(SqList*L)
{
L->length=0;//將線性表的長度置為0
}
///////////////////////////////////////
//函數名：ListEmpty_Sq()
//參數：SqListL
//初始條件：線性表L已存在
//功能：判斷線性表是否為空
//返回值：空：TRUE
//非空：FALSE
///////////////////////////////////////
StatusListEmpty_Sq(SqListL)
{
if(L.length==0)
returnTRUE;
else
returnFALSE;
}
///////////////////////////////////////
//函數名：ListLength_Sq()
//參數：SqListL
//初始條件：線性表L已存在
//功能：返回線性表長度
//返回值：線性表長度(L.length)
///////////////////////////////////////
StatusListLength_Sq(SqListL)
{
return(L.length);
}
///////////////////////////////////////
//函數名：GetElem_Sq()
//參數：SqListL,inti,ElemType*e
//初始條件：線性表L已存在，1<=i<=ListLength(L)
//功能：用e返回線性表中第i個元素的值
//返回值：(i<1)||(i>ListLength(L))：ERROR
//1<=i<=ListLength(L)：OK
///////////////////////////////////////
StatusGetElem_Sq(SqListL,inti,ElemType*e)
{
if(i<1||i>L.length)
returnERROR;//判斷i值是否合理，若不合理，返回ERROR
*e=L.elem[i-1];//數組中第i-1的單元存儲著線性表中第i個數據元素的內容
returnOK;
}
///////////////////////////////////////
//函數名：LocateElem_Sq()
//參數：L,e,compare(ElemType1,ElemType2)
//初始條件：線性表L已存在，compare()為數據元素判定函數
//功能：返回順序表L中第1個與e滿足關系compare()的數據元素的位序
//返回值：若在L中存在於e滿足關系compare()的元素：其位序
//若在L中不存在於e滿足關系compare()的元素：0
///////////////////////////////////////
intLocateElem_Sq(SqListL,e,compare(ElemType1,ElemType2))
{
inti=1;//i的初值為第1元素的位序
intp=L.elem;//p的初值為第1元素的存儲位置
while(i<=L.length&&!(*compare)(*p++,e))
++i;//依次進行判定
if(i<=L.length)
returni;//找到滿足判定條件的數據元素為第i個元素
else
return0;//該線性表中不存在滿足判定的數據元素
}
StatusPriorElem_Sq(SqListL,cur_e,&pre_e);
//見StatusNextElem_Sq(SqListL,cur_e,&next_e);
StatusNextElem_Sq(SqListL,cur_e,&next_e);
//我的思路是先用LocateElem_Sq()搜索cur_e的位序，
//再看是否大於等於length，
//若是，則返回OVERFLOW；否則返回後繼
//這樣也許有點麻煩？所以希望大家能夠補充方案
//bywangweinoo1
///////////////////////////////////////
//函數名：ListInsert_Sq()
//參數：SqList*L,inti,ElemTypee
//初始條件：線性表L已存在，1<=i<=ListLength(L)+1
//功能：在線性表中第i個數據元素之前插入數據元素e
//返回值：失敗：ERROR
//成功：OK
///////////////////////////////////////
StatusListInsert_Sq(SqList*L,inti,ElemTypee)
{
ElemType*j;
if(L->length==LIST_MAX_LENGTH)
returnERROR;//檢查是否有剩餘空間
if(i<1||i>L->length+1)
returnERROR;//檢查i值是否合理
//將線性表第i個元素之後的所有元素向後移動
for(j=L->length-1;j>=i-1;i++)
L->elem[j+1]=L->elem[j];
L->elem[i-1]=e;//將新元素的內容放入線性表的第i個位置，
L->length++;
returnOK;
}
///////////////////////////////////////
//函數名：ListDelete_Sq()
//參數：SqList*L,inti,Elemtype*e
//初始條件：線性表L已存在，1<=i<=ListLength(L)
//功能：將線性表L中第i個數據元素刪除
//返回值：失敗：ERROR
//成功：OK
///////////////////////////////////////
intListDelete_Sq(SqList*L,inti,Elemtype*e)
{
if(IsEmpty(L))
returnERROR;//檢測線性表是否為空
if(i<1||i>L->length)
returnERROR;//檢查i值是否合理
*e=L->elem[i-1];//將欲刪除的數據元素內容保留在e所指示的存儲單元中
//將線性表第i+1個元素之後的所有元素向前移動
for(j=i;j<=L->length-1;j++)L->elem[j-1]=L->elem[j];
L->length--;
returnOK;
}
//函數定義結束

⑶ 線性表的順序存儲結構用C++實現

線性表的順序存儲結構用C++實現代碼：

#include "pch.h"

#include <stdio.h>

#include <malloc.h>

//#define DATA int

typedef int DATA;

struct SNode

{

DATA data;

SNode* pNext;

};

SNode* g_pHead = NULL;

void AddHead(DATA data)

{

SNode* p = (SNode*)malloc(sizeof(SNode));

p->data = data;

p->pNext = g_pHead;

g_pHead = p;

}

void Print()

{

SNode* p = g_pHead;

printf("List：");

while (p)//當節點的地址不為NULL

{

printf("%d ", p->data);

p = p->pNext;

}

printf(" ");

}

int main()

{

AddHead(1);

AddHead(2);

AddHead(3);

Print();

return 0;

}

程序運行結果如下：

(3)線性表順序存儲及實現擴展閱讀：

雙向鏈表框架：

#pragma once

typedef void* POSITION;

typedef int DATA;

struct SNode

{

DATA data;

SNode *pPrev, *pNext;

};

class CList

{

SNode *m_pHead, *m_pTail;

int m_nCount;

public:

CList();

~CList();

void RemoveAll();

DATA GetNext(POSITION &pos);

DATA GetPrev(POSITION &pos);

void AddHead(DATA data);

void AddTail(DATA data);

void RemoveAt(POSITION pos);

};

⑷ 1、線性表順序存儲方式操作2、線性表鏈式存儲方法操作：。兩個都用c語言

下面是從我的博客裡面給你找的，你參考一下。更多的數據結構的內容，也可以去看我的博客。

/************************************************************
說明：
1、主函數內的代碼是為了測試方便，可以自行修改。
2、宏定義NEWS是人機交互信息提示，若不需要，可修改為0。
3、若是windows系統，請將258行中的clear修改為cls。
4、在輸入數據後，請多按一下回車，實現清屏。
環境：ubuntu12.04LTS、codeblocks10.05、2014-04-02
************************************************************/
#include<iostream>
#include<stdlib.h>
#include<malloc.h>
#include<cstring>
#defineNEWS1
#defineLIST_INIT_SIZE100
#defineLIST_ADD_SIZE10
#defineNEW_SIZE(L->list_size+LIST_ADD_SIZE)
usingnamespacestd;
typedefintElem_Type;
typedefstruct
{
Elem_Type*data;//元素
intlen;//長度
intlist_size;//空間
}Sq_List;
typedefenum
{
OK=0,//正常
ERROR=-1,//邏輯異常
OVER=-2//內存異常
}Status;
/******************************
函數名：Init_List
功能：構造、初始化線性表
******************************/
Sq_List*Init_List(void)
{
Sq_List*L=(Sq_List*)malloc(sizeof(Sq_List));
if(!L)
exit(OVER);
L->data=(Elem_Type*)malloc(LIST_INIT_SIZE*sizeof(Elem_Type));
if(!L->data)
exit(OVER);
L->len=0;
L->list_size=LIST_INIT_SIZE;
#if(NEWS)
cout<<"構造成功，已初始化"<<endl;
#endif
returnL;
}
/******************************
函數名：Destroy_List
功能：銷毀線性表
******************************/
StatusDestroy_List(Sq_List*L)
{
free(L);
#if(NEWS)
cout<<"銷毀成功，請不要再使用"<<endl;
#endif
returnOK;
}
/******************************
函數名：Clear_List
功能：清空線性表
******************************/
StatusClear_List(Sq_List*L)
{
memset(L->data,-1,sizeof(L->data));
L->len=0;
#if(NEWS)
cout<<"已全部清空"<<endl;
#endif
returnOK;
}
/******************************
函數名：Empty_List
功能：判斷線性表是否為空
******************************/
boolEmpty_List(Sq_List*L)
{
returnL->len==0;
}
/******************************
函數名：Length_List
功能：獲取線性表長度
******************************/
intLength_List(Sq_List*L)
{
returnL->len;
}
/******************************
函數名：Get_Elem_List
功能：指定位置獲取元素
******************************/
StatusGet_Elem_List(Sq_List*L,intindex,Elem_Type*e)
{
if(!(1<=index&&index<=Length_List(L)))
#if(NEWS)
{
cout<<"獲取位置不合法"<<endl
<<"下面顯示的數據是上次輸入的num的值,請注意！！！"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
*e=L->data[index-1];
returnOK;
}
/******************************
函數名：Insert_List
功能：指定位置插入元素
******************************/
StatusInsert_List(Sq_List*L,intindex,Elem_Typee)
{
if(!(1<=index&&index<=Length_List(L)+1))
#if(NEWS)
{
cout<<"插入位置不合法"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
if(Length_List(L)>=L->list_size)
#if(NEWS)
cout<<"剛才增加了存儲空間"<<endl;
#endif
L->data=(Elem_Type*)realloc(L->data,NEW_SIZE*sizeof(Elem_Type));
if(!L->data)
exit(OVER);

L->list_size+=LIST_ADD_SIZE;

for(inti=Length_List(L);i>=index-1;i--)
L->data[i+1]=L->data[i];

L->data[index-1]=e;
L->len++;
#if(NEWS)
cout<<"插入成功"<<endl;
#endif
returnOK;
}
/******************************
函數名：Delete_List
功能：指定位置刪除元素
******************************/
StatusDelete_List(Sq_List*L,intindex,Elem_Type*e)
{
if(Empty_List(L)||!(1<=index&&index<=Length_List(L)))
#if(NEWS)
{
cout<<"刪除位置不合法or目前是空表"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
*e=L->data[index-1];
for(inti=index;i<Length_List(L);i++)
L->data[i-1]=L->data[i];
#if(NEWS)
cout<<"刪除成功"<<endl;
#endif
L->len--;
returnOK;
}
/******************************
函數名：Print_List
功能：輸出所有元素
******************************/
StatusPrint_List(Sq_List*L)
{
if(Empty_List(L))
returnERROR;
inttemp;
for(inti=1;i<=Length_List(L);i++)
{
Get_Elem_List(L,i,&temp);
cout<<temp<<"";
}
cout<<endl;
returnOK;
}
/******************************
函數名：print_news
功能：方便用戶選擇
******************************/
voidprint_news(void)
{
cout<<" ********************"
<<"*****************************"<<endl
<<" * 0建立、初始化 *"<<endl
<<" * *"<<endl
<<" * 1插入元素 *"<<endl
<<" * *"<<endl
<<" * 2刪除元素 *"<<endl
<<" * *"<<endl
<<" * 3銷毀 *"<<endl
<<" * *"<<endl
<<" * 4獲取表長 *"<<endl
<<" * *"<<endl
<<" * 5清空 *"<<endl
<<" * *"<<endl
<<" * 6獲取元素 *"<<endl
<<" * *"<<endl
<<" * 7列印 *"<<endl
<<" * *"<<endl
<<" * 8退出程序 *"<<endl
<<" ********************"
<<"*****************************"<<endl;
}
intmain(void)
{
Sq_List*test=NULL;
while(true)
{
print_news();
intchoose,index,num;
cout<<"要進行什麼操作？"<<endl;
cin>>choose;
switch(choose)
{
case0:
test=Init_List();break;
case1:
cout<<"插入位置"<<endl;
cin>>index;
cout<<"插入數據"<<endl;
cin>>num;
Insert_List(test,index,num);break;
case2:
cout<<"刪除的位置"<<endl;
cin>>index;
Delete_List(test,index,&num);
cout<<"被刪除的元素是："<<num<<endl;break;
case3:
Destroy_List(test);break;
case4:
cout<<Length_List(test)<<endl;break;
case5:
Clear_List(test);break;
case6:
cout<<"獲取哪個位置的元素"<<endl;
cin>>index;
Get_Elem_List(test,index,&num);
cout<<num<<endl;break;
case7:
Print_List(test);break;
case8:
return0;
default:
break;
}
getchar();
getchar();
system("clear");
}
return0;
}

⑸ 線性表的順序存儲實驗

你改下下面代碼的標點就行了：
#include<iostream.h>
#define elemtype int
struct link
{ elemtype data；//元素類型
link *next； //指針類型，存放下一個元素地址
};

//頭插法建立帶頭結點的單鏈表
link *hcreat()
{ link s,p;
elemtype i;
cout<<」輸入多個結點數值(用空格分隔)，為0時演算法結束」；
cin>>i；
p=new link；
p->next=NULL；
while(i) //當輸入的數據不為0時，循環建單鏈表
{s=new link；
s->data=i；
s->next=p->next；
p->next=s；
cin>>i； }
return p；
}

//輸出單鏈表
void print(1ink *head)
{
1ink *p；
p=head->next；
while(p->next!=NULL)
{
cout<<p->data<<」->」； //輸出表中非最後一個元素
p=p->next；
}
cout<<p->data； //輸出表中最後一個元素
cout<<endl；
}

∥在單鏈表head中查找值為x的結點
Link *Locate(1ink *head，elemtype x)
{
Link *p；
p=head->next；
while((p!=NULL)&&(p->data!=x))
p=p->next；
return p； }

//在head為頭指針的單鏈表中，刪除值為x的結點
void deletel(1ink *head，elemtype x)
{
1ink *p， *q；
q=head；
p=head->next；
while((p!=NULL)&&(p->data!=x))
{
q=p；
p=p->next；}
If(p==NULL) cout<<「要刪除的結點不存在」；
else
q->next=p ->next；
delete(p)；
}
}
//在頭指針head所指的單鏈表中，在值為x的結點之後插入值為y的結點
void insert(1ink *head，elemtype x，elemtype y)
｛ link *p， *s；
s=new link；
s->data=y；
if(head->next==NULL) //鏈表為空
{
head->next=s；
s->next=NULL：
}
p=Locate(head，x)；//調用查找演算法 『
if(p==NULL)
cout<<」插入位置非法」：
else
(s->next=p->next；
p->next=s；
}
}

//將單鏈表p中所有值為x的元素修改成y
void change(1ink *p,elemtype x,elemtype y)
{
link *q；
q=p->next；
while(q!=NULL)
{ if(q->data==x) q->data=y；
q=q->next；
}
}

void count(1ink *h) //統計單鏈表中結點個數
{
1ink *p；int n=0；
p=h->next；
while(p!=NULL)
{n++；p=p->next；}
return n;
}


void main()
{ int n；
elemtype x，y；
link *p， *q；
p=hcreat()； //頭插法建立鏈表
print(p)； //輸出剛建立的單鏈表
cout<<」請輸入要刪除的元素」；
cin>>y；
deletel(p，y)；
print(p)； //輸出刪除後的結果
cout<<」請輸入插入位置的元素值(將待插元素插入到它的後面)」;
cin>>x；
cout<<」請輸入待插元素值」；
cin>>y；
insert(p，x，y)；
print(p)； //輸出插入後的結果
cout<<」請輸入要修改前、後的元素值」;
cin>>x>>y；
change(p，x，y)；
print(p)；
cout<<」請輸入要查找的元素值」；
cin>>x；
q=Locate(p，x)；
if(q==NULL)cout<<x<<」不在表中，找不到!」<<endl；
else cout<<x<<」在表中，已找到!」<<endl；
n=count(p)；
cout<<」鏈表中結點個數為：」<<n<<endl：
}

⑹ 用C語言建立一個順序存儲的線性表並實現線性表的插入和刪除操作

此順序表實現了多個功能，代碼很完善，我將其改成從鍵盤輸入跟選擇刪除了，你根據你的需要自己再進行修改。

//common.h文件，頭文件
#ifndef_COMMON_H_
#define_COMMON_H_

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

#defineTRUE1
#defineFALSE0

#defineMAXSIZE100

typedefintdatatype;

typedefstruct
{
	datatypedata[MAXSIZE];
	intlength;
}sqnode,*sqlink;

voidcreat_sqlist(sqlink*sq);
voidset_empty_sqlist(sqlinksq);
intisempty_sqlist(sqlinksq);
intisfull_sqlist(sqlinksq);
intgetlength_sqlist(sqlinksq);
datatypegetelem(sqlinksq,inti);//i為第i個元素
intlocate_sqlist(sqlinksq,datatypex);//返回該元素在表中的位置
voidinsert_sqlist(sqlinksq,datatypex,inti);//表示在表中第i個位置前插入。
datatypedel_sqlist(sqlinksq,inti);//刪除表中第i個元素
voidshow_sqlist(sqlinksq);

#endif

//線性表實現的c代碼
#include"common.h"
voidcreat_sqlist(sqlink*sq)
{
	*sq=(sqlink)malloc(sizeof(sqnode));
	assert(*sq);
	bzero(*sq,sizeof(sqnode));
	(*sq)->length=0;
}

voidset_empty_sqlist(sqlinksq)
{
	sq->length=0;
}

intisempty_sqlist(sqlinksq)
{
	returnsq->length==0?TRUE:FALSE;
}

intisfull_sqlist(sqlinksq)
{
	returnsq->length==MAXSIZE?TRUE:FALSE;
}

intgetlength_sqlist(sqlinksq)
{
	returnsq->length;
}

datatypegetelem(sqlinksq,inti)//i為第i個元素
{
	if(i<1||i>getlength_sqlist(sq))
	{
		printf("iiswrong!
");
		returnFALSE;
	}
	returnsq->data[i-1];
}

intlocate_sqlist(sqlinksq,datatypex)//返回該元素在表中的枯耐位置
{
	intj=1;
	while(j<=getlength_sqlist(sq))
	{
		if(sq->data[j-1]==x)
			returnj;
		j++;
	}
	returnFALSE;
}
voidinsert_sqlist(sqlinksq,datatypex,inti)//表示在表中第i個沒和春位置前插入。
{
	intj=1;
	if(isfull_sqlist(sq))
	{
		printf("sqlistisfull!
");
		return;
	}
	if(i<1||i>getlength_sqlist(sq)+1)
	{
		printf("iisnotintherange!
");
		return;
	}
	for(j=getlength_sqlist(sq)-1;j>=i-1;j--)
	{
		sq->data[j+1]=sq->data[j];
	}
	sq->data[i-1]=x;
	++sq->length;
}
datatypedel_sqlist(sqlinksq,inti)//刪除表中第i個元素
{
	datatyperet;
	if(isempty_sqlist(sq))
	{
		printf("sqlistisempty!
");
		returnFALSE;
	}
	if(i<1||棚兆i>getlength_sqlist(sq))
	{
		printf("iisnotintherange!");
		returnFALSE;
	}
	for(i;i<getlength_sqlist(sq);i++)
		sq->data[i-1]=sq->data[i];
	--sq->length;
	returnret;
}

voidshow_sqlist(sqlinksq)
{
	intj=0;
	for(j;j<getlength_sqlist(sq);j++)
		printf("%d,",sq->data[j]);
	putchar('
');
}
//main函數
#include"common.h"

intmain(intargc,char*argv[])
{
	inti=0,n,id;
	intnum;
	printf("你要往順序表中插入幾個元素
");
	scanf("%d",&num);
	printf("請往順序表中插入%d個元素：
",num);
	sqlinksq=NULL;
	creat_sqlist(&sq);
	while(i<num)
	{
	scanf("%d",&n);
		insert_sqlist(sq,n,1);
		i++;
	}
	printf("順序表的存儲如下：
");
	show_sqlist(sq);
	printf("你要刪除第幾個元素?
");
	scanf("%d",&id);
	del_sqlist(sq,id);
	printf("刪除第%d個元素之後的順序表為：
",id);
	show_sqlist(sq);
	return0;
}

⑺ 數據結構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. 造成存儲空間的」碎片」.

⑻ 給出線性表的順序存儲的定義及程序實現。

#include<stdio.h>
#include"茄數string"
#include<conio.h>
typedef int ElemType;
#define MAXSIZE 100
#define OK 1
#define ERROR 0
//初始化
typedef struct
{
ElemType elem[MAXSIZE];
int last;
}SeqList;
//創建空表
void IntList(SeqList *L)
{
L->last=-1;
}
//判斷空表
int EmptyList(SeqList *L)
{
if(L->last==-1)
{
return OK;
}
else return ERROR;
}
//輸入遞增有序順序表
void putseqList(SeqList *L,int n)
{
int i;
for(i=0;i<n;i++)
scanf("%d",&(L->elem[i]));
L->last=L->last+n;
}
//求表長
int LenList(SeqList *L)
{
int Len;
Len=L->last+1;
return Len;
}
//查找元素
int Locate(SeqList *L,int e)
{
int s;
if(L->last==-1)
return -1;
for(s=0;s<=L->last;s++)
{
if(L->elem[s]==e)
return (s+1);
else return -1;
}
}
//插入元素
int InsList(SeqList *L,int i,int e)
{
int k;
if((i<1)||(i>L->last+2))
{
printf("插入位置不合理");
return(ERROR);
}
if(L->last>=MAXSIZE-1)
{
printf("表已滿無法插入");
return(ERROR);
}
for(k=L->last;k>=i-1;k--)
L->elem[k+1]=L->elem[k];
L->elem[i-1]=e;
L->last++;
return(OK);
}
//刪除操作
int DeiList(SeqList *L,int f,int *e)
{
int m;
if((f<1)||(f>L->last+1))
{
printf("刪除位置不合理");
return(ERROR);
}
*e=L->elem[f-1];
for(m=f;m<=L->last;m++)
L->elem[m-1]=L->elem[m];
L->last--;
return(OK);
}
//合並操作
void merge(SeqList *LA, SeqList *LB, SeqList *LC)
{
int i,j,k;
i=0;j=0;k=0;
while(i<=LA->last&&j<=LB->last)
if(LA->elem[i]<=LB->elem[j])
{
LC->elem[k]= LA->elem[i];
i++;
k++;
}
else
{
LC->elem[k]=LB->elem[j];
j++;
k++;
}
while(i<=LA->last) /*當表LA有剩餘元素時，則將表LA餘下的猜納好元素賦給表LC*/
{
LC->elem[k]= LA->elem[i];
i++;
k++;
}
while(j<=LB->last) /*當表LB有剩餘元素時，則將表LB餘下的元素賦給表LC*/
{
LC->elem[k]= LB->elem[j];
j++;
k++;
}
LC->last=LA->last+LB->last+1;
}

//輸出元素
int OutputSeqList(SeqList *L)
{
int t;
for(t=0;t<=L->last;t++)
printf("%d ",L->elem[t]);
return(L->elem[t]);
}
//主程序
void main()
{
int z,x,h,u,r,WF=1,La,Lb;
char ch;
SeqList L,LA,LB,LC;
while(WF)
{
printf("\n");
printf("--------------------------------------------\n");
printf("實現順序表穗鉛基本操作\n");
printf("0.退出\n");
printf("1.創建順序表\n");
printf("2.在順序表中插入元素 \n");
printf("3.在順序表中刪除元素\n");
printf("4.合並兩個順序表\n");
printf("請選擇所要實施的操作\n:");
printf("--------------------------------------------\n");
ch=getch();
putchar(ch);
putchar('\n');
//選擇功能里無對應選項選項，執行此返回操作
if(ch<'0'||ch>'7')
{
printf("無此功能選項，請重新選擇！\n");
WF=1;
}
else
//採用switch語句實現菜單的操作
switch(ch)
{
//實現選擇0的操作
case '0':printf("退出\n");break;
//實現選擇1的操作
case '1': printf("創建順序表\n");
IntList(&L);
printf("請輸入順序表表長:\n");
scanf("%d",&z);
printf("請輸入順序表中的元素:\n");
putseqList(&L,z);
LenList(&L);
printf("表長為%d\n",LenList(&L));
printf("順序表為\n");
OutputSeqList(&L);
break;
//實現選擇2的操作
case '2':
if(LenList(&L)<=0)
{ printf("未輸入任何值，請先創建！\n");
break;
}
printf(".在順序表中插入元素\n ");
printf("請輸入要插入的元素的位置和元素(用空格隔開): \n");
scanf("%d %d",&x,&h);
InsList(&L,x,h);
printf("在第%d位子插入元素%d後的順序表為\n:",x,h);
OutputSeqList(&L);
break;
//實現選擇3的操作
case '3':
if(LenList(&L)<=0)
{ printf("未輸入任何值，請先創建！\n");
break;
}
printf("在順序表中刪除元素\n");
printf("請輸入要刪除的元素的位置: \n");
scanf("%d",&u);
DeiList(&L,u,&r);
printf("在刪除第%d個元素後的順序表為:",u);
OutputSeqList(&L);
break;
//實現選擇4的操作
case '4':printf("合並兩個順序表:\n");
IntList(&LA);
IntList(&LB);
IntList(&LC);
//對合並前順序表1的輸入
printf("請輸入順序表1表長:\n");
scanf("%d",&La);
printf("請輸入順序表1中的元素:\n");
putseqList(&LA,La);
LenList(&LA);
printf("表長為%d\n",LenList(&LA));
printf("順序表1為\n");
OutputSeqList(&LA);
printf("\n");
//對合並前順序表2的輸入
printf("請輸入順序表2表長:\n");
scanf("%d",&Lb);
printf("請輸入順序表2中的元素:\n");
putseqList(&LB,Lb);
LenList(&LB);
printf("表長為%d\n",LenList(&LB));
printf("順序表1為\n");
OutputSeqList(&LB);
printf("\n");
//合並操作及對合並後的餓順序表的操作
merge(&LA,&LB,&LC);
OutputSeqList(&LC);
printf("\n");
break;
}
}

}

⑼ 線性表的基本操作在順序存儲結構上的實現

/* =======================
* Filename:delet.c
* -----------------------
* Author:hufeng Date:2007/10/23
* -----------------------------
* ========================
*/
/姿答仔跡汪* header file */
#include <stdio.h>
#include <stdlib.h>
#define M 10

/* =================
* Function:insert
* Reaction:insert x in
* the i place
* ==================
*/
void delet(int a[], int i)
{
int j; /* declaration */舉正

if (i < 1 || i > a[0] + 1)
{
printf("error");
exit(0);
}

for (j = i + 1; j <= a[0]; j++) /* all elem after i backward */
{
a[j - 1] = a[j];
}

/* read x */

a[0] = a[0] - 1;

}

/* ========================
* Function:Creat_list
* reaction:creat a list
* =========================
*/

void creat_list(int a[], int n)
{
int i; /* declaration */
int j;
int x;

a[1] = rand()%100; /* read a[1] */

for (i = 2; i <= n; i++)
{
x = rand()%100;
for (j = 1; j <= i - 1; j++)
{
if (x == a[j])
{
break;
}
}
if (j > i - 1)
{
a[i] = x;
}
else
i--;
}
a[0] = n;
}

/* ========================
* Function:print_list
* Reaction:display the result
* =========================
*/
void print_list(int a[] )
{
int i; /* declartion a cycle variable */

printf("\n");

for (i = 1; i <= a[0]; i++)
{
printf("%5d",a[i]);
}

printf("\n");
}

int main()
{
int a[M]; /* declaration arrey a */
int num;
int place;

creat_list(a, 8); /* creat list a */
print_list(a); /* print list a */

printf("Pleae enter where you want to delet:\n");
scanf("%d",&place);
printf("The place is :%d\n",place);

delet(a, place);
print_list(a);

getch();
return 0;
}

⑽ 數據結構實驗，線性表的順序存儲結構的實現

C++代碼編寫的

#include<iostream>
#include<string>
usingnamespacestd;
typedefintElemType;
typedefstructLNode
{
ElemTypedata;
structLNode*next;
}LinkList;
voidCreatListR(LinkList*&L,ElemTypea[],intn)
{
LinkList*s,*r;
inti;
//L=(LinkList*)malloc(sizeof(LinkList));
L=newLinkList();
r=L;
for(i=0;i<n;i++)
{
//s=(LinkList*)malloc(sizeof(LinkList));
s=newLinkList();
s->data=a[i];
好信r->next=s;
r=s;
}
r->next=NULL;
}
voidDispList(LinkList*L)
{
LinkList*p=L->next;
while(p!=NULL)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
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=newLinkList();
s->data=e;
s->next=p->next;
p->next=s;
return1;
}
}
intListDelete(LinkList*&L,inti)
{
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;
}
p->next=q->next;
inta=q->data;
free(q);
returna;
}
}
intmain()
{
LinkList*L,*L1;
鉛襪差inta[]={1,5,7,9,12,18,19,20,30,43,45,56,41,42,78};
intn=15,i,x,y,j;
CreatListR(L,a,n);
DispList(L);
cout<<"請輸入i"<<endl;
cin>>i;
cout<<"請輸入x"<<endl;
cin>>x;
ListInsert(L,i,x);
DispList(L);
cout<<"請輸入j"<<endl;
cin>>j;
y=ListDelete(L,j);
DispList(L);
cout<<y<<endl;
return0;
}