线性表的顺序存储和链式存储c语言实现

一.线性表的顺序存储

typedef int ElemType;
typedef struct List

{

    ElemType *data;//动态分配 ,需要申请空间

    int length;

}List;

0.完整代码

#include <stdio.h>

#include <stdlib.h>

#define MaxSize 50

#define TRUE 1

#define FALSE 0

typedef int ElemType ;

struct List

{

    ElemType *data;//动态分配 ,需要申请空间

    int length;

};

void InitList(List *p);//初始化表

int ListInsert(List *p,int i,ElemType e);//插入操作 (前插),在第i个位置插入数据e

int ListDelete(List *p,int i);//删除操作，删除第i个位置数据

int ListFindValue(List L,ElemType e);//按值查找元素e ,返回e在顺序表表的位置

int ListFindLocate(List L,int i);//按位查找第i位的值

int Empty(List L); //判空，如果表为空返回TRUE

void PrintList(List L);//输出操作 

int main()

{

    List L;

    InitList(&L);

    ListInsert(&L,,);

    ListInsert(&L,,);

    ListInsert(&L,,);

    ListInsert(&L,,);

    ListInsert(&L,,);

    PrintList(L);

    return ;

 } 

 void InitList(List *p)

 {

     p->data=(ElemType*)malloc(sizeof(ElemType)*MaxSize);

     p->length=;

 }

 int ListInsert(List *p,int i,ElemType e)

 {

     if(i< || i>p->length+)

     {

         return FALSE;//插入位置不合法

     }

     if(p->length>=MaxSize)

     {

         return FALSE;//顺序表已满

     }

     for(int j=p->length;j>=i;j--)

     {

         p->data[j]=p->data[j-];

     }

     p->data[i-]=e;

     p->length++;

     return TRUE;

 }

 int ListDelete(List *p,int i)

 {

     if(i< || i>p->length)

     {

         return FALSE;

     }

     for(int j=i;j<p->length;j++)

     {

         p->data[j-]=p->data[j];

     }

     p->length--;

     return TRUE;

  } 

  int ListFindValue(List L,ElemType e)

  {

      for(int i=;i<L.length;i++)

      {

          if(L.data[i]==e)

          {

              return i+;

        }

    }

    return FALSE;

  }

  int ListFindLocate(List L,int i)

  {

      return L.data[i-];

  }

 void PrintList(List L)

 {

     for(int i=;i<L.length;i++)

     {

         printf("%d ",L.data[i]);

     }

     printf("\n");

 }

 int Empty(List L)

 {

     if(L.length==)

     {

         return TRUE;

     }

     else

     {

         return FALSE;

     }

 }

1.初始化顺序表

void InitList(List *p)

 {

     p->data=(ElemType*)malloc(sizeof(ElemType)*MaxSize);

     p->length=;

 }

2.插入操作 ,在第i个位置插入数据e

int ListInsert(List *p,int i,ElemType e)

 {

     if(i< || i>p->length+)

     {

         return FALSE;//插入位置不合法

     }

     if(p->length>=MaxSize)

     {

         return FALSE;//顺序表已满

     }

     for(int j=p->length;j>=i;j--)

     {

         p->data[j]=p->data[j-];

     }

     p->data[i-]=e;

     p->length++;

     return TRUE;

 }

3.删除操作，删除第i个位置数据

int ListDelete(List *p,int i)

 {

     if(i< || i>p->length)

     {

         return FALSE;

     }

     for(int j=i;j<p->length;j++)

     {

         p->data[j-]=p->data[j];

     }

     p->length--;

     return TRUE;

  }

4.按值查找元素 ,返回元素在顺序表的位置

int ListFindValue(List L,ElemType e)

  {

      for(int i=;i<L.length;i++)

      {

          if(L.data[i]==e)

          {

              return i+;

        }

    }

    return FALSE;

  }

5.按位置查找元素

int ListFindLocate(List L,int i)

  {

      return L.data[i-];

  }

6.判断顺序表是否为空，为空返回TRUE

int Empty(List L)

 {

     if(L.length==)

     {

         return TRUE;

     }

     else

     {

         return FALSE;

     }

 }

7.显示顺序表

void PrintList(List L)

 {

     for(int i=;i<L.length;i++)

     {

         printf("%d ",L.data[i]);

     }

     printf("\n");

 }

