一.线性表的顺序存储

  1. typedef int ElemType;
    typedef struct List
  2. {
  3.     ElemType *data;//动态分配 ,需要申请空间
  4.     int length;
  5. }List;

0.完整代码

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #define MaxSize 50
  4. #define TRUE 1
  5. #define FALSE 0
  6. typedef int ElemType ;
  7. struct List
  8. {
  9.     ElemType *data;//动态分配 ,需要申请空间
  10.     int length;
  11. };
  12.  
  13. void InitList(List *p);//初始化表
  14. int ListInsert(List *p,int i,ElemType e);//插入操作 (前插),在第i个位置插入数据e
  15. int ListDelete(List *p,int i);//删除操作，删除第i个位置数据
  16. int ListFindValue(List L,ElemType e);//按值查找元素e ,返回e在顺序表表的位置
  17. int ListFindLocate(List L,int i);//按位查找第i位的值
  18. int Empty(List L); //判空，如果表为空返回TRUE
  19. void PrintList(List L);//输出操作 
  20.  
  21. int main()
  22. {
  23.     List L;
  24.     InitList(&L);
  25.     ListInsert(&L,,);
  26.     ListInsert(&L,,);
  27.     ListInsert(&L,,);
  28.     ListInsert(&L,,);
  29.     ListInsert(&L,,);
  30.     PrintList(L);
  31.     return ;
  32.  } 
  33.  
  34.  void InitList(List *p)
  35.  {
  36.      p->data=(ElemType*)malloc(sizeof(ElemType)*MaxSize);
  37.      p->length=;
  38.  }
  39.  
  40.  int ListInsert(List *p,int i,ElemType e)
  41.  {
  42.      if(i< || i>p->length+)
  43.      {
  44.          return FALSE;//插入位置不合法
  45.      }
  46.      if(p->length>=MaxSize)
  47.      {
  48.          return FALSE;//顺序表已满
  49.      }
  50.      for(int j=p->length;j>=i;j--)
  51.      {
  52.          p->data[j]=p->data[j-];
  53.      }
  54.      p->data[i-]=e;
  55.      p->length++;
  56.      return TRUE;
  57.  }
  58.  
  59.  int ListDelete(List *p,int i)
  60.  {
  61.      if(i< || i>p->length)
  62.      {
  63.          return FALSE;
  64.      }
  65.      for(int j=i;j<p->length;j++)
  66.      {
  67.          p->data[j-]=p->data[j];
  68.      }
  69.      p->length--;
  70.      return TRUE;
  71.   } 
  72.  
  73.   int ListFindValue(List L,ElemType e)
  74.   {
  75.       for(int i=;i<L.length;i++)
  76.       {
  77.           if(L.data[i]==e)
  78.           {
  79.               return i+;
  80.         }
  81.     }
  82.     return FALSE;
  83.   }
  84.  
  85.   int ListFindLocate(List L,int i)
  86.   {
  87.       return L.data[i-];
  88.   }
  89.  
  90.  void PrintList(List L)
  91.  {
  92.      for(int i=;i<L.length;i++)
  93.      {
  94.          printf("%d ",L.data[i]);
  95.      }
  96.      printf("\n");
  97.  }
  98.  
  99.  int Empty(List L)
  100.  {
  101.      if(L.length==)
  102.      {
  103.          return TRUE;
  104.      }
  105.      else
  106.      {
  107.          return FALSE;
  108.      }
  109.  }

