预备知识
typedef <数据类型> <命名> typedef struct SqList
c++中的&(引用),指针指向被引用变量的存储地址
c——— malloc free函数用于申请和释放内存空间(<stdlib.h>)
malloc申请一整片连续 的内存空间,并返回一个该存储空间首地址,需要强制转换为指定的数据类型
L.data=(ElemType*)malloc(sizeof(ElemType)*InitSize)
free
c++ ———— new delete
基本数据类型可以直接用’==’判定,结构体类型数据要分别判断各个属性值是否相等
数据结构三要素 逻辑结构、存储结构、数据的运算
线性表定义:线性表是具有相同数据类型的n个数据元素的有限序列。(每个元素所占空间一样大,有次序)
notice:位序是从1开始
基本操作
初始化 InitList(&L) 构造一个空表并分配内存空间
销毁 DestoryList(&L) 销毁线性表,释放占用的内存空间
插入 ListInsert(&L,i,e) 在表的第i个位置插入元素e
删除 ListDelete(&L,i,&e) 删除第i个位置的元素,并用e返回删除元素的值
按值查找 LocateElem(L,e)
按位查找 GetElem(L,i)
其他常用操作
Length(L)
PrintList(L)
Empty(L)
顺序表(用顺序存储的方式实现的线性表)
//静态分配
#define MaxSize 10
typedef struct {
ElemType data[MaxSize]; //一整片连续的存储空间
int length;
}SqList;
//动态分配
#define ListSize 10
typedef struct{
ElemType *data;
int MaxSize; //max capacity
int length; //current length
}SqList;
初始化
//初始化一个顺序表
void InitList(SqList &L)
{
for(int i=0;i<MaxSize;i++)
{
L.data[i]=0;
}
L.length=0;
}
void InitList(SqList &L)
{
L.data=(int *)malloc(ListSize*sizeof(int));
L.length=0;
L.MaxSize=ListSize;
}
//增加动态数组长度
void IncreaseSize(SqList &L,int len)
{
int *p=L.data;
L.data=(int *)malloc((ListSize+len)*sizeof(int));
for(int i =0;i<L.length;i++)
{
L.data[i]=p[i];
}
L.MaxSize=L.MaxSize+len;
free(p);
}
插入
//将第i个元素及之后的元素后移,在位置i处插入e
bool ListInsert(SqList &L,int i,int e)
{
if(i<1||i>L.length+1||L.length>L.MaxSize)
return false;
for(int j=L.length;j>=i;j—-)
{
L.data[j]=L.data[j-1];
}
L.data[i-1]=e;
L.length++;
return true;
}
删除
bool ListDelete(SqList &L,int i,int&e)
{
if(i<1||i>L.length)
return false;
e=L.data[i-1];
for(int j=i;j<L.length;j++)
{
L.data[j-1]=L.data[j];
}
L.length—-;
return true;
}
查找
//按位查找
ElemType GetElem(SqList L,int i)
{
return L.data[i-1];
}
//按值查找
int LocateElem(SqList L,ElemType e)
{
for(int i=0;i<L.length;i++)
{
if(L.data[i]=e)
return i+1; //返回位序
}
return 0; //查找失败
}
线性表(单链表实现)
typeof struct LNode{
ElemType data;//数据域
struct LNode *next;//指针域
} LNode,*LinkList;
初始化单链表
//不带头节点
bool InitList(LinkList &L)
{
L=null;
return true;
}
//带头节点
bool InitList(LinkList &L)
{
L=(LNode*)malloc(sizeof(LNode));
if(L==null)//内存不足,分配失败
return false;
L->next=null;
return true;
}
按照位序插入
//头插法,在第i个位置插入
bool ListInsert(LinkList &L,int i,ElemType e)
{
if(i<1) //i从1开始
return false;
LNode *p;
int j=0;
p=L;
while(p!=null&&j<i-1)
{
p=p->next;
j++;
}
if(p==null)
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p-next=s;
return true;
}
bool ListInsert(LinkList &L,int i,ElemType e)
{
if(i<1)
return false;
if(i=1)
{
LNode *s=(LNode*)malloc(sizeof(LNode));
s->data=e;
s->next=L;
L=s;
return true;
}
LNode *p;
int j=1;
p=L;
while(p!=null&&j<i-1)
{
p=p->next;
j++;
}
if(p==null)
return false;
LNode *s=(LNode *)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p-next=s;
return true;
}
删除
bool ListDelete(LinkList &L,int i,ElemType e)
{
if(i<1)
return false;
LNode *p;
int j=0;
p=L;
while(p!=null&&j<i-1)
{
p=p->next;
j++;
}
if(p==null)
return false;
if(p->next==null)
return false;
LNode *q=p-next;
e=q->data;
p-next=q-next;
free(q);
return true;
}
查找
//按位查找
LNode * GetElem(LinkList L,int i){
if(i<0)
return null;
LNode *p;
p=L;
int j=0
while(p!=null&&j<i-1)
{
p=p->next;
j++;
}
return p;
}
//按值查找
LNode * LocateElem(linkList L,ElemType e)
{
LNode *p = L->next;
while(p!=null&&p->data!=e)
p=p->next;
return p;
}
单链表的建立
//尾插法
LinkList List_TailInsert(LinkList &L)
{
int x;
L=(LinkList)malloc(sizeof(LNode));
LNode *s,*r=L;
scanf(“%d”,&x);
while(x!=9999)
{
s=(LNode*)malloc(sizeof(LNode));
s->data=x;
r->next=s;
r=s;
scanf(“%d”,&x);
}
r->next=null;
return L;
}
//头插法创建单链表
LinkList_HeadInsert(LinkList &L)
{
LNode *s;
int x;
L=(LinkList)malloc(sizeof(LNode));
L->next=null;
scanf(“%d”,&x);
while(x!=9999)
{
s=(LNode*)malloc(sizeof(LNode));
s->data=x;
s->next=L->next;
L->next=s;
scanf(“%d”,&x);
}
return L;
}