线性表__顺序表

    最近在备研，但是不方便将电脑带去教室，就希望这这种方式更新数据结构    
的总结，会不定时进行更新，有不对的地方欢迎指正，希望大家能如愿上岸。

一、线性表

1、顺序表的实现

（1）静态分配

#include "stdio.h"

#define maxsize 10       // 定义顺序表的最大长度
typedef struct{
    int data[maxsize] ;  // 顺序表的元素(本次定义为int型)
    int length ;         // 顺序表的当前长度
}SqList;                 // 顺序表类型定义

// 初始化顺序表
void InitLIst(SqList &L) {
    for(int i=0; i < maxsize; i++)
        L.data[i] = 0 ;     // 将初始数据默认值设为0，防止读取脏数据
    L.length = 0 ;          // 顺序表初始长度为0
}

int main(){
    SqList L ;      // 声明一个顺序表
    InitLIst(L) ;   // 初始化顺序表

    // 打印数组
    for(int j = 0;j<L.length;j++)
        printf("data[%d]=%d\n", j, L.data[j]) ;
//    printf("length为%d\n",L.length) ;

    return 0 ;
}

（2）动态分配

#include "stdio.h"
#include "stdlib.h"   // malloc

#define InitSize 15     // 默认最大容量
typedef struct{
    int *data ;         // 指示动态分配数组的指针
    int maxsize ;       // 顺序表的最大容量
    int length ;        // 顺序表的当前长度
}SeqList;

// 初始化顺序表
void InitList(SeqList &L){
    L.data = (int *) malloc(InitSize*sizeof(int )) ;  // 使用malloc函数申请一段连续的空间空间
    L.length = 0 ;
    L.maxsize = InitSize ;
}

// 动态分配数组长度
void IncreaseSize(SeqList &L, int len){
    int *p = L.data ;           // 建立p指针指向data区域
    L.data = (int *)malloc((L.maxsize+len)*sizeof(int)) ;
    for (int i = 0; i < L.length; i++) {
        L.data[i] = p[i];      // 将数组复制到新区域
    }
    L.maxsize = L.maxsize + len ;   // 改变原来的内存容量
    free(p) ;               // 释放原来的内存空间
}

int main(){
    SeqList L ;          // 声明一个顺序表
    InitList(L) ;        // 初始化顺序表
    //插入数据
    IncreaseSize(L, 3) ;
    return 0 ;
}

2、顺序表的操作

（1） 插入 ListInsert

#include "stdio.h"
#include <stdbool.h>  // bool

#define maxsize 10          // 本次采用静态分配方法
typedef struct {
    int data[maxsize] ;
    int length ;
}SqList;

// (2)元素（e）的插入
bool ListInsert(SqList &L, int i, int e){
    if( i < 1 || i > L.length+1)        // 插入位置不合法
        return false ;
    if(L.length >= maxsize)             // 当前存储空间已满
        return false ;
    for (int j = L.length; j >= i ; j--) {  // 将第i个及以后的元素后移
        L.data[j] = L.data[j-1] ;
    }
    L.data[i-1] = e ;       // data为数组，下标从0开始，插入的位序从1开始
    L.length++ ;
    return true ;
}

// 初始化顺序表
void InitList(SqList &L){
    for (int i = 0; i < maxsize; i++) {
        L.data[i] = 0 ;
    }
    L.length = 0 ;
}

int main(){
    SqList L ;              // 声明一个顺序表
    InitList(L) ;           // 初始化顺序表
    //插入代码
    ListInsert(L,3,3) ;
    return 0 ;
}

（2） 删除 ListDelete

#define maxsize 10          // 本次采用静态分配方法
typedef struct {
    int data[maxsize] ;
    int length ;
}SqList;

// 初始化顺序表
void InitList(SqList &L){
    for (int i = 0; i < maxsize; i++) {
        L.data[i] = 0 ;
    }
    L.length = 0 ;
}

// 元素（e）的删除
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++)   // 将第i个位置后的元素前移
            L.data[j-1] = L.data[j] ;
    L.length-- ;                        // 删除结束后。长度减1
    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") ;
    return 0;
}

（3）查找

• 静态分配创建查找 *
• 按位查找 GetElem*

#define maxsize 10          // 本次采用静态分配方法
typedef struct {
    int data[maxsize] ;
    int length ;
}SqList;

int GetElem(SqList L, int i ){
    if(i < 1 || i > L.length)
        return false ;
    else
        return L.data[i-1] ;
}

• 动态分配创建查找 *
• 按值查找 LocateElem*

#define InitList 10 
typedef struct {
    int *data ;
    int maxsize ;
    int length ;
}SqList;

int LocateElem(SqList L, int e){
    for(int i = 0 ;i < L.length ; i++)
        if(L.data[i] == e)
            return i+1 ;    // 数组下标为i，则位序位i+1    
    return 0 ;  
}

• int,char,double,float等基本数据据类型都可以使用（==）进行比较