1.初始化顺序表

  1. void InitList(List *p)
  2.  {
  3.      p->data=(ElemType*)malloc(sizeof(ElemType)*MaxSize);
  4.      p->length=;
  5.  }

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

  1. int ListInsert(List *p,int i,ElemType e)
  2.  {
  3.      if(i< || i>p->length+)
  4.      {
  5.          return FALSE;//插入位置不合法
  6.      }
  7.      if(p->length>=MaxSize)
  8.      {
  9.          return FALSE;//顺序表已满
  10.      }
  11.      for(int j=p->length;j>=i;j--)
  12.      {
  13.          p->data[j]=p->data[j-];
  14.      }
  15.      p->data[i-]=e;
  16.      p->length++;
  17.      return TRUE;
  18.  }

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

  1. int ListDelete(List *p,int i)
  2.  {
  3.      if(i< || i>p->length)
  4.      {
  5.          return FALSE;
  6.      }
  7.      for(int j=i;j<p->length;j++)
  8.      {
  9.          p->data[j-]=p->data[j];
  10.      }
  11.      p->length--;
  12.      return TRUE;
  13.   }

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

  1. int ListFindValue(List L,ElemType e)
  2.   {
  3.       for(int i=;i<L.length;i++)
  4.       {
  5.           if(L.data[i]==e)
  6.           {
  7.               return i+;
  8.         }
  9.     }
  10.     return FALSE;
  11.   }

5.按位置查找元素

  1. int ListFindLocate(List L,int i)
  2.   {
  3.       return L.data[i-];
  4.   }

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

  1. int Empty(List L)
  2.  {
  3.      if(L.length==)
  4.      {
  5.          return TRUE;
  6.      }
  7.      else
  8.      {
  9.          return FALSE;
  10.      }
  11.  }

7.显示顺序表

  1. void PrintList(List L)
  2.  {
  3.      for(int i=;i<L.length;i++)
  4.      {
  5.          printf("%d ",L.data[i]);
  6.      }
  7.      printf("\n");
  8.  }

二.线性表的链式存储

  1. typedef int ElemType;
  2. typedef struct Node{
  3.     ElemType data;
  4.     struct Node *next;
  5. }Node;

