线性表知识总结（高手必备）

1.线性表的定义：

线性表(List)是零个或多个数据元素的集合；

相同内型的N(>=0)个元素的有限序列(a1,a2,a3,…an)

2.性质：

线性表中的数据元素之间是有顺序的：

 a0只有一个后继，an只有一个前驱，ai(0<i<n)既有后继也有前驱;

 线性表可以逐项访问和顺序存储：

3．操作线性表

  创建线性表

 销毁线性表

删除一个元素.

添加一个元素

  清空线性表

缺点：如果链表很大，插入或删除元素会牵动很多元素的移动，时间复杂度增大。

4．线性表的存储结构

顺序存储结构（在物理内存上是相邻的） 

链式存储结构：

定义：每个节点不仅包含数据信息域，而且还需存储后继节点的指针。

单向链表包括三种内型的节点：

表头节点：

第一个节点，它不是一个数据元素，它包含指向一个数据元素的指针以及链表自身的一些信息。

数据节点：

尾节点：即数据节点，指向下一个节点的指针为空。

 

不多说了上菜吧：

 

#ifndef _SEQLIST_H_  
#define _SEQLIST_H_  
 
typedef void SeqList;          //viod 为空内型，数据分封装思想  
typedef void SeqListNode;  
 
SeqList* SeqList_Create(int capacity);  //该方法用于创建并且返回一个空的线性表  
 
void SeqList_Destroy(SeqList* list);  //该方法用于销毁一个线性表list  
 
void SeqList_Clear(SeqList* list);   //该方法用于将一个线性表list中的所有元素清空  
                                  //使得线性表回到创建时的初始状态  
 
int SeqList_Length(SeqList* list);  //该方法用于返回一个线性表list中的所有元素个数  
 
int SeqList_Capacity(SeqList* list);//该方法用于返回一个线性表list的空间容量  
                              
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);//该方法用于向一个线性表list的pos位置处插入新元素node  
                                                        //   返回值为1表示插入成功，0表示插入失败  
SeqListNode* SeqList_Get(SeqList* list, int pos);  //   该方法用于获取一个线性表list的pos位置处的元素  
                                                    //  返回值为pos位置处的元素，NULL表示获取失败  
 
SeqListNode* SeqList_Delete(SeqList* list, int pos);//该方法用于删除一个线性表list的pos位置处的元素  
                                                // 返回值为被删除的元素，NULL表示删除失败  
 
#endif  
 

seqList.C

 

#include <stdio.h>  
#include <malloc.h>  
#include "LinkList.h"  
 
typedef struct _tag_LinkList  
{  
    LinkListNode header;  
    int length;  
} TLinkList;  
 
LinkList* LinkList_Create() // O(1)  
{  
    TLinkList* ret = (TLinkList*)malloc(sizeof(TLinkList));  
      
    if( ret != NULL )  
    {  
        ret->length = 0;  
        ret->header.next = NULL;  
    }  
      
    return ret;  
}  
 
void LinkList_Destroy(LinkList* list) // O(1)  
{  
    free(list);  
}  
 
void LinkList_Clear(LinkList* list) // O(1)  
{  
    TLinkList* sList = (TLinkList*)list;  
      
    if( sList != NULL )  
    {  
        sList->length = 0;  
        sList->header.next = NULL;  
    }  
}  
 
int LinkList_Length(LinkList* list) // O(1)  
{  
    TLinkList* sList = (TLinkList*)list;  
    int ret = -1;  
      
    if( sList != NULL )  
    {  
        ret = sList->length;  
    }  
      
    return ret;  
}  
 
int LinkList_Insert(LinkList* list, LinkListNode* node, int pos) // O(n)  
{   
    TLinkList* sList = (TLinkList*)list;  
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);  
    int i = 0;  
      
    if( ret )  
    {  
        LinkListNode* current = (LinkListNode*)sList;  
          
        for(i=0; (i<pos) && (current->next != NULL); i++)  
        {  
            current = current->next;  
        }  
          
        node->next = current->next;  
        current->next = node;  
          
        sList->length++;  
    }  
      
    return ret;  
}  
 
LinkListNode* LinkList_Get(LinkList* list, int pos) // O(n)  
{  
    TLinkList* sList = (TLinkList*)list;  
    LinkListNode* ret = NULL;  
    int i = 0;  
      
    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )  
    {  
        LinkListNode* current = (LinkListNode*)sList;  
          
        for(i=0; i<pos; i++)  
        {  
            current = current->next;  
        }  
          
        ret = current->next;  
    }  
      
    return ret;  
}  
 
LinkListNode* LinkList_Delete(LinkList* list, int pos) // O(n)  
{  
    TLinkList* sList = (TLinkList*)list;  
    LinkListNode* ret = NULL;  
    int i = 0;  
      
    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )  
    {  
        LinkListNode* current = (LinkListNode*)sList;  
          
        for(i=0; i<pos; i++)  
        {  
            current = current->next;  
        }  
          
        ret = current->next;  
        current->next = ret->next;  
          
        sList->length--;  
    }  
      
    return ret;  
}  

最后

main.c

 

#include <stdio.h>  
#include <stdlib.h>  
#include "LinkList.h"  
 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */ 
 
struct Value  
{  
    LinkListNode header;  
    int v;  
};  
 
int main(int argc, char *argv[])   
{  
    int i = 0;  
    LinkList* list = LinkList_Create();  
      
    struct Value v1;  
    struct Value v2;  
    struct Value v3;  
    struct Value v4;  
    struct Value v5;  
      
    v1.v = 1;  
    v2.v = 2;  
    v3.v = 3;  
    v4.v = 4;  
    v5.v = 5;  
      
    LinkList_Insert(list, (LinkListNode*)&v1, LinkList_Length(list));//插入到链表最后  
    LinkList_Insert(list, (LinkListNode*)&v2, LinkList_Length(list));  
    LinkList_Insert(list, (LinkListNode*)&v3, LinkList_Length(list));  
    LinkList_Insert(list, (LinkListNode*)&v4, LinkList_Length(list));  
    LinkList_Insert(list, (LinkListNode*)&v5, LinkList_Length(list));  
      
    for(i=0; i<LinkList_Length(list); i++) //从链尾逐个输出链表元素  
    {  
        struct Value* pv = (struct Value*)LinkList_Get(list, i);  
          
        printf("%d\n", pv->v);  
    }  
      
    while( LinkList_Length(list) > 0 )  
    {  
        struct Value* pv = (struct Value*)LinkList_Delete(list, 0);  
          
        printf("%d\n", pv->v);  
    }  
      
    LinkList_Destroy(list);  
      
    return 0;  
}  

可以参考数据封装，指针操作等算法！

还有一个链式存储工程，见附件包！