【c】线性表

数据对象集：线性表是N（>=0）个元素构成的有序序列,a1,a2,a3.....a(N-1),aN,a(N+1)

 线性表上的基本操作有：

⑴ 线性表初始化：Init_List(L)
初始条件：表L不存在操作结果：构造一个空的线性表

⑵ 求线性表的长度：Length_List(L)
初始条件：表L存在
操作结果：返回线性表中的所含元素的个数

⑶ 取表元：Get_List(L,i)
初始条件：表L存在且1<=i<=Length_List(L)
操作结果：返回线性表L中的第ｉ个元素的值或地址

⑷ 按值查找：Locate_List(L,x)，ｘ是给定的一个数据元素。
初始条件：线性表L存在
操作结果：在表L中查找值为ｘ的数据元素，其结果返回在L中首次出现的值为ｘ的那个元素的序号或地址，称为查找成功; 否则，在L中未找到值为ｘ的数据元素，返回一特殊值表示查找失败。

⑸ 插入操作：Insert_List(L,i,x)
初始条件：线性表L存在，插入位置正确(1<=i<=n+1,ｎ为插入前的表长)。
操作结果：在线性表L的第i 个位置上插入一个值为x 的新元素，这样使原序号为i , i+1, ... , n 的数据元素的序号变为i+1,i+2, ... , n+1，插入后表长=原表长+1。

⑹ 删除操作：Delete_List(L,i)
初始条件：线性表L存在，1<=i<=n。
操作结果：在线性表L中删除序号为i的数据元素，删除后使序号为i+1, i+2,..., n的元素变为序号为i, i+1,...,n-1，新表长＝原表长－１。

线性表的存储：顺序存储

#include<stdio.h>
#include <string.h>
#include <stdlib.h>

#define max 10
typedef struct{
    int data[max];  //数组 
    int last;        //最后一个数据在数组中的位置 
}LIST;

//初始化 
LIST * makeEmpty();
//查找，返回数据在数组中的位置，不存在返回-1
int find(int,LIST *); 
//插入，成功1，失败-1
int insert(int site,int num,LIST * Ptrl); 
//打印数据结构
void dump(LIST *); 
//删除
int del(int site,LIST * Ptrl); 

void main(void)
{
    int num;
    LIST * demo;
    demo = makeEmpty();
    
    
}

//初始化 
LIST * makeEmpty()
{
    LIST * Ptrl;
    Ptrl = (LIST*)malloc(sizeof(LIST));
    Ptrl->last = -1;    //为空时last为1 
    return Ptrl; 
}
//查找，返回数据在数组中的位置，不存在返回-1
int find(int num,LIST * Ptrl)
{
    int i=0;
    while(i<=Ptrl->last && Ptrl->data[i]!=num)
    {
        i++;
    }
    //如果i大于数据的长度，则就是没有找到 
    if(i > Ptrl->last)
        return -1;
    //返回数据的位置 
    return i; 
}
//插入，成功1，失败-1
int insert(int site,int num,LIST * Ptrl)
{
    //1、判断是否已经满了，最后的位置=长度-1
    if(Ptrl->last == max-1){
        return -1;
    } 
    //2、判断要插入的位置是否大于等于长度 site >= max
    if(site<0 || Ptrl->last >= max){
        return -1;
    } 
    //3、从最后一个数据开始移动，下一位填充上一位的数据 ,data[n+1] = data[n],data[n]=data[n-1],直到n>=site 
    int i;
    for(i=Ptrl->last;i>=site;i--)
    {
        Ptrl->data[i+1] = Ptrl->data[i];
    }
    Ptrl->data[site] = num;
    Ptrl->last += 1;
    return 1; 
} 

