(数据结构)线性表的链式表示和实现(源代码)

合集下载

数据结构上机实验源代码

数据结构上机实验源代码栈的应用十进制数转换为八进制数，逆序输出所输入的数实验代码：//stack.h，头文件class stack{public:stack();bool empty()const;bool full()const;error_code gettop(elementtype &x)const;error_code push(const elementtype x);error_code pop();private:int count;elementtype data[maxlen];};stack::stack(){count=0;}bool stack::empty()const{return count==0;}bool stack::full()const{return count==maxlen;}error_code stack::gettop(elementtype &x)const{if(empty())return underflow;else{x=data[count-1];return success;}}error_code stack::push(const elementtype x){if(full())return overflow;data[count]=x;count++;return success;}error_code stack::pop(){if(empty())return underflow;count--;return success;}//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"stack.h"void read_write() //逆序输出所输入的数{stack s;int i;int n,x;cout<<"please input num int n:";cin>>n;for(i=1;i<=n;i++){cout<<"please input a num:";cin>>x;s.push(x);}while(!s.empty()){s.gettop(x);cout<<x<<" ";s.pop();}cout<<endl;}void Dec_to_Ocx(int n) //十进制转换为八进制{stack s1;int mod,x;while(n!=0){mod=n%8;s1.push(mod);n=n/8;}cout<<"the ocx of the dec is:";while(!s1.empty()){s1.gettop(x);cout<<x;s1.pop();}cout<<endl;}void main(){int n;// read_write();cout<<"please input a dec:";cin>>n;Dec_to_Ocx(n);}队列的应用打印n行杨辉三角实验代码：//queue.hclass queue{public:queue(){count=0;front=rear=0;}bool empty(){return count==0;}bool full(){return count==maxlen-1;}error_code get_front(elementtype &x){if(empty())return underflow;x=data[(front+1)%maxlen];return success;}error_code append(const elementtype x){if(full())return overflow;rear=(rear+1)%maxlen;data[rear]=x;count++;return success;}error_code serve(){if(empty())return underflow;front=(front+1)%maxlen;count--;return success;}private:int count;int front;int rear;int data[maxlen];};//主程序#include<iostream.h>enum error_code{overflow,underflow,success};typedef int elementtype;const int maxlen=20;#include"queue.h"void out_number(int n) //打印前n行的杨辉三角{int s1,s2;int i;int j;int k;queue q;for(i=1;i<=(n-1)*2;i++)cout<<" ";cout<<"1 "<<endl;q.append(1);for(i=2;i<=n;i++){s1=0;for(k=1;k<=(n-i)*2;k++)cout<<" ";for(j=1;j<=i-1;j++){q.get_front(s2);q.serve();cout<<s1+s2<<" ";q.append(s1+s2);s1=s2;}cout<<"1 "<<endl;q.append(1);}}void main(){int n;cout<<"please input n:";cin>>n;out_number(n);}单链表实验实验目的:实验目的（1）理解线性表的链式存储结构。

数据结构线性表的链式表示和实现的基本操作可运行

//头文件Head.h#include <stdlib.h>//exit#define OVERFLOW -2#define NULL 0#define TRUE 1#define ERROR 0#define OK 1#define INFEASIBLE -1typedef int Status;typedef int ElemType;typedef struct LNode //结点类型{ElemType data;struct LNode *prior;struct LNode *next;} LNode,*LinkList;Status comp(ElemType c1,ElemType c2) //判定函数(平方关系) {if(c1==c2*c2)return TRUE;elsereturn ERROR;}void visit(ElemType &c) //被调用的函数{printf("%d ",c);}Status InitList(LinkList &L){//初始化// LinkList L;L=(LinkList)malloc(sizeof(LNode));//生成结点L->next=NULL;return OK;}Status DestroyList(LinkList &L){//摧毁while(L->next){L=L->next;free(L);}return OK;}Status ClearList(LinkList &L){//清空L->next=NULL;return OK;}Status ListEmpty(LinkList L){//判空if(L->next==NULL)return TRUE;return ERROR;}Status ListLength(LinkList &L){//长度LinkList p;p=L->next;int j=0;while(p){j++;p=p->next;}return j;}Status GetElem(LinkList L,int i,ElemType e){//取值LinkList p;p=L->next;int j=1;while(p&&j<i){p=p->next;j++;}if(!p||j>i)return ERROR;return OK;}int LocateElem(LinkList L,ElemType e,Status(*compare)(ElemType,ElemType)) {//返回L中第1个与e满足关系compare()的数据元素的位序LinkList p;int i=0;//while(i<=ListLength(L)&&!compare(p->data,e))while(p&&!compare(p->data,e)){p=p->next;i++;}if(p)//////return i;return ERROR;}Status PriorElem(LinkList L,ElemType cur_e,ElemType &pre_e) {//返回前驱LinkList p;int i=2;p=L->next;while(p&&p->data!=cur_e){i++;p=p->next;}if(!p)return INFEASIBLE;else{pre_e=p->prior->data;return pre_e;}}Status NextElem(LinkList L,ElemType cur_e,ElemType &next_e) {//返回后继LinkList p;p=L;int i=1;while(p->next&&p->data!=cur_e){i++;p=p->next;}if(p==NULL)return INFEASIBLE;else{next_e=p->next->data;return next_e;}}Status ListInsert(LinkList &L,ElemType i,ElemType e){//插入LinkList p,s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)return ERROR;s=(LinkList)malloc(sizeof(LNode));//生成新的结点s->data=e;s->next=p->next;p->next=s;return OK;}Status ListDelete(LinkList &L,ElemType i,ElemType &e){//删除LinkList p;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)return ERROR;e=p->next->data;p->next=p->next->next;return OK;}Status ListTraverse(LinkList L){ //依次对L的每个数据元素调用函数vi()。

线性表的链式表示和实现解析

