线性表及其顺序存储结构

  线性表：是具有相同类型的n个数据元素的有限序列，其中n为表长，当n = 0时线性表是一个空表

eg：若用L命名线性表，则一般表示为

L = 

1.他是一个序列

2.多个元素时第一个元素无前驱，最后一个无后继

3.元素数据有限  

4.每个数据元素所占空间一样大

# include <stdio.h>
void test(int x) {
	x =1024;
	printf("%d",x); //1
} 
int main(void) {
	int x;
	x = 1;
	printf("%d",x); //1
	test(x);
	printf("%d",x);//1
	
}



# include <stdio.h>
void test(int &x) {
	x =1024;
	printf("%d",x);  //1024
} 
int main(void) {
	int x;
	x = 1;
	printf("%d",x); //1
	test(x);
	printf("%d",x); //1024
	
}

 抽象数据类型：是指一组性质相同的值的集合及定义在此集合上的一些操作的总称 

 抽象数据类型定义取决于它的一组逻辑特性，
 而与其在计算机内部如何表示和实现是无关的 

 线性表的抽象类型

  

 Operation  ——创销，增删改查

     Initlist(*L):初始化操作，建立一个空的线性表L

      DestroyList(&L):销毁操作。销毁线性表，并释放线性表L所占有的内存空间

     ListEmpty(L):判断线性表是否为空表，若线性表为空，返回return,  否则返回false

      ClearList(*L):将线性表清空

      GetElem(L,i,*e):将线性表L中第i个位置元素值返回给e

      LocateElem(L,e):在线性表L中查找与给定值e相等的元素，如果查找成功，

                                 返回i该元素在在表中的序号表示成功；否则，返回0表示失败

           ListInsert(*L,i,e):在线性表L中第i个位置插入新的元素e

         ListDelete(*L,i,*e):删除线性表L中第i个位置元素，并用e返回其值

          ListLength(L):返回线性表L的元素个数

两个线性表并集操作

A=A∪B

 

线性表的顺序存储结构

指的是用一段地址连续的存储单元依次存储线性表的数据元素

顺序表的实现

顺序表的静态分配

#define MaxSize 10         //定义最长长度
typedef struct{            
    ElemType date[MaxSize]; //用静态“数组”存放数据元素   ElemType:数据元素类型
    int length;             //顺序表的当前长度
}SqList;                    //顺序表的类型定义（静态分配方式）

#include <stdio.h>
#define MaxSize 10        //定义最长长度
    typedef struct{       
    int date[MaxSize];   //用静态的"数组"存放数据元素
    int length;          //顺序表的当前长度
}Sqlist;                  //顺序表的类型定义
//基本操作——初始化一个顺序表
void InitList(Sqlist &L) {            //在c++中可以&   .cpp
    for(int i = 0;i<MaxSize;i++) {
        L.date[i] = 0;
        L.length = 0;
}
}
int main()  {
    Sqlist L;        //声明一个顺序表
    Initlist(L);    //初始化顺序表
    //.....未完待续，后续操作
    return 0;
}

 

静态分配缺点：数组表长确定后无法更改

顺序表的动态分配

#define InitSize 10            //顺序表的初始长度

typedef struct {

        ElemType *date;       //指示动态分配数组的指针

        int MaxSize;               //顺序表中的最大容量

        int length;                  //顺序表中的当前长度

}SeqList;                            //顺序表的类型定义（动态分配方式）

动态申请和释放内存空间

C语言 —— malloc，free函数  头文件#include<stdlib.h>

malloc（参数）  //指明申请多大的内存空间

申请一整片连续的存储空间

 

C++——new，delete关键字

 

线性表的顺序存储结构的特点

1.随机访问，即可以在O（1）时间内找到第i个元素

2.存储密度高，每个节点只存储数据元素

3.拓展容量不方便

4.插入删除操作不方便，需要移动大量元素

 获得元素

顺序表的查找

1.按位查找

GetElem（L，i）：按位查找操作。获取表L中第i个位的值

#define MaxSize 10              //定义最大长度
typedef struct{                
    ElemType date[MaxSize];    //用静态的“数组”存放数据元素
    int length;                //顺序表的当前长度
}SqList;                       //顺序表的类型定义（静态反配方式）

ElemType GetElem(SqList L,int i) {
        if
        return L.date[i - 1];
}

#define InitSize 10            //顺序表的初始长度
typedef struct{
        ElemType *date;        //指示动态分配数组的指针
        int MaxSize;           //顺序表的最大容量
        int length;            //顺序表的当前长度
}SeqList;                      //顺序表的类型定义（动态分配方式）

ElemType GetElem(SeqList L,int i){
         return L.date[i - 1];
}

 //Status 是函数类型，其值是函数结果状态代码，如OK等
 //初始条件:顺序线性表L已存在，1 <= i <= LiatLength(L)
 //操作结果：用e返回L中第i个数据元素的值
 Status GetElem(SqList L,int i,ElsmType *e) {
       if(L.length = 0|| i < 1|| i>L.length)
       {
           return ERROR;
       }
        *e = L.date(i - 1);
        return OK;
 } 

2.按值查找

LocateElem(L,e):按值查找操作。在表L中查找具有给定关键字值的元素

#define InitSize 10        //顺序表的初始长度
typedef struct{            
    ElemType *date;        //指示动态分配数组的指针
    int MaxSize;           //顺序表中的最大容量
    int length;            //顺序表的当前长度
}SeqList;                  //顺序表的数据类型（动态分配方式）

int LocateElem(SeqList L,ElemType e) {
    for(int i = 0;i < L.length;i++) {
        if(L.data[i]==e)           //结构体不可==
            return i+1;    //数组下标为i的元素等于e，返回其位序i+1
    return 0;              //退出循环说明查找失败
}

总结

 

插入操作  

ListInsert（*L，i，e），在线性表L中第i个位置插入新元素e

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10        //定义最长长度
typedef struct{
	int date[MaxSize];
	int length;
}SqList;
void ListInsert(SqList &L,int i,int e) 
{
	int j = L.length;
	for(j = L.length;j >= i;j--) {
		L.date[j] = L.date[j-1];
	
	}
		L.date[i-1]=e;
		L.length++;
}
int main(){
	SqList L;
//	InitLIst(L);
	ListInsert(L,3,3);

}

当输入的i不符合[1，L.length]时用以下程序判断

 

删除操作

#include <stdio.h>
#define MaxSize 10        
typedef struct{
	int date[MaxSize];
	int length;
}SqList;
bool ListDelete(SqList &L,int i,int &e) {
	if(i<1||i>L.length) 
		return false;
		e=L.date[i-1];
	for(int j = i;j < L.length;j++) 
		L.date[j-1]=L.date[j];
	L.length--;
	return true;	
} 
int main(){
	SqList L;
	InitList(L);   //初始元素 
	int e = -1;
	if(ListDelete(L,3,e))
		printf("已删除第3个元素，删除元素为=%d\n",e);
	else
		printf("位序i不合法，删除失败\n");	
}

删除操作的时间复杂度

 插入和删除