数据结构快速回顾——开篇 线性表

六月到了。开始找工作的节奏，IT方面知识储备严重欠缺，定计划，更新博客，记录自己的准备历程。

1、数据结构　　15天

2、常用算法（排序、动态规划、贪心等）　　30天

3、数据挖掘算法　　　15天

4、移动端、web端开发入门　　15天

5、操作系统　　10天

共计85天，那时将近9月，还能赶上找工作的大潮。

 

何为数据结构？数据结构用处？

一般来说，使用计算机解决一个问题的时候需要经历以下步骤：分析问题、抽象出数学模型、设计解数学模型的算法、写程序、测试、得到最终结果。

为了解决非数值型数学模型，需要使用诸如表、树、图之类的数据结构，数据结构可以帮助我们更好的表达和操作非数值计算的程序中的对象。

定义：数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

根据数据元素之间关系的特征分为以下四种基本结构：集合、线性结构（链表）、树形结构、图状结构。

根据数据元素在计算机中的存储方式分为以下两种结构：顺序存储结构和链式存储结构。

本篇主要介绍第一种数据结构——线性表
线性表是n个数据元素组成的有限序列。数据元素的内容是可变的。

线性表的顺序表示及实现：

顺序表示是指使用一组地址连续的存储单元依次存储线性表的数据元素。

//定义线性表顺序存储结构
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10 //空间不足时 增加分配的空间大小

typedef int ElemType;
typedef int Status;

typedef struct
{
        ElemType *elem;//存储数据的首地址
        int length;    //当前长度
        int listsize;//线性表容量
}SqList;

//初始化顺序表
Status InitList_Sq(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;
}

//创建顺序表
void CreateList(SqList &L, int len)
{
        if(len > LIST_INIT_SIZE)   //顺序表大小大于初始化大小，重新分配空间
        {
                L.elem = (ElemType*) realloc (L.elem, len*sizeof(ElemType));
                L.listsize = len;
        }
        printf("请输入顺序表元素: 
");
        for(int i = 0; i < len; i++)
                scanf("%d", &L.elem[i]);
        L.length = len;
        printf("建立的顺序表为:
");
        for(int i = 0; i < len; i++)
                printf("%d ", L.elem[i]);
        printf("
顺序表一共 %d 个元素。
",L.length);
}

//顺序表L的第i个位置之前插入新的元素e
Status ListInsert_Sq(SqList &L, int i, ElemType e)
{
    if(i > L.length+1 || i<1)
        return ERROR;
    if(i > L.listsize)
    {
        newBase = (ElemType*)realloc(L.elem, (L.listsize+LISTINCREMENT）*sizeof（ElemType);
        if(!newBase)
            exit(OVERFLOW);
        L.elem = newBase;
        L.listsize += LISTINCREMENT;
    }
    ElemType *q,*p;
    q = &(L.elem[i-1]);
    for(p = &(L.elem[L.length-1]); p > q; --p)
        *(p+1) = *p;
    *q = e;
    ++L.length;
    return OK;
}

//删除顺序表L的第i个位置
Status ListInsert_Sq(SqList &L, int i, ElemType& e)
{
    if(i > L.length || i<1)
        return ERROR;

    ElemType *q,*p;
    q = &(L.elem[i-1]);
    e = *q;
    p = &(L.elem[L.length-1]);
    for(;  q < p ; ++p)
        *q = *(q+1);

    --L.length;
    return OK;
}
//返回指定位置的元素
ElemType GetElem(SqList &L, int i)
{
        ElemType *e;
        if(!L.elem || i > L.length || i < 1)
                exit (ERROR);
        e = L.elem+i-1;
        return *e;
}


//定位指定元素，如果有，返回第一个匹配的元素的位置
int LocateElem(SqList &L, ElemType e)
{
        int i;
        if(!L.elem)
                exit (ERROR);
        for(i = 0; i < L.length; i++)
                if(e == L.elem[i])
                        return i+1;
        return 0;
}

 

线性表的链式表示及实现：

链表：用一组地址任意的存储单元存放线性表中的数据元素。结点(表示数据元素或数据元素的映象)=元素(数据元素的映象)+指针(指示后继元素存储位置)。

typedef  struct  LNode { 
    ElemType      data;  // 数据域 
    struct LNode   *next;  // 指针域 
} LNode, *LinkList;    

//初始化，参数为指针的引用 带头结点的链表
Status InitList(LinkList &L){ 
     L=(LinkList)malloc(sizeof(LNode)); //分配一个结点的空间
     L->next=NULL;  //将头指针指向的下一个结点（首元结点也是第一个结点）设为空
     return OK; 
} 

//取元素，L是带头结点的链表的头指针，以 e 返回第 i 个元素
Status GetElem_L(LinkList L, int i, ElemType &e) { 
    ElemType* p= L->next;   
    int j = 1;  
　　while (p && j<i) { 
　　    p = p->next;  ++j;     
    }                       
    if ( !p || j>i ) //  第 i 个元素不存在 
        return ERROR;      
    e = p->data;                 //  取得第 i 个元素 
    return OK; 
}  

//在第i个节点之前插入元素e
Status ListInsert_L(LinkList L, int i, ElemType e) { 
     // L 为带头结点的单链表的头指针，
     LinkList p = L;    
     int j = 0; 
     while (p && j < i-1) { 
            p = p->next;  ++j; // 寻找第 i-1 个结点 
      }         
      if (!p || j > i-1) 
         return ERROR;      // i 大于表长或者小于1 
      s = (LinkList) malloc ( sizeof (LNode));  // 生成新结点                          
      s->data = e; 
      s->next = p->next;      p->next = s;   
      return OK; 
 }
Status ListDelete_L(LinkList L, int i, ElemType &e) { 
// 删除以 L 为头指针(带头结点)的单链表中第 i 个结点 
    LinkList p = L;
    int j = 0;
    while(p && j < i-1)
    {
        p = p->next;
        j++;
    }
    
    if(!(p->next) || j >=i)
        return ERROR;
        
    LinkList q = p->next;
    p->next = q->next;
    e = q->data; free(q);
    return OK;
}

void ClearList(&L) { 
   // 将单链表重新置为一个空表 
    while (L->next) { 
        p=L->next;    L->next=p->next; 
         free（p）;
    } 
} 

//创建链表
void CreateList_L(LinkList &L, int n) { 
       // 逆序输入 n 个数据元素，建立带头结点的单链表 
       L = (LinkList) malloc (sizeof (LNode)); 
       L->next = NULL;    // 先建立一个带头结点的单链表 
       for (i = n; i > 0; --i) { 
         p = (LinkList) malloc (sizeof (LNode)); 
         scanf(&p->data);    // 输入元素值 
         p->next = L->next; L->next = p;  // 插入 
       }  
} // CreateList_L