头结点复习：
a1
a2
p 结点
… ...
an ^
p 指针和 p 结点的区别： L是带头结点的链表的头指针，即L指向头结点，p为指针变量，写出语句 p指向头结点： p指向第一个结点： p指向p结点的下一个结点： p=L p=L->next p=p->next
头指针
L
空指针
头结点
a1
a2
… ...
P=L; while (P!= NULL ) p=p->next; p=NULL
改进的 ClearList(L) :
p
L
///
…
^
void ClearList(LinkList L) { while (L->next) { p=L->next;
int LListlen(LinkList L ) { n=0; p=L ; while ( p->next ) { p=p->next; L->next=p->next; n++; } free(p) ; 算法时间复杂度： return n; } } } // ClearList O(ListLength(L))
Typedef struct LNode {ElemType data; // 数据域 struct Lnode *next; // 指针域 } LNode, *LinkList;
// LNode 为结构变量类型名, LinkList 为结构指针类型名 LinkList p；// p 为指针变量, 分配给 p 一个指针变量; p = (LinkList) malloc (sizeof (LNode)); p 或 p = (LNode*) malloc (sizeof (LNode));

线性表的链式表示和实现—链表

…… ｝
/*调用myList的析构函数*/
MyList的存储结构
(带头结点的空表)
head size 0
next NULL data
▪ 单链表求表长函数
int LinList<T>::Size(void) const {
return size; }
思考1：int LinList<T>::IsEmpty( ) const 如何实现？——判断单链表空否
2.3.1 单链表的存储结构
◆ 结点结构：链表每个结点中只有一个指针域指向直接后继结点。 data next 数据域指针域
数据域：元素本身信息
指针域：指示直接后继的存储位置
结点类的定义 LinList.h文件实现单链表类
template <class T> class LinList; //前视定义,否则友元无法定义
//j从0开始计数
while(p != NULL && j < i) //寻找第i个结点
{ p = p->next; j++; }
return p;
//返回第i个结点的指针
} 思考2：ListNode<T> * LinList<T>::Find(T x) 如何实现？——
查找第一个值为x的元素在单链表的结点
单链表类的定义
template <class T>
class LinList
{
private:
ListNode<T> *head;
//头指针
int size;
//当前数据元素个数
ListNode<T> *Index(int i); //定位函数

数据结构C语言版线性表源代码

#include <stdio.h>#include <conio.h>#include <malloc.h>#include <stdlib.h>#define LIST_INIT_SIZE 100 #define LISTINCREMENT 10#define OK 1#define ERROR -1#define OVERFLOW -1#define ENDFLAG 0typedef int Status;typedef int ElemType;#define OUTFORMAT "%d "#define INFORMAT "%d"typedef struct{ElemType *elem;int length;int listsize;}SqList;Status InitList(SqList *L){L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L->elem) ////// 如果没有分配成功exit(OVERFLOW); /////退出，显示（）内内容L->length=0;L->listsize=LIST_INIT_SIZE;return OK;}Status Inputdata(SqList *L){ ///////SqList *L定义首节点的地址ElemType temp,*newbase;printf("\nInput the data of the sequencial list:\nNote:0 is the ending flag:\n");scanf(INFORMAT,&temp);while(temp!=ENDFLAG){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;}L->elem[L->length++]=temp;scanf(INFORMAT,&temp);}return OK;}Status ListInsert(SqList *L,int i,ElemType e){ElemType *p,*q,*newbase;if(i<0||i>L->length)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]);for(p=&(L->elem[L->length-1]);p>=q;--p)*(p+1)=*p;*q=e;++L->length;return OK;}void MyDisplay(SqList L){int i;for(i=0;i<L.length;i++)printf(OUTFORMAT,L.elem[i]);printf("\n");}void main(void){SqList L;ElemType temp;int i;if(!InitList(&L)) { ////如果初始化失败printf("To initialize the sequencial list fail\n");getch(); //////如果失败，按任意键退出exit(0);}if(!Inputdata(&L)){printf("To input the data of the sequencial list fail\n");getch();exit(0);}MyDisplay(L);printf("Input the data that you want to insert:");scanf(INFORMAT,&temp);printf("Input the insert_location:");scanf("%d",&i);if(!ListInsert(&L,i,temp)){printf("To insert fail\n");getch();exit(0);}MyDisplay(L);getch();}。

实验五__线性表的链式表示和实现

浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验五线性表的链式表示和实现学生姓名专业班级学号实验成绩指导老师（签名）日期一.实验目的和要求1、了解线性表的链式存储结构，学会定义线性表的链式存储结构。

2、掌握单链表、循环单链表的一些基本操作实现函数。

二.实验内容1、设线性表采用带表头附加结点的单链表存储结构，请编写线性表抽象数据类型各基本操作的实现函数，并存放在头文件LinkList.h中（注：教材上为不带表头附加结点）。

同时建立一个验证操作实现的主函数文件test5.cpp，编译并调试程序，直到正确运行。

提示：⑴单向链表的存储结构可定义如下：struct LNode { // 定义单链表节点类型ElemType data; // 存放结点中的数据信息LNode *next; // 指示下一个结点地址的指针}⑵线性表基本操作可包括如下一些：①void InitList (LNode *&H) //初始化单链表②void ClearList(LNode *&H) //清除单链表③int LengthList (LNode *H) //求单链表长度④bool EmptyList (LNode *H) //判断单链表是否为空表⑤ElemType GetList (LNode *H, int pos)//取单链表第pos 位置上的元素⑥void TraverseList(LNode *H) //遍历单链表⑦bool InsertList ( LNode *&H, ElemType item, int pos)//向单链表插入一个元素⑧bool DeleteList ( LNode *&H, ElemType &item, int pos)//从单链表中删除一个元素⑶带表头附加结点的单链表初始化操作的实现可参考如下：void InitList(LNode *&H){ //构造一个空的线性链表H，即为链表设置一个头结点，//头结点的data数据域不赋任何值，头结点的指针域next则为空H=(LNode *)malloc(sizeof(LNode)); // 产生头结点Hif (!H) exit(0); // 存储分配失败，退出系统H->next=NULL; // 指针域为空}2、选做部分：编写一个函数void MergeList(LNode *&La, LNode *&Lb, LNode *&Lc)，实现将两个有序单链表La和Lb合并成一个新的有序单链表Lc，同时销毁原有单链表La和Lb。

链式线性表(源程序)

#include <stdio.h>#include <stdlib.h>#include <iostream.h>#define ListSize 100typedef int DataType;typedef struct node{ DataType data;struct node *next;}ListNode;typedef ListNode *LinkList;void main(){LinkList L,L1,L2,L3;ListNode *p;char ch;int position;DataType newelem,min,max;LinkList InitList();void PrintList(LinkList L);LinkList CreateListF();LinkList CreateListR();int LengthList(LinkList L);void InsertList(LinkList L,DataType newelem,int position);void DeleteList(LinkList L,int position);LinkList LocateList(LinkList L,DataType newelem);void DestroyList(LinkList L);void ReverseList1(LinkList L);void ReverseList2(LinkList L);LinkList MerageList(LinkList L1,LinkList L2);void Delx(LinkList L,DataType newelem);void SplitList(LinkList L,LinkList L1,LinkList L2);void Delmintomax1(LinkList L,int min,int max);void Delmintomax2(LinkList L,int min,int max);void Delrepeat(LinkList L);void Sortlist(LinkList L);void Delminnode(LinkList L);void Joseph();void Invert();do {cout<<endl;cout<<" *******************链式线性表功能菜单************************"<<endl;cout<<" * a：初始化单链表b：建立单链表(头插法)*"<<endl;cout<<" * c: 建立单链表(尾插法) d：求单链表长度*"<<endl;cout<<" * e：单链表插入元素f：单链表删除元素*"<<endl;cout<<" * g：无序单链表查找元素h：释放单链表*"<<endl;cout<<" * i：逆置单链表(头插入) j: 逆置单链表*"<<endl;cout<<" * k：二个递增单链表合并成递减l: 删除值为X的结点*"<<endl;cout<<" * m：将单链表拆分成两个单链表n: 递增单链表删除某数值区间*"<<endl;cout<<" * o：无序单链表删除某数值区间p: 递增单链表删除重复*"<<endl;cout<<" * q：单链表直接插入排序r: 单链表删除最小值*"<<endl;cout<<" * s：约瑟夫问题t: 循环单链表逆置*"<<endl;cout<<" * u：v: *"<<endl;cout<<" * w：x: *"<<endl;cout<<" * y: z：退出*"<<endl;cout<<"*************************************************************"<<endl;cout<<" 请输入你的选择：";cin>>ch;switch (ch){case 'a':L=InitList();PrintList(L);break;case 'b':L=CreateListF();PrintList(L);break;case 'c':L=CreateListR();PrintList(L);break;case 'd':PrintList(L);cout<<" 单链表长度为："<<LengthList(L)<<endl;break;case 'e':cout<<" 请输入插入位置：";cin>>position;cout<<" 请输入插入元素：";cin>>newelem;InsertList(L,newelem,position);PrintList(L);break;case 'f':cout<<" 请输入删除第几个元素：";cin>>position;DeleteList(L,position);PrintList(L);break;case 'g':cout<<" 请输入查找元素：";cin>>newelem;p=LocateList(L,newelem);if (p!=NULL)cout<<p->data<<endl;PrintList(L);break;case 'h':PrintList(L);DestroyList(L);break;case 'i':PrintList(L);ReverseList1(L);PrintList(L);break;case 'j':PrintList(L);ReverseList2(L);PrintList(L);break;case 'k':cout<<" 创建第一个递增有序单链表：";L1=CreateListR();PrintList(L1);cout<<" 创建第二个递增有序单链表：";L2=CreateListR();PrintList(L2);L3=MerageList(L1,L2);cout<<" 递减有序单链表为：";PrintList(L3);break;case 'l':cout<<" 请输入要删除的数据元素：";cin>>newelem;PrintList(L);Delx(L,newelem);PrintList(L);break;case 'm'://利用原空间拆分L=CreateListR();PrintList(L);L1=new(ListNode);L1->next=NULL;L2=new(ListNode);L2->next=NULL;SplitList(L,L1,L2);PrintList(L1);PrintList(L2);break;case 'n':cout<< " 请输入要删除元素的数值区间min,max：";cin>>min;cin>>max;PrintList(L);Delmintomax1(L,min,max);PrintList(L);break;case 'o':cout<< " 请输入要删除元素的数值区间min,max：";cin>>min;cin>>max;PrintList(L);Delmintomax2(L,min,max);PrintList(L);break;case 'p':PrintList(L);Delrepeat(L);PrintList(L);break;case 'q':PrintList(L);Sortlist(L);PrintList(L);break;case 'r':PrintList(L);Delminnode(L);PrintList(L);break;case 's':Joseph();break;case 't':Invert();break;case 'u':break;case 'v':break;case 'w':break;case 'x':break;case 'y':break;default:break;}}while (ch!='z');}LinkList InitList(){ListNode *head;head=new(ListNode);head->next=NULL;return head;}void PrintList(LinkList L) {ListNode *p;if (L)p=L->next;elsep=NULL;cout<<endl;while (p!=NULL){cout<<" "<<p->data;p=p->next;}}LinkList CreateListF(){ListNode *head,*q;int count,i;head=new(ListNode);head->next=NULL;cout<<" 请输入元素个数：";cin>>count;for (i=1;i<=count;i++){q=new(ListNode);cin>>q->data;q->next=head->next;head->next=q;}return head;}LinkList CreateListR(){ListNode *head,*p,*q;int count,i;head=new(ListNode);p=head;cout<<" 请输入元素个数：";cin>>count;for (i=1;i<=count;i++){q=new(ListNode);cin>>q->data;p->next=q;p=q;}p->next=NULL;return head;}int LengthList(LinkList L){int i;ListNode *p;p=L;i=-1;while (p){i++;p=p->next;}return i;}void InsertList(LinkList L,DataType newelem,int position) {int i;ListNode *p,*s;i=position;p=L;while ((p->next!=NULL) && (i>1)){i--;p=p->next;}s=new(ListNode);s->data=newelem;s->next=p->next;p->next=s;}void DeleteList(LinkList L,int position){ListNode *p,*s;int i;p=L;i=position;while ((i>1) && (p!=NULL)){i--;p=p->next;}if (p!=NULL){s=p->next;if (s!=NULL){p->next=s->next;free(s);}}}LinkList LocateList(LinkList L,DataType newelem) {ListNode *p;p=L->next;while ((p!=NULL) && (p->data!=newelem)) p=p->next;return p;}void DestroyList(LinkList L){ListNode *p;while (L->next){p=L->next;L->next=p->next;free(p);}free(L);L=NULL;}void ReverseList1(LinkList L){ListNode *p,*q;p=L->next;L->next=NULL;while (p!=NULL){q=p->next;p->next=L->next;L->next=p;p=q;}}void ReverseList2(LinkList L){ListNode *p,*q,*r;p=L->next;q=p->next;p->next=NULL;while (q){r=q->next;q->next=p;p=q;q=r;}L->next=p;}LinkList MerageList(LinkList L1,LinkList L2) {ListNode *head,*p1,*p2,*s;head=new(ListNode);head->next=NULL;p1=L1->next;p2=L2->next;while (p1 && p2){s=new(ListNode);if (p1->data<p2->data){s->data=p1->data;p1=p1->next;}else{s->data=p2->data;p2=p2->next;}s->next=head->next;head->next=s;}if (p1)while (p1){s=new(ListNode);s->data=p1->data;s->next=head->next;head->next=s;p1=p1->next;}elsewhile (p2){s=new(ListNode);s->data=p2->data;s->next=head->next;head->next=s;p2=p2->next;}return head;}void Delx(LinkList L,DataType newelem){ListNode *p,*s;p=L;while ((p->next) && (p->next->data!=newelem))p=p->next;if (p->next){s=p->next;p->next=s->next;free(s);}}void SplitList(LinkList L,LinkList L1,LinkList L2) //L1放单数，L2放双数{ListNode *p,*p1,*p2;p1=L1;p2=L2;while (L->next){p=L->next;if (p->data%2==1){p1->next=p;p1=p;}else{p2->next=p;p2=p;}}p1->next=NULL;p2->next=NULL;}void Delmintomax1(LinkList L,int min,int max){ListNode *p,*q,*r;p=L;while (p->next && p->next->data<min)p=p->next;q=p->next;while (q && q->data<=max){r=q->next;free(q);q=r;}p->next=q;}void Delmintomax2(LinkList L,int min,int max){ListNode *p,*q;p=L;while (p->next)if (p->next->data>=min && p->next->data<=max){q=p->next;p->next=q->next;free(q);}else}void Delrepeat(LinkList L){ListNode *p,*q;p=L->next;q=p->next;while (q){if (p->data==q->data){p->next=q->next;free(q);}elsep=q;q=p->next;}}void Sortlist(LinkList L){ListNode *p,*q,*r;p=L;q=p->next;p->next=NULL;while (q){p=L;while (p->next && p->next->data<q->data)p=p->next;r=q->next;q->next=p->next;p->next=q;q=r;}}void Delminnode(LinkList L){ListNode *p,*pre,*minp,*minpre;pre=L;p=pre->next;minpre=pre;minp=p;while (p){if (p->data<minp->data){minpre=pre;minp=p;}pre=p;p=p->next;}minpre->next=minp->next;free(minp);}void Joseph(){ListNode *p,*q,*s;int i;p=new(ListNode);p->data=1;q=p;for (i=2;i<=30;i++){s=new(ListNode);s->data=i;q->next=s;q=s;}q->next=p;while (q->next!=q){for (i=1;i<=9;i++)q=q->next;p=q->next;cout<<p->data<<" ";q->next=p->next;free(p);}cout<<q->data;free(q);}void Invert(){ListNode *p,*q,*s;int i;p=new(ListNode);p->data=1;q=p;for (i=2;i<=10;i++){s=new(ListNode);s->data=i;q->next=s;q=s;}q->next=p;while (p!=q){cout<<" "<<p->data;p=p->next;}cout<<" "<<p->data<<endl;p=q->next;q->next=q;while (p!=q){s=p->next;p->next=q->next;q->next=p;p=s;}cout<<" "<<q->data;p=q->next;while (p!=q){cout<<" "<<p->data;p=p->next;}}。

线性表（单链表、循环链表-python实现）

线性表（单链表、循环链表-python实现）⼀、线性表线性表的定义：线性表是具有相同数据类型的有限数据的序列。

线性表的特点：出了第⼀个元素外，每个元素有且仅有⼀个直接前驱，除最后⼀个元素外有且只有⼀个后继。

线性表是⼀种逻辑结构，表⽰元素之间的⼀⼀的相邻关系，顺序表和链表是指存储结构，两者属于不同的概念。

线性表的顺序表⽰：线性表的顺序存储即数组的动态、静态分配，特点是可以随机访问。

线性表的链式表⽰：线性表的链式存储即单链表、双连表、循环单链表以及循环双连表，特点是随机插⼊，不可随机访问。

单链表的实现（python）：#定义每个节点class Node:def__init__(self,data):self.data=dataself.next=Noneclass linkList:#初始化头结点def__init__(self,n):self.head=Node(None)self.n=n#头插法建⽴链表def listCreateForward(self):if self.n==0:return Falseelse:temp=self.headfor i in range(1,self.n+1):print('请输⼊第{0}个节点:'.format(i))num = input()node = Node(num)node.next=temp.nexttemp.next = node#尾插法建⽴链表def listCreateBackward(self):if self.n==0:return Falseelse:temp=self.headfor i in range(1,self.n+1):print('请输⼊第{0}个节点:'.format(i))num = input()node = Node(num)temp.next=nodetemp=node#读取链表def readList(self):if self.n==0:print("空链表！")else:temp = self.headwhile temp.next!=None:temp = temp.nextprint(temp.data,end='')#链表长度def Length(self):i=0temp=self.headwhile temp.next!=None:temp=temp.nexti+=1return i#按值查找def locateElem(self,num):i = 0temp = self.headwhile temp.next != None:temp = temp.nexti += 1if int(temp.data)==num:return ireturn None#按位置查找def getElem(self,j):i = 0temp = self.headwhile temp.next != None:temp = temp.nexti += 1if int(j)==i:return temp.datareturn None#按位置插⼊数字def listInsert(self,j,num):if int(j)<0:return Noneelif self.Length()<j:return Noneelse:i = 0temp = self.headwhile temp.next != None:i += 1if int(j) == i:node=Node(num)node.next=temp.nexttemp.next=nodetemp = temp.next#删除特定元素def deleteData(self,num):temp=self.headwhile True:if temp.next==None:break#当这个节点是尾节点时if int(temp.next.data)==num and temp.next.next==None: temp.next=Nonebreakelif int(temp.next.data)==num:temp.next=temp.next.nexttemp=temp.next#删除特定位置的元素def deleteElem(self,j):if j==1:self.head.next=self.head.next.nextelif j==self.Length() :temp=self.head.nextwhile True:if temp.next.next==None:temp.next=Nonebreaktemp=temp.nextelif j<self.Length():i=2temp=self.head.nextwhile True:if i==j:temp.next=temp.next.nextelse:print('erro')return Nonelinklist1=linkList(5)linklist1.listCreateBackward()linklist1.readList()length=linklist1.Length()print('length={0}'.format(length))locate=linklist1.locateElem(5)print('5在位置{0}'.format(locate))data=linklist1.getElem(3)print('第3个位置是{0}'.format(data))linklist1.listInsert(1,111)linklist1.readList()print('\n删除111(第⼀个元素):')linklist1.deleteData(111)linklist1.readList()print('\n删除5(末尾的元素)')linklist1.deleteData(5)linklist1.readList()print('\n删除第⼀个元素:')linklist1.deleteElem(1)linklist1.readList()print('\n删除末尾的元素')linklist1.deleteElem(3)linklist1.readList()结果：请输⼊第1个节点:1请输⼊第2个节点:2请输⼊第3个节点:3请输⼊第4个节点:4请输⼊第5个节点:51 2 3 4 5 length=55在位置5第3个位置是3111 1 2 3 4 5删除111(第⼀个元素):1 2 3 4 5删除5(末尾的元素)1 2 3 4删除第⼀个元素:2 3 4删除末尾的元素2 3 循环链表的实现（python）：其它部分与单链表相似#定义节点class Node:def__init__(self,data):self.data=dataself.next=Noneclass circleList:# 初始化头结点def__init__(self,n):self.head=Node(None)self.head.next=self.headself.n = n# 头插法建⽴链表-def listCreateForward(self):if self.n==0:return Falseelse:temp=self.headfor i in range(1,self.n+1):print('请输⼊第{0}个节点:'.format(i))num = input()node = Node(num)node.next=temp.nexttemp.next = node temp=temp.next# 尾插法建⽴链表def listCreateBackward(self):if self.n==0:return Falseelse:temp=self.headfor i in range(1,self.n+1):print('请输⼊第{0}个节点:'.format(i))num = input()node = Node(num)temp.next=nodetemp=nodetemp.next = self.head#读取循环链表def readList(self):if self.n==0:print("空链表！")else:temp = self.headwhile temp.next!=self.head: temp = temp.nextprint(temp.data,end='') linklist1=circleList(5)linklist1.listCreateForward()linklist1.readList()linklist1=circleList(5)linklist1.listCreateBackward() linklist1.readList()。

数据结构线性表的链式表示和实现(C语言)

/*创建一个链表，实现对链表的创建，插入/追加，删除等操作*/# include <stdio.h># include <stdlib.h># include <malloc.h>//创建一个结构体typedef struct Node{int data;struct Node * pNext;}NODE,*PNODE;//函数前置声明PNODE create_list(void); //创建一个链表void traverse_list(PNODE); //遍历整个链表bool is_empty(PNODE); //判断列表是否为空int length_list(PNODE); //返回链表的长度bool insert_list(PNODE, int , int); //在链表中插入元素bool delete_list(PNODE, int, int *);//删除链表中的某个元素，并且返回被删除的元素的值。

void sort_list(PNODE); //对链表进行排序int main(void){//初始化头指针变量PNODE pHead = NULL;int val;//创建一个链表，将头结点的指针返回，保存到头指针变量中pHead = create_list();//判断这个链表是否为空/*if( is_empty(pHead) ){printf("这个链表为空\n");}else{printf("链表不为空\n");}*///查看元素的个数printf("该链表元素的个数为：%d\n",length_list(pHead));//遍历整个链表printf("遍历整个链表：");traverse_list(pHead);//插入元素printf("在第3个元素前插入一个99的值：");insert_list(pHead, 3, 99);traverse_list(pHead);//对链表进行排序printf("对链表进行升序排序：");sort_list(pHead);traverse_list(pHead);//删除链表中的元素printf("删除第三个位置的值：");delete_list(pHead, 3, &val);//遍历这个链表traverse_list(pHead);return 0;}/*常见一个链表@param void@return pHead 头指针*/PNODE create_list(void){int val; //用于保存用户输入的值int i; //for循环自增变量int data;//创建头结点PNODE pHead = (PNODE)malloc(sizeof(NODE));if(NULL == pHead){printf("动态内存创建失败\n");exit(-1);}PNODE pTail = pHead;pTail -> pNext = NULL;printf("需要创建元素的个数len=");scanf("%d",&val);for(i = 0; i < val; ++i){printf("请输入第%d个元素：", i + 1);scanf("%d",&data);//创建这个节点PNODE pNew = (PNODE)malloc(sizeof(NODE));if(NULL == pNew){printf("动态内存创建失败\n");exit(-1);}pNew -> data = data;pNew -> pNext = NULL;pTail -> pNext = pNew;pTail = pNew;}return pHead;}/*遍历一个链表@param PNODE 头指针@return void*/void traverse_list(PNODE pHead){PNODE p;p = pHead;if( is_empty(pHead) ){printf("这个链表为空\n");return;}while(NULL != p->pNext){p = p->pNext;printf("%d ",p->data);}printf("\n");}/*判断链表是否为空@param PNODE pHead 头指针@return bool*/bool is_empty(PNODE pHead){if( NULL == pHead -> pNext){return true;}else{return false;}}/*返回链表的长度@param PNODE pHead 头指针@return int i 指针的长度*/int length_list(PNODE pHead){PNODE p;int i = 0;if( is_empty(pHead) ){printf("链表为空。

C语言数据结构之线性表的链式存储结构

C语⾔数据结构之线性表的链式存储结构1.什么是线性表的链式存储结构 —链表存储结点：包括元素本⾝的信息，还有元素之间的关系逻辑的信息这个结点有：数据域和指针域⼀个指针域：指向后继结点，单链表⼆个指针域：指向前继结点，还有⼀个指向后继结点双链表2.原理是：s=(LinkNode *)malloc(sizeof(LinkNode));//s->data=e; //这⾥赋值了s->next=p->next; //p->next=s; //这⾥把指针s给到了p结点a-> 结点b -> 结点c->结点d第⼀个数据：p->data ：a 对应的 p->next是存储地址为 007531F0第⼆个：p->data ：b 对应的 p->next是存储地址为：：00753200第三个数据：p->data ：c 对应的 p->next是存储地址为： 00753210…最后⼀个数据：p->data ：e 对应的 p->next是存储地址为：00000000这样在输出时：利⽤p=p->next进⾏循环p->next是第⼀个，p->next->next 是第⼆个p->next->next->next 是第三个while(p!=NULL){printf("%c",p->data);p=p->next;printf("地址变化：%p\n",p);}这⾥的循环使p=p->next.(⼀直指向下⼀个结点)while(j<i-1 && p!=NULL) //指针p不为空，当i=2,3,4,5执⾏下⾯语句{j++; //执⾏p=p->next; //// printf("%p",p);}#include<stdio.h>#include<malloc.h>typedef char ElemType;typedef struct LNode{ElemType data;struct LNode *next; //指针位置}LinkNode;bool ListInsert(LinkNode *&L,int i,ElemType e){int j=0;LinkNode *p=L,*s; //参数指针 P,s结构体指针，指针赋值，赋值的是地址 if(i<=0)return false;while(j<i-1 && p!=NULL) //指针p不为空，当i=2,3,4,5执⾏下⾯语句{j++; //执⾏p=p->next; //// printf("%p",p);}if(p==NULL)return false;else{s=(LinkNode *)malloc(sizeof(LinkNode));s->data=e; //这⾥赋值了s->next=p->next; //p->next=s; //这⾥把指针s给到了p.printf("%p\n",s->next);printf("%p\n",p->next);return true;}}void DispList(LinkNode *L){LinkNode *p=L->next; //这个L->next就是p->next，//不为空，// p->next指向了s, 返回 a,循环// p->next->next, ,指向了 b结点，引⽤的是 b// p->next->next->next ，指向c结点。

线性表--链表（C语言实现）

线性表--链表（C语⾔实现）线性表是最基本的⼀种数据结构，是0个以上数据元素的有限序列。

由线性表的定义，我们可以得出线性表的两个特性。

⾸先它是⼀个序列，即元素之间是有序的。

除了第⼀个元素外，每⼀个元素都有且只有⼀个直接前驱元素；除了最后⼀个元素外，每⼀个元素都有且只有⼀个直接后驱元素。

也就是说，元素之间是⼀对⼀连接起来的。

其次它的元素是有限的，最少为0个，当元素为0个时，称之为空表。

根据线性表的序列特性，计算机可以⽤两种⽅法来实现线性表：1、开辟⼀块连续的内存，将数据元素⼀个⼀个放⼊进去，说⽩了也就是⽤数组来实现线性表。

这种实现⽅式对于读数据来说⽐较快，但对于插⼊和删除来说，就⽐较尴尬了。

⼀般来说，不会⽤这种⽅法实现线性表这种数据结构。

2、链表。

（重点来了）链表是⼀种递归的数据结构。

链表中的元素为结点，结点由两部分组成，⼀是存储元素值的数据域、⼆是存储指向下⼀个结点地址的指针域（或者是NULL），如果该结点的指针域为NULL，则称该结点为尾结点，也就是链表的结尾。

以下简单的代码让同学们更加直观的感受⼀下链表。

#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef int ElemType;typedef struct node{ ElemType data; struct node* next;}Node, *PNode;// 声明创建链表函数PNode CreateList(void);// 声明遍历链表函数void PrintfList(PNode List);int main(){ PNode List = CreateList(); PrintfList(List); getchar(); return 0;}PNode CreateNode(){ PNode newNode = (PNode)malloc(sizeof(Node)); if (newNode == NULL) { printf("out of memory.\n"); exit(1); } newNode->next = NULL; return newNode;}PNode CreateList(void){ int length; //链表个数，作为循环结束的条件 ElemType data; //链表结点数据域的值 PNode Head = CreateNode(); PNode s = Head; printf("输⼊链表个数："); scanf_s("%d", &length); for (int i = 1; i <= length; i++){ PNode P = CreateNode(); printf("第%d个结点的data值：", i); scanf_s("%d", &data); while (s->next) { s = s->next; } P->data = data; s->next = P; } getchar(); printf("创建链表成功\n"); return Head;}void PrintfList(PNode List){ PNode P = List->next; printf("链表为:"); if (P == NULL) { printf("链表为空"); } while (P != NULL){ printf("%d", P->data); P = P->next; } printf("\n");}。

2-2基于链式存储的线性表的表示与实现

2-2基于链式存储的线性表的表⽰与实现2.4 基于链式存储的线性表的表⽰与实现（链表）⼀、线性表的链式存储结构线性表中的数据元素存放于内存分散的位置上。

由许许多多的结点链接⽽成。

结点 = 数据部分 + 指针(指向线性表中下⼀个结点的位置)头指针（不带头结点）头指针（带头结点）头结点①next 域存放什么？最后结点的标志：p->next=NULL 头指针是什么？参见P27图例，看书5分钟… …结点的动态配置，通过标准函数⽣成的，即p=( LNode*)malloc(sizeof(LNode));//函数malloc分配了⼀个类型为LNode的结点变量的空间，并将其⾸地址放⼊指针变量p中。

//函数free(p)释放所指的结点变量空间。

③⾮随机存取:取链表中第i个元素：设单链表的长度为n，要查找表中第i个元素,即第i个结点，仅当1≦i≦n时，i的值是合法的。

其算法如下：LNode* Getnode(LNode *L，int i) //L是带头结点的链表{LNode * p; int j;p=L; j=0; //初始化，p指向头结点，j为计数器while(p!=NULL&&j{ p=p->next;j++;}if (p==NULL || j>=i)printf(“第i个元素不存在！”);return p;}思考：（1）如果调⽤Getnode(L,0)，结果如何？（2）⽐较：P29算法（3）时间复杂度：⼆、单链表的操作算法创建⼀个空的单链表求单链表的长度插⼊⼀个元素//最基本的操作删除⼀个元素//最基本的操作取某个位置的元素查找元素找某个元素的后继找某个元素的前驱两个链表合并……（1）插⼊运算假设1：在*p之后插⼊新结点*s：（插⼊在链表中间）单链表p插⼊结点图⽰：假设2：在*p之前插⼊？时间复杂度？假设3：插⼊在链表中第⼀个位置呢？假设4：如果链表是⼀个空表呢？特殊头结点LStatus ListInsert_L(LNode *L, int i, ElemType e){//在带头结点的单链表L中第i个位置插⼊元素eLNode *pre,*s;pre=Getnode(L,i-1); //找到第i-1个结点s=(LNode*)malloc (sizeof (LNode)); //⽣成新结点s->data=e;s->next=pre->next; pre->next=s; //插⼊L中return OK;}⽐较：不带头结点的单链表的插⼊操作if(L= =NULL) S->next=NULL;L=S; //空表if(i= =1) S->next=L; L=S; //在第⼀个位置插⼊if(i>1) P=Getnode(L,i-1); S->next=P->next;P->next=S;（2）删除运算//删除*p的后继结点：//删除*P？Status ListDelete_L(LNode *L, int i, ElemType &e){ //在带头结点的单链线性表L中,删除第i个结点，并由e返回其值LNode *pre,*r;pre=Getnode(L,i-1); //找到第i-1个结点，即第i个节点的前⼀个结点prer=pre->next;pre->next=r->next; //删除并释放结点e=r->data;free(r);return OK;}删除P结点？（3）查找运算两种算法：status Getnode(Linklist L，int i, ElemType &e)LNode* Getnode(LNode *L，int i)（4）建⽴单链表链表是⼀个动态的结构，它不需要预先分配空间，因此⽣成链表的过程是⼀个结点“逐个插⼊”的过程。

数据结构算法代码实现——线性表的链式表示与实现（单链表）（三）

数据结构算法代码实现——线性表的链式表⽰与实现（单链表）（三）线性表的链式表⽰使⽤⼀组任意的存储单元存储线性表的数据元素（这些存储单元可以是连续也可以是不连续的）。

常见的链式表：单链表、静态链表、循环链表、双向链表。

链表的存储⽅式和特点我们修改⼀下上⼀篇⽂章的例⼦：假如现在是新⽣⼊校，按照新⽣的先来后到编号1-6，先到的同学可以随意选择床铺，但是需要记住下⼀位同学的床铺号（1舍友记住2舍友床铺号，2舍友记住3舍友床铺号，依次类推）。

此时⽆形的就把同学构成了⼀条链表。

链表的存储⽅式也于此类似，下⾯讨论⼀下链表的特点：(1)数据元素的逻辑顺序和物理顺序不⼀定相同。

(2)在查找数据元素时，必须从头指针开始依次查找，表尾的指针域指向NULL。

(3)在特定的数据元素之后插⼊或删除元素，不需要移动数据元素，因此时间复杂度为 O(1)。

(4) 存储空间不连续，数据元素之间使⽤指针相连，每个数据元素只能访问周围的⼀个元素。

(5)长度不固定，可以任意增删。

在来看下链表中的结点：结点是数据元素信息和指⽰存储位置信息这两部分的组成，这两部分信息也称作数据元素的存储映像。

结点包括了两个域：存储数据元素data是数据域，⽤来存储位置信息next是指针域。

注意：为了增强程序可读性，通常在链表第⼀个结点之前我们会加⼀个头结点，头结点的数据域可以不存储任何信息，也可以存储线性表的长度等附加信息。

另外，有头结点的好处是便于在第⼀个结点做插⼊和删除时不需要做特殊的处理。

下⾯来看单链表单链表的存储结构//----线性表的单链表存储结构（课本28页）---typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;单链表的基本操作（C语⾔）基本操作包括了教材19页的12个操作，其中的操作也实现了教材中的2.8，2.9，2.10算法。

C语⾔代码：1. 头⽂件请参考顺序表⽂章2. 在给出基本操作代码：//----单链表的存储结构（课本28页）---typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;//-----线性表的链式之单链表的基本操作(12个) *///1,Status InitList(LinkList *L){ /* 操作结果：构造⼀个空的线性表L(默认带头结点) */*L =(LinkList)malloc(sizeof(LNode)); //产⽣头结点，并初始化给头指针。

数据结构线性表链表的C语言实现

/*非递减冒泡排序函数*/ int maopao(LinkList &L) {
int i,j,t,n; LinkList p,p0;
p0=L; n=GetLength(L); for(j=1;j<=n-1;j++)
{ p0=p0->next; p=p0; for(i=1;i<=n-j;i++) { if(p->num>p->next->num) { t=p->num; p->num=p->next->num; p->next->num=t; } p=p->next; } }
LinkList p,p0; if(L==NULL) InitList(L); p0=L; printf("请输入链表长度\n"); scanf("%d",&i); printf("\n 请输入%d 个数\n",i); for(;i>0;i--) { p=(LN)malloc(LEN); p->next=NULL; scanf("%d",&p->num); p0->next=p; p0=p; } }
*0 结束程序\n");
int main() {
int i,j,k; LinkList L; L=NULL;
printf(" 编写此程序目的是自我学习线性表链表 \n");
printlin();
while(1) {
int t; scanf("%d",&t); if(t!=0) if(t==1||GetLength(L)!=0) { switch(t) {

实验二：线性表的链式表示和实现

实验二：线性表的链式表示和实现一、实验目的：1.掌握线性列表链式存储结构的表达与实现2．掌握对链表进行创建、插入、删除和查找等操作的算法。

3．掌握算法的设计与分析过程。

4.进一步熟悉VC++开发环境，熟悉应用程序的设计过程，掌握程序编辑、调试和集成的方法和技巧。

二、实验要求：1.采用教材中C语言描述的单链表存储结构，模块化设计流程，设计高效算法完成各种操作任务，并根据实际数据实现各种操作。

2．完成程序编写，调试成功后，书写实验报告。

三、实验任务：1．创建有n（n为正整数）数据元素的单链表，数据从键盘输入。

2．查找第i个结点，找到返回其值，否则返回0；3．对已经创建的单链表分别进行插入结点操作，在第i 个元素之前插入1个结点。

4.删除节点并删除第i个节点的元素。

5.在本地反转单链表。

6．将链表按值的奇偶数分解成两个链表。

要求：创建单链表后，其他操作可以是任意选择进行的。

（考虑设计菜单调用各功能模块）四、设计指南：1．结点的定义#include#includetypedefintdatatype;typedefstructnode{datatypedata;structnode*n ext;}lnode,*linklist;2．将复杂的问题分解成若干个相对容易的小问题，并设计好解决每个小问题的函数的函数名、入口参数及其返回值；设计出各个函数的程序框架及完整的主函数程序。

（注：每个功能一个函数）例如：//输出链表数据voiddisplay（linklistl）{linklistp；p=l->next；第1页/共3页而（p）{printf（\p=p->next；}printf(\}//单链表初始化linklistlistinit(linklistl){l=（linklist）malloc（sizeof（lnode））；l->next=null；returnl;}//创建单链表linklistlistcreate(linklistl,inta){inti;linklistp；//具体操作请大家自己完成display(l);returnl;}voidlistsearch（）{}//单链表插入LinkListInsert（linklistl）{linklistp,q;p=l;//具体操作请填写显示（L）；returnl；}//单链表删除linklistlistdelete(linklistl){linklistp,q;p=l;//请自行完成具体操作voidmain(){第2页，共3页inti;inta,b,c;linklistl;l=listinit(l);while(1){printf(\单链表*****\\n\printf(\创建*****\\n\printf(\查找*****\\n\printf(\插入*****\\n\printf(\删除*****\\n\printf(\退出*****\\n\printf(\请输入您的选择：\\n\scanf(\switch(i){case1:printf(\请输入元素个数：\\n\scanf(\listcreate(l,a);break;case2:listsearch();break;case3:listinsert(l); break;case4:listdelete(l);display(l);break;case0:exit(0);default:printf(\您的输入有误，请重新输入!\\n\}}}第3页，共3页。

线性表的链式表示和实现讲解

思路：要存取第i个数据元素，必须从头指针起一直找到该结点的指针p，然后才能执行 p->data=new_value 。
访问第i个数据元素的操作函数可写为：
Status GetElem_L(LinkList L, int i, ElemType e) {p=L->next; j=1; //带头结点的链表
Q1：第一行的LNode 与最后一行的LNode是不是一回事？
A1：不是。前者LNode是结构名，后者LNode是对整个 struct类型的一种“缩写”，是一种“新定义名”，它只是对现有类型名的补充，而不是取代。
10
Q2：那为何两处要同名(LNode和LNode）？太不严谨了吧？
A2：同名是为了表述起来方便。因为描述的对象相同，方便阅读和理解。 Q3：结构体中间的那个struct LNode是何意？
(1) 链式存储结构特点：其结点在存储器中的位置是随意的，即逻辑上相邻的数据元素在物理上不一定相邻。
如何实现？通过指针来实现！
让每个存储结点都包含两部分：数据域和指针域
样式：数据指针或指针数据指针
数据域：存储元素数值数据
指针域：存储直接后继或者直接前驱的存储位置
设计思想：牺牲空间效率换取时间效率 3
13
（2）单链表的插入（重点）
在链表中第i个位置前插入一个元素x 的示意图如下：
p
p
ai-1
ai
ai-1
ai
p->next
插入X
第2章线性表
2.1 线性表的逻辑结构 2.2 线性表的顺序表示和实现 2.3 线性表的链式表示和实现 2.4 一元多项式的表示和相加
1
2.3 线性表的链式表示和实现

线性表的链式表示C++代码

/*****************************************************************线性表链式表示和实现(严版<数据结构>2.3)******************************************************************/#include <stdio.h>#include <stdlib.h>/* 函数结果状态代码 */#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1 //不可实行#define OVERFLOW -2 //溢出/* STATUS是函数的类型，其值是函数结果状态代码 */typedef int STATUS;typedef int ELEMTYPE;/* 线性表的单链表存储结构 */typedef struct LNode {ELEMTYPE data;struct LNode *next;}LNode, *LinkList;#define NUMARRAY 10STATUS GetElem_L(LinkList L, int i, ELEMTYPE *e);STATUS ListInsert_L(LinkList *L, int i, ELEMTYPE e);STATUS ListDelete_L(LinkList *L, int i, ELEMTYPE *e);STATUS CreateList_L(LinkList *L, ELEMTYPE listArray[], int n); void MergeList_L(LinkList *La, LinkList *Lb, LinkList *Lc);int ListLength_L(LinkList L);void DestroyList_L(LinkList *L);int main(void){LinkList L, L2, L3;ELEMTYPE e, listArray[NUMARRAY] = {0};int i, listLen;printf("请输入10个整数:");for(i = 0; i < NUMARRAY; i++)scanf("%d", &listArray[i]);/* 测试CreateList_L与GetElem_L */CreateList_L(&L, listArray, NUMARRAY);printf("测试CreateList_L与GetElem_L: ");for(i = 1; i <= ListLength_L(L); i++) { GetElem_L(L, i, &e);printf("%d ", e);}printf("\n");/* 测试ListInsert_L */ListInsert_L(&L, 2, 5);printf("测试ListInsert_L: ");for(i = 1; i <= ListLength_L(L); i++) { GetElem_L(L, i, &e);printf("%d ", e);}printf("\n");/* 测试ListDelete_L */ListDelete_L(&L, 2, &e);printf("测试ListDelete_L: ");for(i = 1; i <= ListLength_L(L); i++) { GetElem_L(L, i, &e);printf("%d ", e);}printf("\n");/* 测试MergeList_L */printf("请输入5个整数:");for(i = 0; i < 5; i++)scanf("%d", &listArray[i]);CreateList_L(&L2, listArray, 5);MergeList_L(&L, &L2, &L3);printf("测试MergeList_L: ");for(i = 1; i <= ListLength_L(L3); i++) { GetElem_L(L3, i, &e);printf("%d ", e);}printf("\n");/* 测试DestroyList_L */printf("测试DestroyList_L: ");DestroyList_L(&L3);printf("\nListLength_L(L3) = %d\n", ListLength_L(L3));return 0;}/***************************************************************L为指向带头结点的单链表的指针。

线性表的链式表示和实现(简单的插入和删除功能)

#include<iostream>using namespace std;#define ERROR 0#define OK 1class LNode{private:int num;LNode *next;public:friend LNode* LNodeCreate(); //创建链式线性表friend int GetElem(LNode *H,int i); //L为带头结点的单链表的头指针，当第i个元素存在，输出其值friend int LNodeInsert(LNode *H,int i,int e); //L为带头结点的单链表的头指针，在dii个位置插入元素efriend int LNodedelete(LNode *H,int i); //删除线性表中第i个元素};/*//从头到尾创建线性表LNode* LNodeCreate(){LNode *q,*H,*p;int size;cout<<"请输入线性表元素的个数：";cin>>size;cout<<"请输入线性表这"<<size<<"个元素：";q=H=new LNode;for(int i=0;i<size;i++){p=new LNode;cin>>p->num;H->next=p;H=p;}H->next=NULL;H=q->next;cout<<"刚创建的线性表为：";for(p=H;p!=NULL;p=p->next)cout<<p->num<<" ";cout<<endl<<endl;return H;}*///从尾到头创建线性表LNode* LNodeCreate(){LNode *L=new LNode,*p;L->next=NULL;int size,e;cout<<"请输入线性表元素的个数：";cin>>size;cout<<"请输入线性表这"<<size<<"个元素：";for(int i=size;i>0;--i){p=new LNode;cin>>e;p->num=e;p->next=L->next;L->next=p;}L=p;cout<<"刚创建的线性表为：";for(p=L;p!=NULL;p=p->next)cout<<p->num<<" ";cout<<endl<<endl;return L;}int GetElem(LNode *H,int i){LNode *p; int j=1; //j为计数器p=H;while(p&&j<i){p=p->next;++j;}if(!p&&j>i) return ERROR;cout<<"取出的值为："<<p->num<<endl<<endl;return OK;}int LNodeInsert(LNode *H,int i,int e){LNode *p,*s; int j=1;p=H;while(p&&j<i-1){p=p->next;++j;}s=new LNode;s->num=e;s->next=p->next;p->next=s;cout<<"新的线性表为：";for(p=H;p!=NULL;p=p->next)cout<<p->num<<" ";cout<<endl<<endl;return OK;}int LNodedelete(LNode *H,int i){ LNode *p=H,*q;int j=1;while(p&&j<i-1){p=p->next;++j;}if(!p&&j>i) return ERROR;q=p->next;p->next=q->next;delete(q);cout<<"新的线性表为：";for(p=H;p!=NULL;p=p->next)cout<<p->num<<" ";cout<<endl<<endl;return OK;}int main(){LNode *H;int m;H=LNodeCreate();cout<<"请输入你要取出的元素的位置："; cin>>m;GetElem(H,m);int i,e;cout<<"请输入你要插入的元素的位置："; cin>>i;cout<<"请输入你要插入的元素："; cin>>e;LNodeInsert(H,m,e);int j;cout<<"请输入你要删除的元素的位置："; cin>>j;LNodedelete(H,j);return 0;}。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

p=p->next;
i++;
}while(p!=NULL);
returnOK;
}Байду номын сангаас
main()
{
structnode *head;
chara;
intn;
elemtypee;
while(1)
{
printf("1:构造一个线性表\n2:销毁线性表\n3:将已有线性表置为空表\n4：判断线性表是否为空\n5:计算已有线性表中数据元素的个数\n");
returnOK;
}
statusgetelem(node *head,inti,elemtype&e)
{
node*p;
p=head->next;
intn=1;
if(i<1)
{
printf("输入的i值不合法\n");
returnERROR;
}
while(n<i)
{
p=p->next;
n++;
}
if(p==NULL)
#define OVERFLOW -2
typedefintstatus;
typedefintelemtype;
#include"header.h"
structnode
{
elemtypedate;
structnode *next;
};
structnode*createlist(node *head,intn)
{
if(head==NULL)
returnOK;
else
returnERROR;
}
statuslistlength(node *head)
{
inti=0;
node*p;
p=head->next;
while(1)
{
i++;
if(p->next==NULL)
break;
p=p->next;
}
printf("该线性表的表长为%d\n",i);
{
printf("输入的i值不合法\n");
returnhead;
}
structnode *p,*q;
p=head;
intj=1;
while(j<i)
{
if(p->next->next==NULL)
break;
p=p->next;
j++;
}
if(j==i)
{
q=p->next;
p->next=p->next->next;
数据结构实验线性表的链式表示和实现（源代码）
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#define TURE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INEEASLIBE -1
{
head=NULL;
free(head);
printf("线性表销毁成功\n");
}
break;
case'3':
clearlist(head);
printf("线性表以置为空表\n");
break;
case'4':
if(listempty(head)==OK)
printf("线性表为空表\n");
system("cls");
returnhead;
}
structnode*clearlist(node *head)
{
head=NULL;
returnhead;
}
statusdestroylist(node *head)
{
head=NULL;
free(head);
returnOK;
}
statuslistempty(node *head)
{
if(i==1)
{
printf("该位上的数据元素为一个元素没有直接前驱元素\n");
returnERROR;
}
structnode *p,*q;
p=head->next;
intj=1;
for(;p!=NULL;p=p->next)
{
if(j==i)
break;
q=p;
j++;
}
if(p!=NULL)
{
e=q->date;
printf("该元素有数据元素并且直接前驱元素已传递给e\n");
returnOK;
}
else
{
printf("输入的i值不合法\n");
returnERROR;
}
}
statusnextelem(node *head,inti,elemtype&e)
{
structnode *p;
printf("6:取出元素的值\n7:定位元素的位置\n8:插入新的数据元素\n9:删除某一个数据元素\na:显示该线性表中全部的元素\n");
printf("b:取出特定位置的直接前驱元素\nc:取出特定位置上直接后继元素\n0:退出\n\n\n");
scanf("%c",&a);
getchar();
p=head->next;
intj=0;
for(;p->next!=NULL;p=p->next)
{
j++;
if(i==j)
break;
}
if(p->next!=NULL)
{
e=p->next->date;
printf("该位上有后继元素且直接后继元素的值已传递给e\n");
returnOK;
}
if(p->next==NULL&&(j+1)==i)
e=q->date;
free(q);
}
if(j<i)
printf("输入的i值不合法\n");
returnhead;
}
statustrip(node *head)
{
structnode *p;
p=head->next;
inti=1;
do
{
printf("第%d位===%d\n",i,p->date);
system("cls");
switch(a)
{
case'0':
exit(0);
case'1':
printf("请输入需要创建元素的个数n\n");
scanf("%d",&n);
getchar();
head=createlist(head,n);
break;
case'2':
if(destroylist(head)==OK)
{
printf("输入的i值不合法\n");
returnERROR;
}
e=p->date;
returnOK;
}
statuslocatelem(node *head,elemtypee)
{
node*p;
inti=1;
p=head->next;
while(1)
{
if(p->date==e&&p==NULL)
if(priorelem(head,n,e)==OK)
printf("\n第%d位的直接前驱元素为%d\n",n,e);
break;
case'c':
printf("请输入需要取出直接后继元素的位数n=");
scanf("%d",&n);
getchar();
if(nextelem(head,n,e)==OK)
else
printf("线性表不为空表\n");
break;
case'5':
listlength(head);
break;
case'6':
printf("请输入需要取出元素的位数n=");
scanf("%d",&n);
getchar();
printf("\n");
getelem(head,n,e);
inti=0;
for(;i<n;)
{
p=(structnode*)malloc(sizeof(structnode));
printf("请输入创建的结点数据元素的值\n");
scanf("%d",&p->date);
getchar();
p->next=NULL;
q->next=p;
q=p;
i++;
}
printf("\n第%d位的直接后继元素为%d\n",n,e);