线性表的实操

线性表：

• 存储同类型元素的有序序列的线性结构

  /* 线性表的顺序存储 */
  typedef struct LNode *List; // 定义了一个新类型为List，代表的是LNode *的类型
  struct LNode{
      elementType data[MAXSIZE]; // elementType代表的是任意类型
      int last; // last代表现在线性表中存有多少个元素
  };
  
  

• 线性表的链式存储实现

  • 不要求逻辑上相连的元素在物理地址上也相连；通过指针建立数据元素之间的逻辑关系

  /* 线性表的链式存储 */
  typedef struct LNode *List;
  struct LNode{
      ElementType Data;
      List next;
  };
  struct LNode L;
  List prt;
  

操作集：

1. 初始化

   /* 顺序表实现 */
   List InitEmpy(){
       List prt = (List) malloc(sizeof(struct LNode));
       prt->last = -1;
       return prt;
   }
   
   
   /* 链表实现 */
   List InitEmpy(){
       List prt = (List) malloc(sizeof(struct LNode));
       prt->data 
       prt->next = null;
       return prt;
   }
   

2. 创建顺序表

   // 向顺序表中输入元素
   int CreateList(List prt,int n){
       int len = prt->lenght;
   
       // 判断n是否大于数组剩余范围
       if(n<=0){
           printf("n值输入错误,请重新输入");
           return 0;
       }
       if(n>MAXSIZE-prt->lenght){
           printf("空间不足请重新,输入一个小于%d的数",(MAXSIZE-len));
           return 0;
       }
   
       // 输入需要保存的数字
       int a;
       for(int i = 0;i < n;i++){
           scanf("%d",&a);
           prt->data[i+len] = a;
       }
       prt->lenght = len + n;
   
       return 1;
   }
   

3. 根据位序，返回相应元素

   /* 顺序表实现 */
   elementType findElementByIndex(int index,List prt){
       // 先判断查找的位置是否合法
       if(index>MAXSIZE - 1){
           return 0;
       }
       return prt->data[index];
   }
   
   elementType findElementByIndex(int index,List prt){
       int i = 0;
       List = p; 
       p = prt
       while(prt->next != null && i < index){
           p = p->next;
       }
       if(p)
   }
   

4. 在线性表中查找element的第一次出现的位置

   /* 顺序表实现 */
   int findIndexByElement(elementType element,List prt){
        if(prt->last<0){
           return 0;
       }
       int i;
       for(i = 0; i < prt -> last;i++){
           if(prt->data[i] == element){
               return i;
           }
       }  
       return 0;
   }
   

5. 删除元素

   /* 顺序表实现 */
   int deleteByElement(elementType element,List prt){
       if(prt->last<0){
           return 0;
       }
       int index = 0;// 记录元素删除的位置
       for(int i = 0;i < prt->last;i++){
           if(prt->data[i] == element){
               index = i;
           }
       }
       if(index == 0){
           return 0;
       }
       for(int i = index;prt->last;i++){
           prt->data[i] = prt->data[i+1];
       }
       prt->last--;
       
       return 1;
   }
   

6. 插入元素

   /* 顺序表实现 */
   int insertByIndex(int index,elementType element,List prt){
       if(prt->last == MAXSIZE - 1 ){ //判断数组是否已满
           return 0;
       }
       
       if(index>prt->last || index < 0){// 判断插入位置是否正确
           return 0;
       }
       for(int i = prt->last -1; i>=index;i--){
           prt->data[i+1] =  prt->data[i];
       }
       prt->data[index] = element;
       prt->last++;
       return 1;
   }
   

7. 返回线性表长度

   int getLen(List prt){
       return prt->last;
   
   

动态顺序表：

• 结构体定义：

  /* 动态存储的顺序表(可以更改数组的大小) */
  typedef struct LNode *List; // 定义了一个新类型为List，代表的是LNode *的类型
  struct LNode{
      elementType *data; // 设置一个指向数组的指针
      int length;  // 数组的长度
      int last; // 当前数组所占用的长度
  };// 利用指针的指向性就可以直接可以更换值相等数组来更改顺序表的大小
  struct LNode L;
  List PtrL;  // 相当于定义了一个Lnode类型的指针
  

顺序表操作：

1. 初始化

   List initEmpy(){
   }
   

后插法链表简单实现：

#include "stdio.h"
# include"stdlib.h"

#define ERROR -1

// 链表结构体定义
typedef struct LNode* List;
struct LNode{
    int data;
    List next;
};

/* 链表初始化 */
List InitEmpy(){
    List prt = (List) malloc(sizeof(struct LNode));
    prt->data = 0;
    prt->next = NULL;
    return prt;
}

//ListInsert(&L,i,e)： 插入操作。在表L中的第i个位置上插入指定元素e。
int ListInsert(List L,int i,int e){
    List p = L;
    int j = 0;   // 用于计数
    // 将指针定位到插入位置的前一个
    while (p!=NULL && j < i - 1)
    {
        p = p->next; 
        j++;
    }
    if(p == NULL){
        return 0;
    }
    // 创建插入元素结构体
    List s = (struct LNode *)malloc(sizeof(struct LNode));
    if(s == NULL){
        return ERROR;
    }
    s->data = e;
    s->next = NULL;
      
    // 执行插入操作
    s->next = p->next;
    p->next = s;

    return 1;
}

// 删除位置的元素
int deleteByIndex(List L,int index){
    /*根据位序进行元素的删除*/


    if(index < 1){
        return ERROR;
    }
    List p = L;// 工作指针
    int count = 0;//计数工具
    int e; //保存删除节点的值

    while(p != NULL && count < index - 1){
        p = p->next;
        count++;
    }
    
    
    if(p == NULL){
        return ERROR;
    } 

    List s = p->next;
    p->next = s->next;
    e = s->data;


    return e;
}


// 尾插法建表
List List_TailInsert(List L){
    
    List p,s;
    p = L;
    int n; // 记录需要插入的个数
    printf("请输入你要插入数字的个数：");
    scanf("%d",&n);
    printf("请输入%d个数据",n);
    
    for (size_t i = 0; i < n ; i++)
    {   
        s = (List)malloc(sizeof(struct LNode));
        scanf("%d",&s->data);
        p->next = s;
        p = s;
        p->next = NULL; 
    }
   
    return L;   
}

int main(){
    
    List L = InitEmpy();
    
    List_TailInsert(L);

    int s;

        int i = 6,e = 9;
    int flag = ListInsert(L,i,e);
    if(flag == 1){
        printf("插入成功！！");
    }
    
    List p = L->next;
    while(p!=NULL)
    {
        printf("-%d",p->data);
        p = p->next;
    }

    printf("\n");

    s = deleteByIndex(L,5);

    if(s == ERROR){
        printf("删除失败");
    }
    p = L->next;
    printf("删除后：");
    while(p!=NULL)
    {
        printf("-%d",p->data);
        p = p->next;
    }
    printf("\n");
}