0.完整代码

  1.  #include <stdio.h>
  2.  #include <stdlib.h>
  3.  #define TRUE 1
  4.  #define FALSE 0
  5.  typedef int ElemType;
  6.  typedef struct Node{
  7.      ElemType data;
  8.      struct Node *next;
  9.  }Node;
  10.  
  11.  Node* InitNode();//初始化创建头结点
  12.  Node* Node_HeadInsert(Node *L);//头插法建立链表
  13.  Node* Node_TailInsert(Node *L);//尾插法建立链表
  14.  Node* NodeInsert(Node *L,int i);//在第i个位置插入结点
  15.  Node* NodeDelete(Node *L,int i);//删除第i个结点
  16.  Node* NodeSearchNum(Node *L,int i);//按序号查找
  17.  Node* NodeSearchValue(Node *L,ElemType x);//按值查找
  18.  void PrintNode(Node *L);//显示单链表
  19.  Node* NodeMerge(Node *p,Node *q);//合并两个递增链表 
  20.  
  21.  int main()
  22.  {
  23.      Node *L;
  24.      L=InitNode();
  25.      L=Node_TailInsert(L);
  26.      L=NodeInsert(L,);
  27.      PrintNode(L);
  28.      L=NodeDelete(L,);
  29.      PrintNode(L);
  30.      return ;
  31.   }
  32.  Node* InitNode()
  33.  {
  34.      Node *L;
  35.      L=(Node*)malloc(sizeof(Node));
  36.      L->next=NULL;
  37.      return L;
  38.  }
  39.  Node* Node_HeadInsert(Node *L)
  40.   {
  41.       Node *s;
  42.       ElemType x;
  43.       scanf("%d",&x);//插入结点的值
  44.       while(x!=)
  45.       {
  46.           s=(Node*)malloc(sizeof(Node));
  47.           s->data=x;
  48.           s->next=L->next;
  49.           L->next=s;
  50.           scanf("%d",&x);
  51.        }
  52.        return L;
  53.   }
  54.  
  55.   Node* Node_TailInsert(Node *L)
  56.   {
  57.       ElemType x;
  58.       Node *s,*r=L;
  59.       scanf("%d",&x);
  60.       while(x!=)
  61.       {
  62.           s=(Node*)malloc(sizeof(Node));
  63.           s->data=x;
  64.           r->next=s;
  65.           r=s;
  66.           scanf("%d",&x);
  67.       }
  68.       r->next=NULL;
  69.       return L;
  70.  }
  71.  
  72.  Node* NodeInsert(Node *L,int i)
  73.  {
  74.      ElemType x;
  75.      Node *s,*p=NodeSearchNum(L,i-);
  76.      printf("输入插入节点的值:") ;
  77.      scanf("%d",&x);
  78.      s=(Node*)malloc(sizeof(Node));
  79.      s->data=x;
  80.      s->next=p->next;
  81.      p->next=s;
  82.      printf("插入完成!\n");
  83.      return L;
  84.  }
  85.  
  86.  Node* NodeDelete(Node *L,int i)
  87.  {
  88.      Node *p,*q;
  89.      p=NodeSearchNum(L,i-);
  90.      q=p->next;
  91.      p->next=q->next;
  92.      free(q);
  93.      printf("删除完成!\n");
  94.      return L;
  95.  }
  96.  
  97.   Node *NodeSearchNum(Node *L,int i)
  98.   {
  99.       int count=;//计数
  100.       Node *p=L->next;
  101.       if(i==)
  102.           return L;
  103.      if(i<)
  104.          return NULL;
  105.      while(p&&count<i)
  106.      {
  107.          p=p->next;
  108.          count++;
  109.       }
  110.       return p;
  111.   }
  112.  
  113.   Node *NodeSearchValue(Node *L,ElemType x)
  114.   {
  115.       Node *p=L->next;
  116.       while(p&&p->data!=x)
  117.       {
  118.           p=p->next;
  119.       }
  120.       return p;
  121.   }
  122.   void PrintNode(Node *L)
  123.   {
  124.       Node *p=L->next;
  125.       printf("单链表:");
  126.       while(p)
  127.       {
  128.           printf("%d ",p->data);
  129.           p=p->next;
  130.       }
  131.       printf("\n");
  132.  
  133.   }
  134.  
  135.   Node* NodeMerge(Node *p,Node *q)
  136.   {
  137.       Node *r,*t;
  138.       r=InitNode();
  139.       t=r;
  140.       while(p->next&&q->next)
  141.       {
  142.           if(p->next->data<q->next->data)
  143.           {
  144.               t->next=p->next;
  145.               p->next=p->next->next;
  146.               t=t->next;
  147.           }
  148.           else
  149.           {
  150.               t->next=q->next;
  151.               q->next=q->next->next;
  152.               t=t->next;
  153.           }
  154.       }
  155.  
  156.       while(p->next)
  157.       {
  158.           t->next=p->next;
  159.           p->next=p->next->next;
  160.           t=t->next;
  161.       }
  162.  
  163.       while(q->next)
  164.       {
  165.           t->next=q->next;
  166.           q->next=q->next->next;
  167.           t=t->next;
  168.       }
  169.  
  170.       free(p);
  171.       free(q);
  172.  
  173.       return r;
  174.   }

1.初始化创建头结点

  1. Node* InitNode()
  2. {
  3.     Node *L;
  4.     L=(Node*)malloc(sizeof(Node));
  5.     L->next=NULL;
  6.     return L;
  7. }

2.头插法建立链表

  1. Node* Node_HeadInsert(Node *L)
  2.  {
  3.      Node *s;
  4.      ElemType x;
  5.      scanf("%d",&x);//插入结点的值
  6.      while(x!=)
  7.      {
  8.          s=(Node*)malloc(sizeof(Node));
  9.          s->data=x;
  10.          s->next=L->next;
  11.          L->next=s;
  12.          scanf("%d",&x);
  13.       }
  14.       return L;
  15.  }

3.尾插法建立链表

  1.  Node* Node_TailInsert(Node *L)
  2.  {
  3.      ElemType x;
  4.      Node *s,*r=L;
  5.      scanf("%d",&x);
  6.      while(x!=)
  7.      {
  8.          s=(Node*)malloc(sizeof(Node));
  9.          s->data=x;
  10.          r->next=s;
  11.          r=s;
  12.          scanf("%d",&x);
  13.      }
  14.      r->next=NULL;
  15.      return L;
  16. }

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

  1. Node* NodeInsert(Node *L,int i)
  2. {
  3.     ElemType x;
  4.     Node *s,*p=NodeSearchNum(L,i-);
  5.     printf("输入插入节点的值:") ;
  6.     scanf("%d",&x);
  7.     s=(Node*)malloc(sizeof(Node));
  8.     s->data=x;
  9.     s->next=p->next;
  10.     p->next=s;
  11.     printf("插入完成!\n");
  12.     return L;
  13. }

