数据结构笔记(二)--顺序表

线性表

线性结构:最常用,最简单的一种数据结构,其中的数据元素是有序且是有限的,其 基本特点:

1. 存在一个唯一的被称为 第一个 的数据元素
2. 存在一个唯一的被称为 最后一个 的数据元素
3. 除第一个元素外,每一个元素均有唯一 一个直接前驱
4. 除最后一个元素外,每一个元素均有唯一 一个直接后继

2.1 线性表的逻辑结构

2.1.1线性表的定义

线性表(Linear List) :是由n个数据类型相同的数据元素(结点)组成的有限序列.其中 n 为不小于0的整数.数据元素的个数 n 称为线性表的长度

相关术语:

• 当 n = 0 时, 称为空表
• 当 n > 0 时, 记为非空序列($a_0,a_1,a_2,\cdots,a_n$)
  
  • $a_0$ 称为 首节点 , $a_{n-1}$ 称为 尾结点
  • 序号小于 i 的所有元素都是 $a_i$ 的前驱 , 其中 $a_{i-1}$ 是 $a_i$ 的直接前驱
  • 序号大于 i 的所有元素都是 $a_i$ 的后继 , 其中 $a_{i+1}$ 是 $a_i$ 的直接后继

2.1.2线性表的逻辑结构

结点的种类

• 单值型元素 每个元素只有一个数据项(item)
• 记录型元素 每个元素含有多个数据项.此时称每个数据项为结点的一个域,其中唯一标识每个结点的域组(一个或多个域) 被称为‘关键字’

2.2 线性表的顺序存储

2.2.1线性表的顺序存储结构

顺序存储 :把线性表的结点 按逻辑结构依次存放在一组地址连续的存储单元里. 此时简称为 顺序表
顺序表的特点:

1. 线性表的逻辑顺序与物理顺序一致
2. 数据元素之间的关系是以元素在计算机内‘物理位置相邻’来体现
   相应的有如下类似的存储位置的关系表达式
   LOC($a_i$)=LOC($a_{i-1}$)+L ,其中 L 为 每个元素占用的存储单元
   LOC($a_n$)=LOC($a_i$)+(n-i)$\ast$L

2.2.2顺序表顺序表的描述与基本操作

基本操作:

• 创建
• 赋值
• 查找
• 修改
• 插入
• 删除
• 求长度

顺序表的C++语言描述与实现

#include <stdio.h>   // for printf
#include <stdlib.h>  // for calloc,free
#include <string.h>  // for memmove
#define SEQLIST_DEFAULT_SIZE 10
///顺序表的C++语言描述
///说明 : T 必须支持[]操作的复合类型,或者是基本类型
template<typename T>
struct SeqList {
public:
    SeqList(int size=SEQLIST_DEFAULT_SIZE) {
        init(size);
    }
    bool delete(int idxDelete,T* saveOut=NULL){
        //顺序表不为空,并且 idxDelete 在合理范围内
        if(curSize && idxDelete>=0&& idxDelete<=curSize) {
            if(saveOut)
                *saveOut=data_[idxDelete];

            for(int i=idxDelete;i<curSize;i++)
                data_[i-1]=data_[i];

            curSize--;
            return true;
        }
        return false;
    }
    void display(){
        getInfo();
        for(int i=0;i<curSize;i++){
            printf("%d elem is %d\n",i,data_[i]);
        }
    }

    int  find(T s){
        for(int i=0;i<curSize;i++) {
            if(data_[i] == s){
                return i;
            }
        }
        return -1;
    }
    //打印顺序表的信息
    void getInfo(){
        printf("SeqList[0x%x] capacity:%d, curLength:%d\n",data_,capacity,curSize);
    }
    ///插入
    bool insert(T elemInsert,int idxInsert=-1){
        ensureSize();
        if(idxInsert>0){
            for(int j=curSize-1;j>=idxInsert;j--){
                data_[j+1]=data_[j];
            }
            idxInsert--;
        }else{
            idxInsert=curSize;
        }
        data_[idxInsert]=elemInsert;
        curSize++;
        return true;
    }
    bool isFull(){
        return curSize+1>=capacity;
    }
    bool isValidIndex(int idx) {
        if(idx < 0 || idx > curSize){
            return false;
        }
        return true;
    }
    int  length(){
        return curSize;
    }
private:
    T*  data_;
    int curSize;
    int capacity;

    //increase
    void ensureSize(){
        if(curSize<capacity){
            return;
        }       
        printf("[WARN]顺序表已满,自动扩展当前大小一倍\n");
        capacity<<=1;
        T* nb=(T*)calloc(capacity,sizeof(T));
        if(nb){
            memmove(nb,data_,curSize*sizeof(T));
            free(data_);
            data_=nb;
        }
    }   
    ///创建
    int init(int nSize=SEQLIST_DEFAULT_SIZE){
        data_=(T*)calloc(nSize,sizeof(T));
        if(NULL == data_){
            return -1;
        }
        capacity=nSize;
        curSize=0;
        getInfo();
        return 0;
    }
};
#ifndef DYLIB
int main(){
    SeqList<int> isl;
    int testArr[11]={40,41,42,43,44,140,142,143,144,145,146};
    //isl.init();
    for(int i=0;i<sizeof(testArr)/sizeof(testArr[0]);i++) {
        isl.insert(testArr[i]);
    }
    isl.display();
    //insert again
    for(i=0;i<sizeof(testArr)/sizeof(testArr[0]);i++) {
        isl.insert(testArr[i]);
    }
    isl.display();
    return 0;
}
#endif