线性表的顺序存储和链式存储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 ...

随机推荐

Java实现 LeetCode 813 最大平均值和的分组（DFS+DP记忆化搜索）
813. 最大平均值和的分组我们将给定的数组 A 分成 K 个相邻的非空子数组 ,我们的分数由每个子数组内的平均值的总和构成.计算我们所能得到的最大分数是多少. 注意我们必须使用 A 数组中的每一个 ...
Java实现 LeetCode 733 图像渲染（DFS）
733. 图像渲染有一幅以二维整数数组表示的图画,每一个整数表示该图画的像素值大小,数值在 0 到 65535 之间. 给你一个坐标 (sr, sc) 表示图像渲染开始的像素值(行 ,列)和一个新的 ...
Java实现 LeetCode 676 实现一个魔法字典（暴力）
676. 实现一个魔法字典实现一个带有buildDict, 以及 search方法的魔法字典. 对于buildDict方法,你将被给定一串不重复的单词来构建一个字典. 对于search方法,你将被给 ...
Java实现 LeetCode 521 最长特殊序列 Ⅰ(出题人：“就是喜欢看你们不敢相信那么简单，又不敢提交的样子。”)
521. 最长特殊序列 Ⅰ 给定两个字符串,你需要从这两个字符串中找出最长的特殊序列.最长特殊序列定义如下:该序列为某字符串独有的最长子序列(即不能是其他字符串的子序列). 子序列可以通过删去字符串中 ...
Dockerfile 解析
Dockerfile Dockerfile是用来构建Docker镜像的构建文件,是由一系列参数和命令构成的脚本. 构建的三个步骤:1.编写Dockerfile文件 2.docker build 3 ...
Jmeter用beanshell将相应中的参数写入到本地文件中
实现效果: 将每次请求的指定参数写入到本地csv文件中. 实际场景:将登录请求中,服务器返回的token值获取并写入到本地csv文件中,供其他接口调用.这样在压测单接口时,不需要再进行登录,避免压测单 ...
python3 优惠券查询GUI程序
from tkinter import ttkfrom tkinter import messageboximport pymssqlimport tkinterimport decimalimpor ...
对SSH框架的理解
首先是对struts的理解.struts是把servlet.jsp以及众多标签库整合在一起的开源web框架,他实现了mvc设计模式.Struts实际上就是对MVC的各部件提供了现成的实现组件.Stru ...
TCP协议“三次握手”与“四次挥手”详解（下）
前面进行“三次握手”建立连接后,当客户端的数据发送完毕,它就会要求与服务器端断开连接,那么就要进行“四次挥手”进行连接的释放. 注意,此处所谓的“客户端”与“服务器端”,只是为了方便标识连接的双方,即 ...
基于 abp vNext 和 .NET Core 开发博客项目 - Blazor 实战系列（三）
系列文章基于 abp vNext 和 .NET Core 开发博客项目 - 使用 abp cli 搭建项目基于 abp vNext 和 .NET Core 开发博客项目 - 给项目瘦身,让它跑起来 ...

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

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

随机推荐

热门专题