5.删除第i个结点

  1. Node* NodeDelete(Node *L,int i)
  2. {
  3.     Node *p,*q;
  4.     p=NodeSearchNum(L,i-);
  5.     q=p->next;
  6.     p->next=q->next;
  7.     free(q);
  8.     printf("删除完成!\n");
  9.     return L;
  10. }

6.按序号查找

  1.  Node *NodeSearchNum(Node *L,int i)
  2.  {
  3.      int count=;//计数
  4.      Node *p=L->next;
  5.      if(i==)
  6.          return L;
  7.     if(i<)
  8.         return NULL;
  9.     while(p&&count<i)
  10.     {
  11.         p=p->next;
  12.         count++;
  13.      }
  14.      return p;
  15.  }

7.按值查找

  1.  Node *NodeSearchValue(Node *L,ElemType x)
  2.  {
  3.      Node *p=L->next;
  4.      while(p&&p->data!=x)
  5.      {
  6.          p=p->next;
  7.      }
  8.      return p;
  9.  }

8.显示单链表

  1. void PrintNode(Node *L)
  2.  {
  3.      Node *p=L->next;
  4.      printf("单链表:");
  5.      while(p)
  6.      {
  7.          printf("%d ",p->data);
  8.          p=p->next;
  9.      }
  10.      printf("\n");
  11.  
  12.  }

9.合并两个递增链表

  1. Node* NodeMerge(Node *p,Node *q)
  2.  {
  3.      Node *r,*t;
  4.      r=InitNode();
  5.      t=r;
  6.      while(p->next&&q->next)
  7.      {
  8.          if(p->next->data<q->next->data)
  9.          {
  10.              t->next=p->next;
  11.              p->next=p->next->next;
  12.              t=t->next;
  13.          }
  14.          else
  15.          {
  16.              t->next=q->next;
  17.              q->next=q->next->next;
  18.              t=t->next;
  19.          }
  20.      }
  21.  
  22.      while(p->next)
  23.      {
  24.          t->next=p->next;
  25.          p->next=p->next->next;
  26.          t=t->next;
  27.      }
  28.  
  29.      while(q->next)
  30.      {
  31.          t->next=q->next;
  32.          q->next=q->next->next;
  33.          t=t->next;
  34.      }
  35.  
  36.      free(p);
  37.      free(q);
  38.  
  39.      return r;
  40.  }

输出示例：

