数据结构【C语言】【不完全】

最新推荐文章于 2024-05-18 17:16:57 发布
VIP文章 最新推荐文章于 2024-05-18 17:16:57 发布
阅读量394 收藏 3
点赞数
分类专栏： 笔记 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43328585/article/details/104981983
版权

线性表

顺序表

定义

#define LIST_INIT_SIZE 10                  
#define LISTINCREMENT 2                 
typedef  struct
{
           ElemType  *elem;
    int  length;
    int  listsize;
}SqList;

也可以使用顺序表静态分配数组，其存储结构定义如下：

#define	MAXSIZE  100  
typedef  struct
{
    
	ElemType  elem[MAXSIZE];  
	int   last;/*记录线性表中最后一个元素在数组elem[ ]中的位置（下标值），空表置为-1*/
}SqList;

注意：静态数组或动态数组都可以实现顺序表。如果不加特殊说明，本书中采用的都是动态数组。

#include"public1.H"
#include"p2.H"
Status InitList(SqList &L)
{
    //构造一个空的顺序表
   L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
   if(!L.elem)
       exit(OVERFLOW);
   L.length=0;
   L.listsize=LIST_INIT_SIZE;
   return OK;
}
Status DestroyList(SqList &L)
{
    //销毁顺序线性表L
   free(L.elem);
   L.elem=NULL;
   L.length=L.listsize=0;
   return OK;
}
int LocateElem(SqList L, ElemType e)
{
    //根据数据元素的值，返回它在线性表L中的位置
   int i=1;
   while ((i<=L.length)&&(*(L.elem+i-1)!=e))
   	i++;
   if (i<=L.length)
   	return i;
   else
   	return(0);
}
Status GetElem(SqList L,int i,ElemType &e)
{
    //根据数据元素在线性表L中的位置，返回它的值
   if(i<0||i>L.length)
       return ERROR;
   e=*(L.elem+i-1);
   return OK;
}
Status ListInsert(SqList &L,int i,ElemType e)
{
    // 在L中第i个位置之前插入新的数据元素e，L的长度加1
   if(i>=L.listsize)
   {
   
   if(!(L.elem=(ElemType*)realloc(L.elem,sizeof(ElemType)*LISTINCREMENT)))
           exit(OVERFLOW);
       L.listsize+=LISTINCREMENT;
   }
   if(i<0)
       return ERROR;
   for(int j=L.length;j>=i;j--)
   {
   
       *(L.elem+j)=*(L.elem+j-1);
   }
   *(L.elem+i-1)=e;
   L.length++;
   return OK;
}
Status ListDelete(SqList &L,int i,ElemType &e)
{
    //删除L的第i个数据元素，并用e返回其值，L的长度减1
   if(i<0||i>L.length)
       return ERROR;
   e=*(L.elem+i-1);
   for(int j=i;j<L.length;j++)
   {
           *(L.elem+j-1)=*(L.elem+j);
   }
   L.length--;
return OK;
}
Status PriorElem(SqList L,ElemType cur_e,ElemType &pre_e)
{
    // 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，否则操作失败
   int location=LocateElem(L,cur_e);
   if((!location)||cur_e==*(L.elem))
       return ERROR;
   pre_e=*(L.elem+location-2);
   return OK;
}
Status visit(SqList L)
{
    //按序输出顺序表的各个元素值
  int i;
  for(i=1;i<=L.length;i++)
    printf("%d ",*(L.elem+i-1));
  printf("L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);
  return OK;
}
int main()
{
   
  SqList L;
  ElemType e,pre_elem;
  Status i;
  int j;
  i=InitList(L);
  visit(L);
  for(j=1;j<=5;j++)
    i=ListInsert(L,1,j);
  printf("在L的表头依次插入1～5后：*L.elem=");
  visit(L);
  for(j=1;j<=5;j++)
    *(L.elem+L.length+j-1)=j;
  printf("在L的表尾依次插入1～5后：*L.elem=");
  L.length=L.length+5;
  visit(L);
  ListInsert(L,1,0);
  printf("在L的表头插入0后：*L.elem=");
  visit(L);
  i=LocateElem(L,1);
  printf("值为1的数据元素在顺序表中的位置是");
  printf("%d ",i);
  printf("\n");
  GetElem(L,5,e);
  printf("第5个元素的值为：%d\n",e);
  printf("在L中删除第三个数据元素：*L.elem=");
  ListDelete(L,3,e);
  visit(L);
  printf("第五个元素的值为：%d",*(L.elem+4));
  if(PriorElem(L,*(L.elem+4),pre_elem))
       printf("，它的前驱为：%d\n",pre_elem);
   else
       printf(",你输入的是第一个数，它没有前驱！\n");
  DestroyList(L);
  printf("销毁L后：L.elem=%u L.length=%d L.listsize=%d\n",L.elem,L.length,L.listsize);
  return 0;
}

单链表

单链表存储结构定义

typedef int ElemType;
typedef struct LNode
 {
        ElemType data;
       LNode *next;
 }LNode;
 typedef  LNode  *LinkList;

函数部分：

#include"public1.H"
#include"p3.h"
Status InitList(LinkList &L)
 {
    // 构造一个空的单链表L
   L=(LinkList)malloc(sizeof(LNode));
   if (!L)
     exit(OVERFLOW);
   L->next=NULL;
   return OK;
 }
Status DestroyList(LinkList &L)
 {
    // 销毁单链表L
    LinkList p;
    while(p=L->next)
    {
   
        L->next=p->next;
        free(p);
    }
	return OK;
 }
void CreateList(LinkList &L,int n)
 {
    // 逆位序输入n个元素的值，建立带表头结构的单链线性表L
   int i;
   LinkList p;
   L=(LinkList)malloc(sizeof(LNode));
   L->next=NULL;
   printf("请输入%d个数据：",n);
   for(i=n;i>0;--i)
   {
   
     p=(LinkList)malloc(sizeof(LNode));
     scanf("%d",&p->data);
     p->next=L->next;
     L->next=p;
   }
 }
void CreateList2(LinkList &L,int n)
 {
    // 正位序输入n个元素的值，建立带表头结构的单链线性表
    int i;
    LinkList p,tail;
    tail=L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    printf("请输入%d个数据：", n);
    for(i=0;i<n;i++)
    {
   
        p=(LinkList)malloc(sizeof(LNode));
        scanf("%d", &p->data);
        p->next=NULL;
        tail->next=p;
        tail=p;
    }
 }
int ListLength(LinkList L)
 {
    // 返回L中数据元素个数
    int num=0;
    LinkList p=L->next;
    while(p)
    {
   
        num++;
        p=p->next;
    }
	return num;
 }
Status GetElem(LinkList L,int i,ElemType &e)
 {
    // L为带头结点的单链表的头指针。当第i个元素存在时,其值赋给e并返回OK,否则返回 ERROR
   int j=1;
   LinkList p=L->next;
   while(p&&j<i)
   {
   
     p=p->next;
     j++;
   }
   if(!p||j>i)
     return ERROR;
   e=p->data;
   return OK;
 }
int LocateElem(LinkList L,ElemType e)
 {
    // 返回L中第1个值为e 的数据元素的位序，若这样的数据元素不存在,则返回值为0
    LinkList p=L->next;
    int num=0;
    while(p)
    {
   
        num++;
        if(p->data==e)
            return num;
        else
            p=p->next;
    }
	return 0;
 }
Status visit(LinkList L)
 {
    //按序输出单链表的各个元素值
   LinkList p=L->next;
   while(p)
   {
   
     printf("%d ",p->data);
     p=p->next;
   }
   printf("\n");
   return OK;
 }
 Status ReverseVisit(LinkList L)
 {
   //逆位序输出单链表的各个元素的值
     LinkList p=L->next,tail;
     int length=ListLength(L);
     while(length)
     {
   
         int num=0;
         p=L->next;         //两行代码应该放在循环内部，进行初始化
         while(p&&num!=length)
         {
   //找到尾结点
             num++;
             tail=p;
             p=p->next;
         }
         printf("%d  ",tail->data);
         length--;
     }
     return OK;
 }
 Status ListInsert(LinkList &L,int i,ElemType e)
{
   //在带头节点的单链表L中第i个位置之前插入元素e
    if(i<0) return ERROR;
    int count=1;
    LinkList p=L->next,pre=L,q;
    for(    ;p&&count!=i;count++,p=(pre=p)->next);//找到第i个位置及其pre的指针
    if(count>i)  return ERROR;   //没有找到第i个位置
    q=(LinkList)malloc(sizeof(LNode));   //创建一个新的结点存放元素e
    if(!q)  exit(OVERFLOW);
    q->data=e;
    pre->next=q;
    q->next=p;
	return OK;
}

Status ListDelete(LinkList &L,int i,ElemType& e)
{
   //在带头节点的单链表L中，删除第i个元素，并由e返回其值
    if(i<0) return ERROR;
    int count=1;
    LinkList pre=L,p=L->next;
for(    ;p&&count!=i;count++,p=(pre=p)->next);  
//find i_th node and its previous node
    if(count>i) return ERROR;
    e=p->data;
    pre->next=p->next;
    free(p);
	return OK;
}
void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc)
{
    //已知线性表La和Lb中的数据元素按值非递减排列
  //归并La和Lb得到新的线性表Lc,Lc的数据元素也按值非递减排列
    Lc=(LinkList)malloc(sizeof(LNode));
    LinkList pa=La->next,pb=Lb->next,pc=Lc;
    while(pa&&pb)
    {
   //到La,Lb两个表其中一个结束为止，将元素按非递减插入链表Lc中
        if(pa->data<pb->data)
            pa=(pc=pc->next=pa)->next;
        else if(pa->data>pb->data)
            pb=(pc=pc->next=pb)->next;
        else
        {
   
            pc=pc->next=pa;
            pa=pa->next;
            pc=pc->next=pb;
            pb=pb->next;
        }
    }
    while(pa&&!pb)  //Lb表结束
        pa=(pc=pc->next=pa)->next;
    while(pb&&!pa)  //La表结束
        pb=(pc=pc->next=pb)->next;
    pc->next=NULL;  //将Lc表尾部置空
}
//实现归并算法MergeList2，使重复的元素只保存一次
void MergeList2(LinkList &La,LinkList &Lb,LinkList &Lc)
{
    //已知线性表La和Lb中的数据元素按值递减排列
  //归并La和Lb得到新的线性表Lc,Lc的数据元素也按值递减排列
    Lc=(LinkList)malloc(sizeof(LNode));
    LinkList pa=La->next,pb=Lb->next,pc=Lc;
    while(pa&&pb)
    {
   //到La,Lb两个表其中一个结束为止，将元素按递减插入链表Lc中
        if(pa->data<pb->data)
            pa=(pc=pc->next=pa)->next;
        else if(pa->data>pb->data)
            pb=(pc=pc->next=pb)->next;
        else
        {
   
            pc=pc->next=pa;
            pa=pa->next;
            pb=pb->next;
        }
    }
    while(pa&&!pb)  //Lb表结束
        pa=(pc=pc->next=pa)->next;
    while(pb&&!pa)  //La表结束
        pb=(pc=pc->next=pb)->next;
    pc->next=NULL;  //将Lc表尾部置空
}