二.线性表的链式存储

typedef int ElemType;

typedef struct Node{

    ElemType data;

    struct Node *next;

}Node;

0.完整代码

 #include <stdio.h>

 #include <stdlib.h>

 #define TRUE 1

 #define FALSE 0

 typedef int ElemType;

 typedef struct Node{

     ElemType data;

     struct Node *next;

 }Node;

 Node* InitNode();//初始化创建头结点

 Node* Node_HeadInsert(Node *L);//头插法建立链表

 Node* Node_TailInsert(Node *L);//尾插法建立链表

 Node* NodeInsert(Node *L,int i);//在第i个位置插入结点

 Node* NodeDelete(Node *L,int i);//删除第i个结点

 Node* NodeSearchNum(Node *L,int i);//按序号查找

 Node* NodeSearchValue(Node *L,ElemType x);//按值查找

 void PrintNode(Node *L);//显示单链表

 Node* NodeMerge(Node *p,Node *q);//合并两个递增链表 

 int main()

 {

     Node *L;

     L=InitNode();

     L=Node_TailInsert(L);

     L=NodeInsert(L,);

     PrintNode(L);

     L=NodeDelete(L,);

     PrintNode(L);

     return ;

  }

 Node* InitNode()

 {

     Node *L;

     L=(Node*)malloc(sizeof(Node));

     L->next=NULL;

     return L;

 }

 Node* Node_HeadInsert(Node *L)

  {

      Node *s;

      ElemType x;

      scanf("%d",&x);//插入结点的值

      while(x!=)

      {

          s=(Node*)malloc(sizeof(Node));

          s->data=x;

          s->next=L->next;

          L->next=s;

          scanf("%d",&x);

       }

       return L;

  }

  Node* Node_TailInsert(Node *L)

  {

      ElemType x;

      Node *s,*r=L;

      scanf("%d",&x);

      while(x!=)

      {

          s=(Node*)malloc(sizeof(Node));

          s->data=x;

          r->next=s;

          r=s;

          scanf("%d",&x);

      }

      r->next=NULL;

      return L;

 }

 Node* NodeInsert(Node *L,int i)

 {

     ElemType x;

     Node *s,*p=NodeSearchNum(L,i-);

     printf("输入插入节点的值:") ;

     scanf("%d",&x);

     s=(Node*)malloc(sizeof(Node));

     s->data=x;

     s->next=p->next;

     p->next=s;

     printf("插入完成!\n");

     return L;

 }

 Node* NodeDelete(Node *L,int i)

 {

     Node *p,*q;

     p=NodeSearchNum(L,i-);

     q=p->next;

     p->next=q->next;

     free(q);

     printf("删除完成!\n");

     return L;

 }

  Node *NodeSearchNum(Node *L,int i)

  {

      int count=;//计数

      Node *p=L->next;

      if(i==)

          return L;

     if(i<)

         return NULL;

     while(p&&count<i)

     {

         p=p->next;

         count++;

      }

      return p;

  }

  Node *NodeSearchValue(Node *L,ElemType x)

  {

      Node *p=L->next;

      while(p&&p->data!=x)

      {

          p=p->next;

      }

      return p;

  }

  void PrintNode(Node *L)

  {

      Node *p=L->next;

      printf("单链表:");

      while(p)

      {

          printf("%d ",p->data);

          p=p->next;

      }

      printf("\n");

  }

  Node* NodeMerge(Node *p,Node *q)

  {

      Node *r,*t;

      r=InitNode();

      t=r;

      while(p->next&&q->next)

      {

          if(p->next->data<q->next->data)

          {

              t->next=p->next;

              p->next=p->next->next;

              t=t->next;

          }

          else

          {

              t->next=q->next;

              q->next=q->next->next;

              t=t->next;

          }

      }

      while(p->next)

      {

          t->next=p->next;

          p->next=p->next->next;

          t=t->next;

      }

      while(q->next)

      {

          t->next=q->next;

          q->next=q->next->next;

          t=t->next;

      }

      free(p);

      free(q);

      return r;

  }

1.初始化创建头结点

Node* InitNode()

{

    Node *L;

    L=(Node*)malloc(sizeof(Node));

    L->next=NULL;

    return L;

}

