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

1.线性表的定义：

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

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

2. 性质：

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

 a0只有一个后继，an只有一个前驱，ai(0

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

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
#include
#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; (inext != 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
        {
            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
        {
            current = current->next;
        }

        ret = current->next;
        current->next = ret->next;

        sList->length--;
    }

    return ret;
}

最后

main.c

 

#include
#include
#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//从链尾逐个输出链表元素
    {
        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;
}

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

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

 

转载于:https://blog.51cto.com/lovecasy/1170954