线性表及实现

顺序存储结构表示非0项

 

链表结构存储非零项

typedef struct PolyNode *Polynomial;
struct PloyNode {
    int coef;
    int expon;
    Ploynomial link;
};

 

线性表的抽象描述：

名称：线性表(List)

数据对象集：n个元素构成的有序序列

操作集：

1、List MakeEmpty()：初始化一个空线性表L

2、ElementType FindKth(int K, List L)：根据位序K，返回相应元素

3、int Find(ElementType X, List L)：在线性表L中查找X的第一次出现位置

4、void Insert(ElementType X, int i, List L)：在位序i前插入一个新元素X

5、void Delete(int i, List L)：删除指定位序i的元素

6、int Length(List L)：返回线性表L的长度n

 

线性链表顺序存储实现

typedef struct LNode *List;
struct LNode{
    ElementType Data[MAXSIZE];
    int Last;
};
struct LNode L;
List PtrL;
定义结构

1.初始化

List MakeEmpty()
{
    List PrtL;
    PtrL = (List)malloc(sizeof(struct LNode));
    PtrL->Last = -1;
    return PtrL;
}
MakeEmpty

2.查找

int Find(ElementType X, List PtrL)
{
    int i = 0;
    while(PtrL->Data[i]!=X && i<=PtrL->Last) {
        i++;
    }
    if(i>PtrL->Last) 
        return -1;
    else 
        return i;
}
Find

3.插入（第i个位置插入一个值为X的新元素）

void Insert(ElementType X, int i, List PtrL)
{
    int j;
    if(PtrL->Last <= MAXSIZE - 1) {
        printf("table full");
        return;
    }
    if(i<1||i>PtrL->Last) {
        printf("position illegal");
        return;
    }
    for(j=Ptr->Last;j>=i-1;j--) {
        Ptr->Data[j+1] = Ptr->Data[j];
    }
    PtrL->Data[i-1] = X;
    PtrL->Last++;
    return PtrL;
}
Insert

4.删除

void Delete(int i, List PtrL)
{
    int j;
    if(i<1||i>PtrL->Last) {
        printf("not exist %d element value", i);
        return;
    }
    for(j=i;j<PtrL->Last;j++)
        PtrL->Data[j-1] = PtrL->Data[j];
    PtrL->Last--;
    return;
}
Delete

 

线性表的链式存储实现

typedef strcut LNode *List;
struct LNode{
    ElementType Data;
    List *Next;
};

struct LNode L;
List PtrL;
定义

1.求表长

 1 int Length(List PtrL)
 2 {
 3     List p = PtrL;
 4     int j = 0;
 5     while(p) {
 6         p = p->Next;
 7         j++;
 8     }
 9     return j;
10 }
Length

2.按序号查找

 1 List FindKth(int K, List PtrL)
 2 {
 3     List p = PtrL;
 4     int i = 1;
 5     while(p!=NULL&&i<K) {
 6         p = p->Next;
 7         i++;
 8     }
 9     if(i==K)
10         return p;
11     else
12         return NULL;
13 }
FindKth

3.按值查找

1 List Find(ElementType X, List PtrL)
2 {
3     List p = PtrL;
4     while(p!=NULL&&p->Data!=X) {
5         p = p->Next;
6     }
7     return p;
8 }
Find

4.插入

（1）线构造一个新结点，用s指向

（2）在找到链表的第i-1个结点，用p指向

（3）然后修改指针，插入结点（p之后插入新结点是s）

 1 List Insert(ElementType X, int i, List PtrL)
 2 {
 3     List p, s;
 4     if(i == 1) {
 5         s = (List)malloc(sizeof(struct LNode));
 6         s->Data = X;
 7         s->Next = PtrL;
 8         return s;
 9     }
10     p = FindKth(i-1, PtrL);
11     if(p == NULL) {
12         printf("i error");
13         return NULL;
14     } else {
15         s = (List)malloc(sizeof(struct LNode));
16         s->Data = X;
17         s->Next = p->Next;
18         p->Next = s;
19         return PtrL;
20     }
21 }
Insert

5.删除

（1）先找到链表的第i-1个结点，用p指向

（2）再用指针s指向要被删除的结点（p的下一个结点）；

（3）然后修改指针，删除s所指结点；

（4）然后释放s所指结点的空间。

 1 List Delete(int i, List PtrL)
 2 {
 3     List p, s;
 4     if(i == 1) {
 5         s = PtrL;
 6         if(PtrL!=NULL)
 7             PtrL = PtrL->Next;
 8         else
 9             return NULL;
10         free(s);
11         return PtrL;
12     }
13     p = FindKth(i-1, PtrL);
14     if(p == NULL) {
15         printf("%d not exist", i-1);
16     } else if(p->Next == NULL) {
17         printf("%d not exist", i);
18     } else {
19         s = p->Next;
20         p->Next = s->Next;
21         free(s);
22         return PtrL;
23     }
24 }
Delete

 广义表

  • 广义表是线性表的推广
  • 对于线性表而言，n个元素都是基本的单元素
  • 广义表中，这些元素不仅可以是单元素也可以是另一个广义表
typedef struct GNode *GList;
struct GNode{
    int Tag;
    union {
        ElementType Data;
        GList SubList;
    }URegion;
    GList Next;
};
定义

 

posted @ 2018-03-15 22:15  习惯就好233  阅读(322)  评论(0)  编辑  收藏  举报