2.头插法建立链表

Node* Node_HeadInsert(Node *L)

 {

     Node *s;

     ElemType x;

     scanf("%d",&x);//插入结点的值

     while(x!=)

     {

         s=(Node*)malloc(sizeof(Node));

         s->data=x;

         s->next=L->next;

         L->next=s;

         scanf("%d",&x);

      }

      return L;

 }

3.尾插法建立链表

 Node* Node_TailInsert(Node *L)

 {

     ElemType x;

     Node *s,*r=L;

     scanf("%d",&x);

     while(x!=)

     {

         s=(Node*)malloc(sizeof(Node));

         s->data=x;

         r->next=s;

         r=s;

         scanf("%d",&x);

     }

     r->next=NULL;

     return L;

}

4.在第i个位置插入结点

Node* NodeInsert(Node *L,int i)

{

    ElemType x;

    Node *s,*p=NodeSearchNum(L,i-);

    printf("输入插入节点的值:") ;

    scanf("%d",&x);

    s=(Node*)malloc(sizeof(Node));

    s->data=x;

    s->next=p->next;

    p->next=s;

    printf("插入完成!\n");

    return L;

}

5.删除第i个结点

Node* NodeDelete(Node *L,int i)

{

    Node *p,*q;

    p=NodeSearchNum(L,i-);

    q=p->next;

    p->next=q->next;

    free(q);

    printf("删除完成!\n");

    return L;

}

6.按序号查找

 Node *NodeSearchNum(Node *L,int i)

 {

     int count=;//计数

     Node *p=L->next;

     if(i==)

         return L;

    if(i<)

        return NULL;

    while(p&&count<i)

    {

        p=p->next;

        count++;

     }

     return p;

 }

7.按值查找

 Node *NodeSearchValue(Node *L,ElemType x)

 {

     Node *p=L->next;

     while(p&&p->data!=x)

     {

         p=p->next;

     }

     return p;

 }

8.显示单链表

void PrintNode(Node *L)

 {

     Node *p=L->next;

     printf("单链表:");

     while(p)

     {

         printf("%d ",p->data);

         p=p->next;

     }

     printf("\n");

 }

9.合并两个递增链表

Node* NodeMerge(Node *p,Node *q)

 {

     Node *r,*t;

     r=InitNode();

     t=r;

     while(p->next&&q->next)

     {

         if(p->next->data<q->next->data)

         {

             t->next=p->next;

             p->next=p->next->next;

             t=t->next;

         }

         else

         {

             t->next=q->next;

             q->next=q->next->next;

             t=t->next;

         }

     }

     while(p->next)

     {

         t->next=p->next;

         p->next=p->next->next;

         t=t->next;

     }

     while(q->next)

     {

         t->next=q->next;

         q->next=q->next->next;

         t=t->next;

     }

     free(p);

     free(q);

     return r;

 }

输出示例：

2020-06-27

线性表的顺序存储和链式存储c语言实现的更多相关文章