2020-06-27

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

  1. 数据结构导论 四 线性表的顺序存储VS链式存储

    前几章已经介绍到了顺序存储.链式存储 顺序存储:初始化.插入.删除.定位 链式存储:初始化.插入.删除.定位 顺序存储:初始化 strudt student{ int ID://ID char nam ...

  2. 算法与数据结构(一) 线性表的顺序存储与链式存储(Swift版)

    温故而知新,在接下来的几篇博客中,将会系统的对数据结构的相关内容进行回顾并总结.数据结构乃编程的基础呢,还是要不时拿出来翻一翻回顾一下.当然数据结构相关博客中我们以Swift语言来实现.因为Swift ...

  3. 线性表的顺序存储和链式存储的实现(C)

    //线性表的顺序存储 #include <stdio.h>typedef int DataType;#define MaxSize 15//定义顺序表typedef struct { Da ...

  4. 线性表的Java实现--链式存储（单向链表）

    单向链表(单链表)是链表的一种,其特点是链表的链接方向是单向的,对链表的访问要通过顺序读取从头部开始. 链式存储结构的线性表将采用一组任意的存储单元存放线性表中的数据元素.由于不需要按顺序存储,链表在 ...

  5. c数据结构 -- 线性表之 复杂的链式存储结构

    复杂的链式存储结构 循环链表 定义:是一种头尾相接的链表(即表中最后一个结点的指针域指向头结点,整个链表形成一个环) 优点:从表中任一节点出发均可找到表中其他结点 注意:涉及遍历操作时,终止条件是判断 ...

  6. 队列的顺序存储与链式存储c语言实现

    一. 队列 1.队列定义:只允许在表的一端进行插入,表的另一端进行删除操作的线性表. 2.循环队列:把存储队列的顺序队列在逻辑上视为一个环. 循环队列状态: 初始时:Q.front=Q.rear=0 ...

  7. 栈的顺序存储和链式存储c语言实现

    一. 栈 栈的定义:栈是只允许在一端进行插入或删除操作的线性表. 1.栈的顺序存储 栈顶指针:S.top,初始设为-1 栈顶元素:S.data[S.top] 进栈操作:栈不满时,栈顶指针先加1,再到栈 ...

  8. 线性表的Java实现--链式存储（双向链表）

    有了单向链表的基础,双向链表的实现就容易多了. 双向链表的一般情况: 增加节点: 删除节点: 双向链表的Java实现: package com.liuhao.algorithm;      publi ...

  9. C 数据结构1——线性表分析（顺序存储、链式存储）

    之前是由于学校工作室招新,跟着大伙工作室招新训练营学习数据结构,那个时候,纯碎是小白(至少比现在白很多)那个时候,学习数据结构,真的是一脸茫然,虽然写出来了,但真的不知道在干嘛.调试过程中,各种bug ...

随机推荐

  1. Java实现 LeetCode 712 两个字符串的最小ASCII删除和（最长公共子串&&ASCII值最小）

    712. 两个字符串的最小ASCII删除和 给定两个字符串s1, s2,找到使两个字符串相等所需删除字符的ASCII值的最小和. 示例 1: 输入: s1 = "sea", s2 ...

  2. Java实现 蓝桥杯 算法提高 三进制数位和

    算法提高 三进制数位和 时间限制:1.0s 内存限制:256.0MB 提交此题 问题描述 给定L和R,你需要对于每一个6位三进制数(允许前导零),计算其每一个数位上的数字和,设其在十进制下为S. 一个 ...

  3. Java实现 蓝桥杯VIP 算法提高 进制转换

    算法提高 进制转换 时间限制:1.0s 内存限制:256.0MB 问题描述 程序提示用户输入三个字符,每个字符取值范围是0-9,A-F.然后程序会把这三个字符转化为相应的十六进制整数,并分别以十六进制 ...

  4. Java中输入时IO包与Scanner的区别

    最常用的一个IO控制台输入的 import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream ...

  5. Java实现第十届蓝桥杯迷宫

    试题 E: 迷宫 本题总分:15 分 [问题描述] 下图给出了一个迷宫的平面图,其中标记为 1 的为障碍,标记为 0 的为可 以通行的地方. 010000 000100 001001 110000 迷 ...

  6. java实现第九届蓝桥杯最大乘积

    最大乘积 把 1~9 这9个数字分成两组,中间插入乘号, 有的时候,它们的乘积也只包含1~9这9个数字,而且每个数字只出现1次. 比如: 984672 * 351 = 345619872 98751 ...

  7. python自学Day06（自学书籍python编程从入门到实践）

    第7章 用户输入和while循环 我们设计的程序大多是为了解决用户最终的问题,所以我们大多需要在用户那里获取一些信息. 学习用户输入的获取与处理,学习while循环让程序不断运行直到达到指定的条件不满 ...

  8. STL中的string

    string常用函数 1.构造函数 string(const char *s); //用c字符串s初始化 string(int n,char c); //用n个字符c初始化 string类还支持默认构 ...

  9. 恕我直言，我怀疑你并不会用 Java 枚举

    开门见山地说吧,enum(枚举)是 Java 1.5 时引入的关键字,它表示一种特殊类型的类,默认继承自 java.lang.Enum. 为了证明这一点,我们来新建一个枚举 PlayerType: p ...

  10. Jmeter(八) - 从入门到精通 - JMeter配置元件（详解教程）

    1.简介 JMeter配置元件可以用来初始化默认值和变量,读取文件数据,设置公共请求参数,赋予变量值等,以便后续采样器使用.将在其作用域的初始化阶段处理.配置元件(Config Element)提供对 ...