//打印数据结构
void dump(LIST * Ptrl){
    int i=0;
    while(i<=Ptrl->last)
    {
        printf("%d=>%d---%d
",i,Ptrl->data[i],Ptrl->last);
        i++;
    }
}
//删除
int del(int site,LIST * Ptrl)
{
    //检测删除的位置是否存在
    if(site > Ptrl->last || site<0){
        return -1;
    } 
    
    int i;
    for(i=site;i<=Ptrl->last;i++)
    {
        Ptrl->data[i] = Ptrl->data[i+1];
    } 
    Ptrl->last--;
    return 1;
} 

线性表的存储：链式存储

 　　存放数据元素信息的称为数据域，存放其后继地址的称为指针域。因此n个元素的线性表通过每个结点的指针域拉成了一个“链子”，称之为链表。因为每个结点中只有一个指向后继的指针，所以称其为单链表。

　　链表是由一个个结点构成的，结点定义如下：
　　typedef struct node{

　　　　datatype data;
　　　　struct node *next;
　　} LNode，*LinkList；

　　定义头指针变量：
　　LinkList H；

　　

#include<stdio.h>
#include <string.h>
#include <stdlib.h>

#define max 10
typedef struct list{
    int data;
    struct list * next;
}LIST; 

//初始化
LIST * initialize();
//按key查找
LIST * findByKey(int key,LIST * Ptrl);
//按value查找
LIST * findByVal(int value,LIST * Ptrl);
//插入 
int insert(int key,int val,LIST * Ptrl); 
//删除
int delete(int key,LIST * Ptrl);
//表长
int length(LIST * Ptrl);
//打印
void dump(LIST * Ptrl);

 void main(void)
 {
     LIST * demo;
     demo = initialize();
     insert(1,22,demo);
     insert(2,222,demo);
     LIST * find = findByVal(22,demo);
    //demo = initialize();
    dump(demo);
     //printf("%d",length(demo));
 }
 
//初始化
LIST * initialize()
{
    LIST * Ptrl;
    Ptrl = (LIST *)malloc(sizeof(LIST));
    if(Ptrl==NULL){
        puts("molloc fail in line 38
");
        exit;
    }
    Ptrl->next = NULL;
    Ptrl->data = 0; 
    return Ptrl;
} 
//按key查找
LIST * findByKey(int key,LIST * Ptrl)
{
    if(key==0)
    {
        return Ptrl;
    }
    
    LIST * p;
    p = Ptrl;
    int i=0;
    
    while(p!=NULL && i<key)
    {
        p = p->next;
        i++;
    }
    if(i==key){
        return p;
    }
    return NULL; 
}
//按value查找
LIST * findByVal(int value,LIST * Ptrl)
{
    LIST * p;
    p = Ptrl;
    while(p!=NULL && p->data!=value)
    {
        p=p->next;
    }        
    if(p != NULL){
        return p;
    }else{
        return NULL;
    }
}

 //插入 
int insert(int key,int val,LIST * Ptrl)
{
    LIST * p,* find;
    
    p = (LIST *)malloc(sizeof(LIST));
    if(Ptrl==NULL){
        puts("molloc fail in line 86
");
        exit;
    }
    

    find = findByKey(key-1,Ptrl);

    p->data = val;
    p->next = find->next;
    find->next = p;
    
    return 1;
}
//删除
int delete(int key,LIST * Ptrl)
{
    //检查长度的合法性
    
    //删除
    LIST * p,* find;
    p = findByKey(key,Ptrl);
    find = findByKey(key-1,Ptrl);
    find->next = p->next;
    free(p);
}
//表长
int length(LIST * Ptrl)
{
    int i=0;
    LIST * p = Ptrl;
    while(p!=NULL)
    {
        p = p->next;
        i++;
    }
    return i;
}
//打印
void dump(LIST * Ptrl)
{
    LIST * p = Ptrl;
    while(p!=NULL)
    {
        printf("%d
",p->data);
        p = p->next;
    }
}

栈的存储

    顺序存储

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define max 10

typedef struct list{
    int data[max];
    int top;
}LIST;

//初始化
LIST * initialize(); 
//判断是否为空
int isEmpty(LIST *);
//判断是否满了
int isFull(LIST *);
//出栈 
int pop(LIST *); 
//入栈 
int push(int value,LIST * Ptrl);
//打印
void dump(LIST *); 

void main(void)
{
    LIST * demo = initialize();
    push(3,demo);
    push(6,demo);
    push(9,demo);
    pop(demo);
    dump(demo);
}

//初始化
LIST * initialize()
{
    LIST * Ptrl;
    Ptrl = (LIST *)malloc(sizeof(LIST));
    if(Ptrl == NULL)
    {
        puts("malloc error!!!
");
        exit;
    }
    Ptrl->top=-1;
    return Ptrl;
}
//判断是否为空
int isEmpty(LIST * Ptrl)
{
    if(Ptrl->top == -1)
    {
        return 0;
    }
    return 1;
}

//判断是否满了
int isFull(LIST * Ptrl)
{
    if(Ptrl->top >= max-1)
    {
        return 0;
    }
    return 1;
}
//出栈 
int pop(LIST * Ptrl)
{
    if(isEmpty(Ptrl) == 0)
    {
        puts("is empty");
        exit;
    }
    
    int temp =  Ptrl->data[Ptrl->top];
    Ptrl->top--;
    return temp;
}
//入栈 
int push(int value,LIST * Ptrl)
{
    if(isFull(Ptrl) == 0)
    {
        puts("is full");
        exit;
    }
    Ptrl->top++;
    Ptrl->data[Ptrl->top] = value;
    return 1;
} 
//打印
void dump(LIST * Ptrl)
{
    if(isEmpty(Ptrl) == 0)
    {
        puts("is empty");
        exit;
    }
    
    int i;
    for(i=Ptrl->top;i>=0;i--)
    {
        printf("%d
",Ptrl->data[i]); 
    }
}

 链式村粗

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define max 10

typedef struct list{
    int data;
    struct list * next;
}LIST;

//初始化
LIST * initialize(); 
//判断是否为空
int isEmpty(LIST *);
//判断是否满了
int isFull(LIST *);
//出栈 
int pop(LIST *); 
//入栈 
int push(int value,LIST * Ptrl);
//打印
void dump(LIST *); 

void main(void)
{
    LIST * demo = initialize();
    push(2,demo);
    push(5,demo);
    push(6,demo);
    push(8,demo);
    pop(demo);
    dump(demo);
}


//初始化
LIST * initialize()
{
    LIST * Ptrl;
    Ptrl = (LIST *)malloc(sizeof(LIST));
    Ptrl->next = NULL;
    //Ptrl->data = -1;
    return Ptrl;
}
//判断是否为空
int isEmpty(LIST * Ptrl)
{
    if(Ptrl->next == NULL)
    {
        return 0;
    }
    return 1;
}

//判断是否满了
int isFull(LIST * Ptrl)
{
    
}
//出栈 
int pop(LIST * Ptrl)
{
    if(isEmpty(Ptrl)==0){
        puts("is empty");
        exit;
    }
    LIST * temp = Ptrl->next;
    int data = temp->data;
    Ptrl->next = temp->next;
    free(temp);
    return data;
}
//入栈 
int push(int value,LIST * Ptrl)
{
    LIST * temp = (LIST *)malloc(sizeof(LIST));
    temp->next = Ptrl->next;
    temp->data = value;
    Ptrl->next = temp;
    return 1;
} 
//打印
void dump(LIST * Ptrl)
{
    if(isEmpty(Ptrl)==0){
        puts("is empty");
        exit;
    }
    LIST * p = Ptrl->next;
    while(p != NULL)
    {
        printf("%d
",p->data);
        p = p->next;
    }
    
}