栈

void  CreateList_L(LinkList &L,  int n){
   
	//逆位序输入n个元素的值，建立带表头结点的单链表L。
	int i;
	LinkList p;
	L=(LinkList) malloc (sizeof(LNode));
	L->next=NULL; 			//建一个带头结点的单链表
	printf("Input %d integers: ",n);
	for (i=n; i>0 ; --i )
	{
   
		p= (LinkList) malloc (sizeof(LNode)); 	//生成新结点
		scanf("%d",&p->data); 				//输入元素值
		p->next=L->next; L->next =p;		//插入到表头
	}
}// CreateList_L


void PrintList_L(LinkList L)
{
   //递归地将链表输出
    printf("%d  ",L->data);
    if(L->next) //当下一结点为空的时候，结束递归
        PrintList_L(L->next);
}

LinkList reverse(LinkList p)
{
   //递归地将单链表逆置，返回值为链表开始结点
    LinkList L,q;
    if(!p->next)    return p;   //结束递归条件，返回值为链表头结点
    L=reverse(p->next);
    p->next->next=p;
    p->next=NULL;
    return L;//返回头节点
}
int ListLength(LinkList L)
{
   //递归地求链表长度，返回值为链表长度
    if(!L->next)    return 1;
    return (ListLength(L->next)+1);
}
void ReversePrintList(LinkList L)
{
   //递归地逆序输出链表
    if(L->next)
        ReversePrintList(L->next);
    printf("%d  ",L->data);
}
LinkList MergeList(LinkList La,LinkList Lb)
{
   //递归地将两个有序链表合并，返回值为头结点
    LinkList L,p;
    if(!La) //当链表La结束时
        return Lb;
    if(!Lb) //当链表Lb结束时
        return La;
最低0.47元/天 解锁文章
钝刀刀斩杂思
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言 不完全类型
专注【PostgreSQL源码学习&研究】
06-04 1428
1、 不完全类型是指“函数之外、类型大小不能被确定的类型”。首次接触“不完全数据类型”概念是来自《征服C指针》的3.2.10章节。C的类型共分为： （1）对象类型（char、int、数组、指针、结构体等） （2）函数类型 （3）不完全类型 下图涵盖了c中的所有类型 不完全类型（incomplete types）有三种不同形式： void、未指定长度的数组以及具有非指定内容的结构和联合。voi...
二叉树(C语言)
即使身边世事再毫无道理
08-07 383
#include #include typedef char elemType; typedef struct BTree { elemType data; struct BTree* lTree; struct BTree* rTree; struct BTree* next; }Tree; typedef struct QList { Tree*
数据结构C语言版（答案）
热门推荐
hrdzkj的专栏
09-15 6万+
第1章  绪论 1.1 简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。 解：数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。     数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。     数据对象是性质相同的数据元素的集合，是数据的一个子集。     数据结构是相互之间存在
C语言的本质（14）——不完全类型和复杂声明
weixin_30436891的博客
07-17 104
ISO 将 C 的类型分为三个不同的集合： 函数、对象和不完全类型三大类。函数类型很明显；对象类型包含其他一切，除非不知道对象的大小。该标准使用术语“对象类型”指定指派的对象必须具有已知大小，注意，除 void 之外的不完全类型也称为对象。对象类型又分为标量类型和非标量类型。枚举类型、字符型和各种整数的表示形式都被称作标量类型。当在C表达式中使用标量类型的值时，编译器就会自动将这些标识符转换为...
C语言中不完全数据类型
wangkeyen的专栏
02-17 1430
不完全类型和复杂声明C语言的类型分为函数类型、对象类型和不完全类型三大类。对象类型又分为标量类型和非标量类型。指针类型属于标量类型，因此也可以做逻辑与、或、非运算的操作数和if、for、while的控制表达式，NULL指针表示假，非NULL指针表示真。不完全类型是暂时没有完全定义好的类型，编译器不知道这种类型该占几个字节的存储空间，例如：具有不完全类型的变量可以通过多次声明组合成一个完全类型，比如...
严蔚敏数据结构C语言版本-可运行源码-完全C语言代码实现.zip
08-17
严蔚敏数据结构C语言版本_可运行源码_完全C语言代码实现 ----- 毕业设计，课程设计，项目源码均经过助教老师测试，运行无误，欢迎下载交流 ----- 下载后请首先打开README.md文件（如有），某些链接可能需要魔法打开...
数据结构C语言版 陈峰棋
09-17
数据结构的完全实现，不是只有理论的那种。C语言实现的，其中有关于字符串基本处理的各种实现，很全，很不错。各种基本结构讲的很细，学习数据结构的不二之选。（压缩包里内附源代码的 呵呵）
数据结构——栈 括号匹配 C语言
03-16
假设一个字符串包含三种括号：圆括号‘(’ 和 ‘)’，方括号‘[’ 和 ‘]’，花括号 ‘{’和‘}’，且这三种括号可按任意的次序排列，请判断括号是否完全匹配。如果不能匹配，输出"No"；如果能匹配，则输出"Yes"。
清华大学数据结构C语言习题集答案完全版
12-06
清华大学数据结构C语言习题集答案完全版，是学好数据结构的最佳题目库
史上最全经典数据结构算法c语言实现代码合集
10-13
数据结构2.txt 数据结构3.txt 数组完全单元.txt 数组操作.txt 数组递归退出.txt 数组递归退出2.txt 文件加密.txt 文件复制.txt 文件连接.txt 无向图.txt 时间陷阱.txt 杨辉三角形.txt 栈单元加.txt 栈...
C语言编程实现：二叉树采用二叉链表存储，要求建立一颗二叉树，并输出要求的二叉树树状形式与结点编号。
weixin_42070473的博客
04-12 1万+
一、题目 编程实现：二叉树采用二叉链表存储，要求建立一颗二叉树，并输出要求的二叉树树状形式与结点编号。结点如图1.1所示。 图 1.1 其中，二...
考研数据结构动-静态分配顺序表（线性表）
Gragon_gump的博客
10-09 1806
静态分配 代码实现 #include <stdio.h> #include <malloc.h> //添加malloc函数的头文件 //预定义常量和类型 #define LIST_INIT_SIZE 10 //线性表的存储空间的初始分配量 typedef int ElemType;//取别名 方便改 typedef struct{ ElemType data[LIST_INIT_SIZE]; //用静态的“数组”存放数据元素 int length;//顺序表的当前长度 }Sq
算法导论学习（三）——数据结构【待续】
天岚1993_量产机的博客
04-12 1912
简单归纳算法导论一书中数据结构的部分的内容。
C语言不完全类型与延迟定义
勤能补拙
08-11 3913
一直以为我的C语言学的还可以，虽说不是出神入化，但是至少比较熟悉吧。但是前一段时间看了一篇微信推文，再百度了一下C语言不完全类型。发现我居然C语言不完全类型和用途甚广的延迟定义都没概念。这两天仔细查阅了相关概念并用代码实验了一下。 本文结构如下：  C语言不完全类型概念介绍一个故事延迟定义的优点思考… C语言不完全类型 不完全类型也就是不知道变量的所有的类型信息。比如可
线性表的顺序存储及操作
HLXchamp的博客
04-07 601
存储的表示 #define MAXSIZE 100 typedef struct { ElemType elem[MAXSIZE]; int last/*记录线性表中最后一个元素在数组elem[]的位置 (下标值),空表置为一 */ } SeqList; PS： 1、结点类型定义中 Elemtype 是为了描述的统一而自定的，实际应用中可以根据自...
《数据结构》顺序查找和折半查找
weixin_34189116的博客
10-23 412
  /*******************************************************************************/* &lt;PRE&gt;/* 版权所有    : -/* 模块名      : 查找/* 文件名      : search.cpp/* 功能描述    : 静态查找表中查找/* 作者        : &lt;xxx&gt;...
Java Hash Collision之数据生产
weixin_34148456的博客
06-03 166
上一篇文章一种高级的DoS攻击-Hash碰撞攻击我通过伪造Hash Collision数据实现了对Java的DoS攻击，下面说说如何生产大量的攻击数据。 HashTable是一种非常常用的数据结构。它存取速度快，结构简单，深得程序员喜爱。HashTable大致数据结构如下图： Hash Function也叫哈希散列函数，通过散列函数我们能将各种类型的k...
第十三讲：指针（5）
最新发布
2301_79761834的博客
05-18 954
第十三讲：指针（5）
算法与数据结构c语言
09-04
在C语言中，我们可以使用各种算法和数据结构来解决问题。以下是一些常见的算法和数据结构： 1. 线性数据结构： - 数组（Array）：在内存中以连续的方式存储多个相同类型的元素。 - 链表（Linked List）：通过指针...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值