数据结构导论四线性表的顺序存储VS链式存储
前几章已经介绍到了顺序存储.链式存储顺序存储:初始化.插入.删除.定位链式存储:初始化.插入.删除.定位顺序存储:初始化 strudt student{ int ID://ID char nam ...
算法与数据结构(一) 线性表的顺序存储与链式存储(Swift版)
温故而知新,在接下来的几篇博客中,将会系统的对数据结构的相关内容进行回顾并总结.数据结构乃编程的基础呢,还是要不时拿出来翻一翻回顾一下.当然数据结构相关博客中我们以Swift语言来实现.因为Swift ...
线性表的顺序存储和链式存储的实现(C)
//线性表的顺序存储 #include <stdio.h>typedef int DataType;#define MaxSize 15//定义顺序表typedef struct { Da ...
线性表的Java实现--链式存储（单向链表）
单向链表(单链表)是链表的一种,其特点是链表的链接方向是单向的,对链表的访问要通过顺序读取从头部开始. 链式存储结构的线性表将采用一组任意的存储单元存放线性表中的数据元素.由于不需要按顺序存储,链表在 ...
c数据结构 -- 线性表之复杂的链式存储结构
复杂的链式存储结构循环链表定义:是一种头尾相接的链表(即表中最后一个结点的指针域指向头结点,整个链表形成一个环) 优点:从表中任一节点出发均可找到表中其他结点注意:涉及遍历操作时,终止条件是判断 ...
队列的顺序存储与链式存储c语言实现
一. 队列 1.队列定义:只允许在表的一端进行插入,表的另一端进行删除操作的线性表. 2.循环队列:把存储队列的顺序队列在逻辑上视为一个环. 循环队列状态: 初始时:Q.front=Q.rear=0 ...
栈的顺序存储和链式存储c语言实现
一. 栈栈的定义:栈是只允许在一端进行插入或删除操作的线性表. 1.栈的顺序存储栈顶指针:S.top,初始设为-1 栈顶元素:S.data[S.top] 进栈操作:栈不满时,栈顶指针先加1,再到栈 ...
线性表的Java实现--链式存储（双向链表）
有了单向链表的基础,双向链表的实现就容易多了. 双向链表的一般情况: 增加节点: 删除节点: 双向链表的Java实现: package com.liuhao.algorithm; publi ...
C 数据结构1——线性表分析（顺序存储、链式存储）
之前是由于学校工作室招新,跟着大伙工作室招新训练营学习数据结构,那个时候,纯碎是小白(至少比现在白很多)那个时候,学习数据结构,真的是一脸茫然,虽然写出来了,但真的不知道在干嘛.调试过程中,各种bug ...

随机推荐

我终于搞清了啥是 HTTPS 了
引言最近上海连续下了一周雨,温度一夜之间回到解放前,穿夏装的我被冻得瑟瑟发抖,躲在家里哪也不想去. 在家百无聊赖的刷着网页,看到公众号后台的留言,有同学问我 HTTP 和 HTTPS 有啥区别? 这 ...
Java实现 LeetCode 820 单词的压缩编码（暴力）
820. 单词的压缩编码给定一个单词列表,我们将这个列表编码成一个索引字符串 S 与一个索引列表 A. 例如,如果这个列表是 ["time", "me", & ...
Java实现蓝桥杯算法训练字串统计
算法训练字串统计时间限制:1.0s 内存限制:512.0MB 问题描述给定一个长度为n的字符串S,还有一个数字L,统计长度大于等于L的出现次数最多的子串(不同的出现可以相交),如果有多个,输出最 ...
Java实现 LeetCode 284 顶端迭代器
284. 顶端迭代器给定一个迭代器类的接口,接口包含两个方法: next() 和 hasNext().设计并实现一个支持 peek() 操作的顶端迭代器 – 其本质就是把原本应由 next() 方法 ...
Java实现蓝桥杯素因子去重
素因子去重问题描述给定一个正整数n,求一个正整数p,满足p仅包含n的所有素因子,且每个素因子的次数不大于1 输入格式一个整数,表示n 输出格式输出一行,包含一个整数p. 样例输入 1000 样 ...
Linux 日志轮替
日志轮替包括两个方面的内容:切割日志文件,轮换日志文件日志文件的命令规则如果配置文件中有dateext参数,那么日志文件的后缀会是日期,例如:yum.log-20200424,这样,文件名不会重叠 ...
PAT 部分A+B
正整数A的“DA(为 1 位整数)部分”定义为由A中所有DA组成的新整数PA,例如:给定A＝3862767,DA＝6,则A的“6 部分”PA是 66,因为A中有 2 个 6. 现给定A,DA,B, ...
dbca oracle 12 c 遇到ora27125
网上大部分方法是把dba组放在内核的,没有效果,可以尝试 google找到一位大神的方案,成功解决 https://oracle-admin.com/2014/01/22/ora-27125-unab ...
@bzoj - 3724@ PA2014Final Krolestwo
目录 @description@ @solution@ @accepted code@ @details@ @description@ 你有一个无向连通图,边的总数为偶数. 设图中有k个奇点(度数为奇 ...
匿名实现类&匿名对象
学习过程中经常搞不清匿名类&匿名对象怎么用,今天就把常用的方式总结一遍. 1.创建了非匿名实现类的非匿名对象 //定义USB接口 interface USB{ void inputInofo( ...

线性表的顺序存储和链式存储c语言实现

线性表的顺序存储和链式存储c语言实现的更多相关文章

随机推荐

热门专题