精华内容
下载资源
问答
  • 数据结构】单链表初始化

    万次阅读 多人点赞 2019-03-26 17:53:49
    #include <stdio.h> #include <stdlib.h> //链表中节点的结构 typedef struct Link { ...//初始化链表的函数 link * initLink(); //用于输出链表的函数 void display(link *p); int...

     

    #include <stdio.h>
    #include <stdlib.h>
    
    
    //链表中节点的结构
    typedef struct Link {
    	int  elem;
    	struct Link *next;
    }link;
    
    //初始化链表的函数
    link * initLink();
    //用于输出链表的函数
    void display(link *p);
    
    int main() {
    	//初始化链表(1,2,3,4)
    	printf("初始化链表为:\n");
    	link *p = initLink();
    	display(p);
    	return 0;
    }
    //无头节点的链表
    //link * initLink() {
    //	link * p = NULL;//创建头指针
    //	link * temp = (link*)malloc(sizeof(link));//创建首元节点
    //											  //首元节点先初始化
    //	temp->elem = 1;
    //	temp->next = NULL;
    //	p = temp;//头指针指向首元节点
    //	for (int i = 2; i<5; i++) {
    //		link *a = (link*)malloc(sizeof(link));
    //		a->elem = i;
    //		a->next = NULL;
    //		temp->next = a;
    //		temp = temp->next;
    //	}
    //	return p;
    //}
    //含头结点的链表
    link * initLink() {
    	link * p = (link*)malloc(sizeof(link));//创建一个头结点
    	link * temp = p;//声明一个指针指向头结点,
    					//生成链表
    	for (int i = 1; i<5; i++) {
    		link *a = (link*)malloc(sizeof(link));//申请一个新节点
    		a->elem = i;//第二个节点的数据域a->data=1;
    		a->next = NULL;//指针域为空
    		 //a所指向的节点连接在temp指向节点的后面(新节点插入链尾)
    		temp->next = a; 
    //指针temp每次都指向新链表的最后一个节点,其实就是 a节点,这里写temp = a也对(修改为指针)
    		temp = temp->next;
    		 
    	}
    	return p;
    }
    
    //void display(link *p) {
    //	link* temp = p;//将temp指针重新指向头结点
    //				   //只要temp指针指向的结点的next不是Null,就执行输出语句。
    //	while (temp) {
    //		printf("%d ", temp->elem);
    //		temp = temp->next;
    //	}
    //	printf("\n");
    //}
    void display(link *p) {
    	link* temp = p;//将temp指针重新指向头结点
    				   //只要temp指针指向的结点的next不是Null,就执行输出语句。
    	while (temp->next) {
    		temp = temp->next;
    		printf("%d", temp->elem);
    	}
    	printf("\n");
    }

     

    展开全文
  • 数据结构之线性表的初始化及其操作

    万次阅读 多人点赞 2019-04-03 23:47:22
    以上顺序表类型的定义【初始化】的含义: 为顺序表分配一个容量为 MAXSIZE 大小的数组空间,数组名为 data ,并将线性表的当前长度 length 设为0. [注意点]: 为什么用数组来对线性表进行存储? 顺序表的...


    TOC]

    一.准备工作

    1.定义存储空间的分配量

    #define MAXSIZE 10
    

    2.定义结果状态函数Status 返回成功失败的状态。

    误区:刚开始我把Status理解成了C语言的一个关键字,后来才知道Status是一个用户自定义函数,是定义的一种类型。

    用来表示成功或失败的状态。

        typedef int Status;//Status是函数的类型
    

    3.定义ElemType 函数类型,需要根据实际情况而定。

    typedef为类型定义标识符,作用是为一个数据类型或者结构(比如struct)重新定义一个名称。

    所以定义:

        typedef int ElemType;
    

    作用是:将关键字int重命名为ElemType

    intElemType代表的类型是一样的,声明和定义的变量是等价的

    4.通过结构类型来定义顺序表存储类型与定义。

    typedef struct
         {
             ElemType data[MAXSIZE];
             int length;
         
         }SqList;
    

    以上顺序表类型的定义【初始化】的含义:

    为顺序表分配一个容量为MAXSIZE大小的数组空间,数组名为data ,并将线性表的当前长度length设为0.

    [注意点]:

       为什么用数组来对线性表进行存储?
    

    顺序表的定义:用一组地址连续的存储单元依次存储线性表的各个数据元素,即用顺序存储的线性表

       它采用的数据元素存储方式是静态存储,这种方式还是有很多缺点的,因为你不知道自己实现到底需要计算机分配多少空间,在编程活动中,特别是我们的小学期中,很多同学出现了溢出或空间不够的现象,也就是传说中的“烫烫”,而数组的存储方式就是静态存储,计算机分配的空间都是你自己去定义的,后边进入链表我们会知道动态存储你需要多少空间计算机会自动按需分配,告别数组的这种静态存储带来的弊端。


    二.功能函数的声明

        void InitList(SqList *LP);//顺序表的初始化
        void CreateList(SqList *LP,ElemType a[],int n);//顺序表的创建
        void PrintList(SqList *LP);//顺序表的输出
        int ListLength(SqList *LP);//顺序表的长度,即当前元素的个数
        Status ListInsert(SqList *LP,int i,ElemType e);//顺序表的插入操作,在位置i插入元素
        Status GetElem(SqList *LP,int i,ElemType *e);//顺序表的查找操作,返回第i个位置的元素到e中
        Status ListDelete(SqList *LP,int i,ElemType *e);//顺序表的删除操作
    

    1.顺序表的初始化
    2.顺序表的创建
    3.顺序表的输出
    4.顺序表的长度,即当前元素的个数
    5.顺序表的插入操作,在位置i插入元素
    6.顺序表的查找操作,返回第i个位置的元素到e中
    7.顺序表的删除操作

    以上表示7个函数声明分别所代表的意义。

    接下来我们需要分别编写这7个功能函数,将对应的接口进行连接,最后写出主函数,通过主函数实现调用,完成整个操作。


    三.函数功能的编写

    1.线性表的初始化,建立了一个空表

        void InitList(SqList *LP)
        {
            LP->length=0;
        }
    

    2.创建一个顺序表

        void CreateList(SqList *LP,ElemType a[],int n)
        {
            int i;
        for(i=0;i<n;i++)
            {//通过循环将数组元素全部遍历放入顺序表中
            LP->data[i]=a[i];
            LP->length++;
            }
        }
    

    3.输出线性表

    void PrintList(SqList *LP)
    {
    	int i;
    	printf("\n顺序表中的元素为:\n");
    	for(i=0;i<LP->length;i++)
    	printf("%4d",LP->data[i]);
    	printf("\n\n");
    }
    

    4.线性表的当前长度

    void ListLength(SqList *LP)
    {
    	return LP->length;
    }
    

    5./*==========================================================
    函数功能的实现:顺序表的运算----元素的插入
    函数输入:顺序表的地址,插入值,插入位置
    函数输出:完成标志--------0:异常 1:正常

    ============================================================*/

    Status ListInsert(SqList *LP,int i,ElemType e)
    {
    	int k;
    	if(LP->length==MAXSIZE)//顺序表已满
    	return 0;
    	if(i<1||i>LP->length+1)//插入位置非法
    	return 0;
    
    	for(k=LP->length-1;k>=i-1;k--)//从顺序表最后一个元素开始后移
    	LP->data[k+1]=LP->data[k];
    LP->data[i-1]=e;//将插入的元素放入i-1中
    
    LP->length++;
    return 1;
    }
    

    6./*==========================================================
    函数功能的实现:顺序表的运算----元素的删除
    函数输入:顺序表的地址,删除位置,返回删除元素值
    函数输出:完成标志--------0:异常 1:正常

    ============================================================*/

    Status ListDelete(SqList *LP,int i,ElemType *e)
    {
    	int k;
    	if(LP->length==0)
    	return 0;
    	if(i<1||i>LP->length)
    	return 0;
    	*e=LP->data[i-1];
    for(k=i;k<LP->length;k++)
    LP->data[k-1]=LP->data[k];
    
    LP->length--;
    return 1;
    }
    

    7./*==========================================================
    函数功能的实现:顺序表的运算----元素的查找
    函数输入:顺序表的地址,查找位置,接收查找值的变量(地址)
    函数输出:完成标志--------0:异常 1:正常

    ============================================================*

    Status GetElem(SqList *LP)
    {
    	if(p->length==0||i<1||i>LP->length)
    	return 0;
    	*e=LP->data[i-1];
    	return 1;
    }
    

    四.主函数的编写

    	int main()
    	{
    		SqList L,*SP;
    		int flag;//用于接收函数状态返回或用于接收查找元素
    		ElemType result;
    		int search;
    
    		ElemType arr[]={12,14,16,24,28,30,42,77};
    		SP=&L;
    		InitList(SP);//初始化线性表
    		CreateList(SP,arr,8);//创建线性表
    		PrintList(SP);//输出线性表
    		printf("顺序表的当前长度为:%d\n",ListLength(SP));
    
    		//顺序表中插入元素
    		printf("在第几个位置插入?\n");
    		flag=ListInsert(SP,9,90);
    		if(flag==1)
    		{
    			PrintList(SP);
    			printf("顺序表当前长度为:%d\n\n",ListLength(SP));
    		}
    		else
    		{
    			printf("顺序表插入失败\n");
    			printf("顺序表的当前长度为:%d\n\n",ListLength(SP));
    		}
    
    		/*顺序表中查找元素*/
    		printf("要查找第几个元素?\n\n");
    		scanf("%d",&search);
    		flag=GetElem(SP,search,&result);
    		if(flag==1)
    		printf("第%d个元素是%d\n\n",search,result);
    		else
    		printf("顺序表查找失败!\n");
    
    		/*顺序表的删除操作*/
    		printf("要删除第几个元素?\n");
    		scanf("%d",&search);
    		flag=ListDelete(SP,search,&result);
    		if(flag==1)
    		printf("删除的第%d个元素是%d\n\n",search,result);
    		else
    		printf("顺序表删除失败!\n");
    
    		return 0;
    	}
    

    五.函数接口说明

    1. 线性表的初始化
    void InitList(SqList *LP);
    

    接口1:SqList *LP
    含义:线性表的地址。

    1. 线性表的创建
     	void InitList(SqList *LP);//顺序表的初始化
    

    接口1:SqList *LP
    含义:线性表的地址。

    1. 线性表的输出
     void PrintList(SqList *LP);//顺序表的输出
    

    接口1:SqList *LP
    含义:线性表的地址。

    1. 线性表的当前长度
     int ListLength(SqList *LP);//顺序表的长度,即当前元素的个数
    

    接口1:SqList *LP
    含义:线性表的地址。

    1. 线性表的插入操作
     Status ListInsert(SqList *LP,int i,ElemType e);//顺序表的插入操作,在位置i插入元素
    

    接口1:SqList *LP线性表的地址
    接口2:int i插入的位置
    接口3:ElemType e插入的新元素值

    1. 线性表的查找操作
    Status GetElem(SqList *LP,int i,ElemType *e);//顺序表的查找操作,返回第i个位置的元素到e中
    

    接口1:SqList *LP线性表的地址
    接口2:int i查找到的位置
    接口3:ElemType *e返回元素值

    1. 线性表的删除操作
     Status ListDelete(SqList *LP,int i,ElemType *e);//顺序表的删除操作
    

    接口1:SqList *LP线性表的地址
    接口2:int i要删除的位置
    接口3:ElemType *e获得的删除值


    六.实现思路

    代码流程图


    展开全文
  • c语言结构体学习整理(结构体初始化,结构体指针)

    万次阅读 多人点赞 2018-11-01 20:22:12
    c语言中交换两个结构体的值(结构体指针) 1关于语言的结构体: 首先我们为什么要用到结构体,我们都已经学了很多int char …等类型还学到了同类型元素构成的数组,以及取上述类型的指针,在一些...如果把这些数据...

    渣渣c的c语言学习之路

    1.关于c语言的结构体:

    首先我们为什么要用到结构体,我们都已经学了很多int char …等类型还学到了同类型元素构成的数组,以及取上述类型的指针,在一些小应用可以灵活使用,然而,在我们实际应用中,每一种变量进行一次声明,再结合起来显然是不太实际的,类如一位学生的信息管理,他可能有,姓名(char),学号(int)成绩(float)等多种数据。如果把这些数据分别单独定义,就会特别松散、复杂,难以规划,因此我们需要把一些相关的变量组合起来,以一个整体形式对对象进行描述,这就是结构体的好处。

    2首先我们要了解一些小知识

    2.1**只有结构体变量才分配地址,而结构体的定义是不分配空间的。**
    2.2结构体中各成员的定义和之前的变量定义一样,但在定义时也不分配空间。
    2.3结构体变量的声明需要在主函数之上或者主函数中声明,如果在主函数之下则会报错
    2.4c语言中的结构体不能直接进行强制转换,只有结构体指针才能进行强制转换
    2.5相同类型的成员是可以定义在同一类型下的
    列如

    
    struct Student
    { 
    	int number,age;//int型学号和年龄
    	char name[20],sex;//char类型姓名和性别
    	float score;
    }

    最后的分号不要忘了 有的编译器会自动加上,因此有的同学就会不注意。

    3关于结构体变量的定义和引用

    在编译时,结构体的定义并不分配存储空间,对结构体变量才按其数据结构分配相应的存储空间

    
     struct Book
     { 
     	char title[20];//一个字符串表
    
    示的titile 题目
    	char author[20];//一个字符串表示的author作者
     	float value;//价格表示 
     };//这里只是声明 结构体的定义 
    struct Book book1,book2;//结构体变量的定义 分配空间
    
    book1.value;//引用结构体变量
    

    定义结构体变量以后,系统就会为其分配内存单元,比如book1和book2在内存中占44个字节(20+20+4)具体的长度你可以在你的编译器中使用sizeof关键字分别求出来。
    列如

    当然,要注意一点:用sizeof关键字求结构体长度时,返回的最大基本类型所占字节的整数倍 比方说我们上面求得的为44 为 float(4个字节)的整数倍,
    但是我们把title修改为title[22]; 这时正常长度为46 ,但是你会发现实际求得的为48,(4的整数倍)

    这就涉及到结构体的存储

    1结构体整体空间是占用空间最大的成员(的类型)所占字节数的整数倍。

    2.结构体的每个成员相对结构体首地址的偏移量(offset)都是最大基本类型成员字节大小的整数倍,如果不是编译器会自动补齐,

    关于这个我们简单介绍下:

    1.偏移量----偏移量指的是结构体变量中成员的地址和结构体变量首地址的差。即偏移字节数,结构体大小等于最后一个成员的偏移量加上他的大小,第一个成员的偏移量为0,

    struct S1
    {
        char a;
    
        int b;
    
        double c;
    };
    

    这里char a 偏移量为1 之后为int b 因为偏移量1不为int(4)的整数倍,所以会自动补齐,而在 double c 时,偏移量为8 是double(8)的整数倍,所以不用自动补齐 最后求得结构体得大小为 16

    具体看下图:
    在这里插入图片描述
    通过上面的代码同学们应该会有一个简单的认知

    4结构体变量的初始化

    结构体的初始化有很多需要注意的地方,这里我们说明下
    首先是几种初始化的方法
    ps在对结构体变量初始化时,要对结构体成员一一赋值,不能跳过前面成员变量,而直接给后面成员赋初值,但是可以只赋值前面几个,对与后面未赋值的变量,如果是数值型,则会自动赋值为0,对于字符型,会自动赋初值为NULL,即‘\0’

    4.1定义时直接赋值

    struct Student
    { 
    	char name[20];
    	char sex;
    	int number;
    }stu1={"zhaozixuan",'M',12345};
    //或者
    struct Student
    { 
    	char name[20];
    	char sex;
    	int number;
    }struct Student stu1={"zhaozixuan",'M',12345};
    
    

    注意字符为‘ ’ 字符串为""
    4.2定义结构体之后逐个赋值

    stu1.name="王伟";
    stu1.sex='M';
    stu1.number=12305;
    //也可用strcpy函数进行赋值
    strcpy(stu1.name,"王伟");
    
    

    4.3定义之后任意赋值

     struct Student stu1={
      .name="Wang",
      .number=12345,
      .sex='W', 
     };//可以对任意变量赋值
    

    这样写的好处时不用按照顺序来进行初始化,而且可以对你想要赋值的变量直接进行赋值,而不想赋值的变量可以不用赋值

    需要注意的是如果在定义结构体变量的时候没有初始化,那么后面就不能全部一起初始化了;

    等下结构体数组初始化时我们还会有一个讲解

    这里我们顺带提一下typedef说明结构体类型


    这里的BOOK就相当于struct book的一个别名一样,用它来定义结构体变量非常简便
    主要也是考二级要用到,所以我们简单介绍下

    5结构体变量的引用(输出和输入)

    5.1结构体变量的赋值用scanf赋值和printf输出时跟其他变量操作一样
    但是有几点需要注意
    (1) .是运算符,在所有运算符优先级中最高
    (2)如果结构体的成员本身是一个结构体,则需要继续用.运算符,直到最低一级的成员。

    struct Student
    {	char name[20];
    	char sex;
    	int number;
    	struct Date
    	{
    		int year;
     		int month;
     		int day;
    	}birthday;
    
    }stu1;
    printf("%d",stu1.birthday);//这样子是错误的,因为birthday也是一个结构体变量
    scanf("%d",&stu1.birthday.month);//正确
    

    (3)可以引用接头体变量成员的地址,也可以引用结构体变量的地址:

    printf("%o", student);(输出student的首地址)(%o 按八进制输出)

    6结构体数组及其初始化(重点)

    这里我们简单说下,具有相同类型的结构体变量组成数组就是结构体数组

    结构体数组与结构体变量区别只是将结构体变量替换为数组

    struct Student
    { 
    	char name[20];
    	char sex;
    	int number;
    }stu1[5]={
    	 {"zhaozixuan",'M',12345},
    	 {"houxiaohong",'M',12306},
    	 {"qxiaoxin",'W',12546},
    	 {"wangwei",'M',14679},
    	 {"yulongjiao",'W',17857}
    };
    stu1[3].name[3]//表示stu1的第三个结构变量中姓名的第五个字符
    //若初始化时已经是结构体数组全部元素[]中的数可以不写如stu1[]=
    

    注意结构体数组要在定义时就直接初始化,如果先定义再赋初值是错误的
    比如:

    struct Student stu1;
    stu1[3]={
      {"zhaozixuan",'M',12345},
      {"houxiaohong",'M',12306},
      {"qxiaoxin",'W',12546}
      };
      
    

    这样子是错误的,

    这里我在写的时候遇到一些问题,还是结构体数组初始化的问题,折腾了下解决了,给大家分享下
    对于数组初始化时
    比如

    char str[20];
    str="I love you";/* 这样会修改数组的地址,但是数组的地址分配之后是不允许改变的 */
    
    

    在第一条语句中 str就已经被定义成数组而在C99标准中不允许将字符串(实际上是一个指针变量) 赋值给数组,所以如果我们直接赋值是错误的

    那么怎么弄呢
    这里提供3种方法

    1.定义数组时直接定义
    char str[20]=“I love you”;

    2.用strcpy或者memset函数进行复制
    char str[20];
    strcpy(str,“I love you”);
    再用到memset函数时,出现了一些问题
    对于memcset函数简单介绍下

    memset
    void *memset(void *s,int c,size_t n)
    作用:将已开辟内存空间s的首n个字节的值设为值c。

    char str[20];
    memset(str,'a',20);
    

    如果是字符类型数组的话,memset可以随便用,但是对于其他类型的数组,一般只用来清0或者填-1,如果是填充其他数据就会出错

    int str[10];
    memset(str,1,sizeof(str));//这样是错误的
    
    

    这里我们说下这个错误,

    首先我们要知道memset在进行赋值时,是按字节为单位来进行赋值的,每次填充的数据长度为一个字节,而对于其他类型的变量,比如int,占4个字节 所以sizeof(str)=40; 而用memset赋值时,将会对指向str地址的前40个字节进行赋值0x01(00000001) 的操作,把0x00000000赋值4次0x01操作变为0x01010101(00000001000000010000000100000001)

    相当于给“前10个int”进行了赋值0x01010101的操作 对应十进制的16843009
    所以会出很大的错误

    这里请务必要注意,但是如果是清零一个数组用memset还是很方便的
    简单使用的话同学们用strcmp函数就行

    3用指针(注意内存分配)
    char *str;
    str=“I love you”;

    这两句话的本质是,在内存中开辟一段内存空间,把"I love you"放进这段内存空间,然后把这段内存空间的地址交给str,由于str是变量,所以给它赋值是合法的。

    请注意,在我们进行数组初始化的时候如果定义的数组过长,而我们只初始化了一部分数据,对于未初始化的数据如果是数值型,则会自动赋值为0,对于字符型,会自动赋初值为NULL,即‘\0’ 即不足的元素补以默认值
    这里我们在4小节中也提到了
    比如

    int str[10]={1};//这里只是把str的第一个元素赋值为1,其他元素默认为0
    
    



    7结构体与指针

    我们知道,指针指向的是变量所占内存的首地址,在结构体中,指针指向的是结构体变量的起始地址,当然也可指向结构体变量的元素
    这里我们分为三部分
    7.1指向结构体变量的指针

    定义形式一般为
    struct 结构体名* 指针名;
    比如: struct Student* p;

    struct Student
    {	
    	char cName[20];
     	int number;
     	char csex;  
    }student1;
    struct Student*p;
    p=&student1;
    //若为结构体数组则
    struct Student stu1[5];
    struct Student*p;
    p=stu1;//因为stu1为结构体数组而p=stu1直接是指向stu1的首地址,就不用再加&符
    
    

    用结构体指针变量访问结构体变量成员有以下两种方式:
    (*p).cName //这里的括号不能少,在5.1中有提到
    p->cName

    简单来说以下三种形式是等价的

    p->cName
    (*p).cName 
    student1.cName
    p->cName //可以进行正常的运算
    

    p->number++; 是将结构体变量中number的值进行运算,然后再加一,
    这里要注意下,等下在7.2中会有比较

    7.2指向结构体数组的指针

    7.1中我们已经提到结构体数组指针的命名,这里我们仅对一些知识点做下介绍
    这里我们接着来说结构体数组指针
    在我们想要用指针访问结构体数组的第n个数据时可以用

    struct Student stu1[5];
    struct Student*p;
    p=stu[n];
    (++p).number//是指向了结构体数组下一个元素的地址
    
    

    7.3结构体成员是指针类型变量
    比如

    struct Student
    {
     	char* Name;//这样防止名字长短不一造成空间的浪费
     	int number;
     	char csex;  
    }student1;
    
    

    在使用时可以很好地防止内存被浪费,但是注意在引用时一定要给指针变量分配地址,如果你不分配地址,结果可能是对的,但是Name会被分配到任意的一的地址,结构体不为字符串分配任何内存存储空间具有不确定性,这样就存在潜在的危险,

    struct Student
    {
     	char* Name;
     	int number;
     	char csex;  
    }stu,*stu;
    
    stu.name=(char*)malloc(sizeof(char));//内存初始化
    

    这里我们说一下,同学们看书的时候一般不会看到,
    如果我们定义了结构体指针变量,他没有指向一个结构体,那么这个结构体指针也是要分配内存初始化的,他所对应的指针类型结构体成员也要相应初始化分配内存

    struct Student
    {
     	char* Name;
     	int number;
    	char csex;  
    }stu,*stu;
    stu = (struct student*)malloc(sizeof(struct student));./*结构体指针初始化*/
      stu->name = (char*)malloc(sizeof(char));/*结构体指针的成员指针同样需要初始化*/  
    
    

    7.4二叉树遍历算法
    二叉树的二叉链表类型定义如下:
    typedef struct btnode {
    datatype data;
    struct btnode *lchild,*rchild;
    };
    这里我们仅仅提出以下,因为涉及到链表,感兴趣的同学可以去学习下(二级要用),
    7.5结构体作为函数参数

    首先我们要注意的一点,使用结构体变量作为函数参数的时候,采取的是值传递的方式,将结构体所占内存单元的内容全部传递给形参,并且形参必须也要是同类型的结构体变量,在使用时,会自动创建一个结构体变量作为原变量的副本,并且也需要占内存,并且在调用期间如果修改(形参)结构体中成员的值,修改值是无效的

    而如果用指针作为实参,传递给函数的形参,这时候传递的是结构体的地址,形参所指向的地址就是结构体变量的地址,这时候进行修改的话是可以修改的,这正是指针的精华所在

    在这里我们再提供几种互换两个结构体的方法

    struct Student
    {
     char cName[20];
     int number;
     char csex;  
    }student1,student2;
    struct Student student1={"Wang",12345,'W'};
    struct Student student2={"Zhao",54321,'M'}; 
    struct Student*stu1=&student1;
    struct Student*stu2=&student2;
    
    struct Student *student3;
    student3=stu1;
    stu1=stu2;
    stu2=student3;//互换地址
    
    2对于同类型结构体直接互换值就行
    struct stu student3;
    student3=student1;
    student1=student2;
    student2=student3;
    //这里也可以写成应strcmp函数互换
    
    3memcpy()函数进行互换
    
    
    4比较笨的方法: 用for循环互换
    

    最后提下memset清空结构体

    struct Student
    {
     char cName[20];
     int number;
     char csex;  
    }stu1;
    
    一般情况下,清空str的方法:
      str.cName[0]='\0';
      str.csex='0';
      str.number=0;
      但是我们用memset就非常方便:
      memset(&str,0,sizeof(struct Student));
      如果是数组:
      struct Student stu[10];
      就是
      memset(stu,0,sizeof(struct Student)*10);
    

    整理不易,点个赞再走呗!

    展开全文
  • 2、初始化、顺序表数据结构大小、长度 3、赋值、顺序表数据结构赋值 4、插入、在指定位置插入数据,后续数据循环后移,长度增加,空间大小增加或者不变 5、删除、删除指定位置的数据,后续数据循环前移,长度减小...

    c语言 顺序表的基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出)

    1、创建、申请空间

    2、初始化、顺序表数据结构大小、长度

    3、赋值、顺序表数据结构赋值

    4、插入、在指定位置插入数据,后续数据循环后移,长度增加,空间大小增加或者不变

    5、删除、删除指定位置的数据,后续数据循环前移,长度减小、空间大小不变

    6、查询、查看指定数据是否在顺序表结构中

    7、替换、将顺序表结构中指定数值替换为另外的数值

    8、输出、输出顺序表结构中存储的数据(根据长度大小输出)

    代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <Windows.h>
    #define Size 5
    //显示日期、时间、文件信息
    void xinxi()
    {
    
    	printf("Date : %s\n", __DATE__);
    	printf("Time : %s\n", __TIME__);
    	printf("File : %s\n", __FILE__);
    	printf("Line : %d\n", __LINE__);
    	printf("\n***以下是程序部分***\n\n");
    	
    }
    //定义顺序表结构
    typedef struct Table
    {
    	int *head;//类似于数组指针
    	int length;//数据长度
    	int size;//机构大小
    }table;
    //初始化顺序表结构
    table initcreact()
    {
    	table t;
    	if ((t.head = (int *)malloc(Size*sizeof(int))) == NULL)
    	{
    		printf("申请存储空间失败!");
    			exit(1);
    	}
    	t.length = 0;//初始化长度为 0
    	t.size = Size;//结构大小
    	return t;
    }
    //结构赋值
    table fuzhi(table t)
    {
    	int i;
    	for (i = 0; i < t.size; i++)
    	{
    		t.head[i] = i + 1;
    		t.length++;//长度随赋值情况增加
    	}
    	return t;
    }
    //输出结构存储情况
    table prt(table t)
    {
    	printf("存储的数据如下:\n");
    	for (int i = 0; i < t.length; i++)
    		printf("%d ", t.head[i]);
    	printf("\n");
    	return t;
    }
    //插入数据
    table insert(table t,int elme,int add)
    {
    	if (t.length == t.size)//如果数据结构已满,增加存储空间
    		t.head= (int *)realloc(t.head, (t.size + 1) * sizeof(int));
    	if (t.head == NULL)
    	{
    		printf("申请存储空间失败!\n");
    		exit(1);
    	}
    	else t.size++;//空间大小增加
    	int i = t.size;
    	for (; i >= elme-1; i--)//数据循环后移
    		t.head[i] = t.head[i - 1];
    	t.head[elme-1] = add;//指定位置插入数据,赋值
    	t.length++;//长度增加
    	return t;
    }
    //删除指定数据
    table deleter(table t, int elme)
    {
    	int i = elme-1;
    	for (; i <= t.size; i++)
    		t.head[i] = t.head[i +1];
    	t.head[i] = 0;
    	t.length--;
    	return t;
    }
    //查询指定数据,返回在数据结构中的位置
    int select(table t, int elme)
    {
    	int i;
    	for (i = 0; i <= t.length; i++)
    	{
    		if (t.head[i] == elme)
    			return i+1;
    	}
    	return -1;
    }
    //替换指定数据
    table tihuan(table t, int elme, int add)
    {
    	int i=select(t,elme);
    	
    		t.head[i-1] = add;
    		return t;
    	
    }
    //主函数
    int main()
    {
    	xinxi();
    	table t = initcreact();
    	t = fuzhi(t);
    	t = prt(t);
    	int elme;
    	printf("请输入插入的位置:");
    	scanf("%d", &elme);
    	int add;
    	printf("请输入插入数据:");
    	scanf("%d", &add);
    	if (elme > t.size+1 || elme < 0)
    	{
    		printf("输入的位置错误\n");
    		exit(0);
    	}
    	t = insert(t, elme,add);
    	t = prt(t);
    	printf("请输入删除的位置:");
    	scanf("%d", &elme);
    	if (elme > t.size || elme < 0)
    	{
    		printf("输入的位置错误\n");
    		exit(0);
    	}
    	t = deleter(t, elme);
    	t = prt(t);
    	printf("查找 5 的位置\n");
    	elme = select(t, 5);
    	printf("5 的位置是 %d\n", elme);
    
    	t = prt(t);
    	printf("用 55 替换 5\n");
    	tihuan(t, 5, 55);
    	t = prt(t);
    
    	system("pause");
    	return 0;
    }

     

     

    展开全文
  • 数据结构 图的初始化

    千次阅读 2017-10-23 23:53:07
    //创建一个图 初始化:只有顶点没有边 void InsertGraphic(eEdge* E); //插入一条边 void BuildGraphic(); //图的建立 }; void GraphicOperation::CreateGraphic(int vertexNum) { ObjectGrahpic->Nv = ...
  • 一部分伪代码 c++代码 #include using namespace std;.../*是一种数据结构,用数组的形式表现出来*/ class stackClass//不需要typedef { private: int data[stack_Size]; int top; public: void i
  • //初始化top = base = 0 //因为在Push的操作中,每次完了之后都是使得top++; //如果top==MAXLEN-1的时候,完成之后就会执行top++,这个时候其实top已经在预分配内存之外了 //所以才有了下一步(top-base>=base),从而...
  • 数据结构初始化操作汇总

    千次阅读 2013-08-04 21:16:01
    数据结构初始化操作 1.顺序表的初始化: void InitList(SqList *&L) //初始化线性表 {  L = (SqList *)malloc(sizeof(SqList)); //分配存放线性表的空间  L -> length = 0; //置空线性表长度为0 }   2....
  • 数据结构-单链表基本操作-C语言代码

    万次阅读 多人点赞 2020-01-22 19:51:58
    本篇只有c语言代码,具体思路讲解请看这篇博客:数据结构-线性结构-单链表 1.头插法建立单链表 #include<stdio.h> #include<stdlib.h> //单链表的结构定义 typedef struct LNode { int data...
  • 大一学C语言的时候还没觉得有啥难的,直到现在学了数据结构。。。 还是自己技术不过关,理解不到位,还需要努力。。。 下面贴关于顺序栈的代码: #include<stdio.h> #include<stdlib.h> //存储...
  • 本文主要介绍在类中简化数据结构初始化过程的技巧
  • 以下的定义结构体的方式是我看过那么多别人的代码以来让我感觉最容易看懂的,对新手也是很友好的,反正我创建新结点或者是传参只需要写一种形式struct List* ptr = ...; 就可以了。 struct List { int val;...
  • 开始学习数据结构已经一个月了,一共上了16节课,开始还是有点困难,毕竟过了一个暑假,C++的知识有些遗忘,还有就是指针部分学习海华丝不够扎实,所以这个月在数据结构这个课程上面,还是有点点吃力,所以先开始问...
  • 1、顺序表初始化 2、顺序表插入元素 3、顺序表删除元素 4、顺序表查找元素 5、顺序表合并 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素。 顺序存储方式不仅只用于存储线性结构。 ...
  • 数据结构C语言版——初始化一个线性表

    万次阅读 多人点赞 2017-03-09 20:31:43
    数据结构C语言版——初始化一个线性表
  • 适合初学数据结构,不明白如何通过代码实现顺序表。 超简洁代码如下: # include <stdio.h> # define initsize 10 //表长度的初始定义 # define maxsize 50 //定义线性表的最大长度 //顺序表结构的头文件 ...
  • VPP借鉴了FreeBSD协议栈的graphnode处理思想,报文的处理是在一个个node之间逐级处理,除VPP预定义的node... node的基础数据结构如上图所示,__bootstrap_vlib_main_vector是最顶级的全局变量,此变量下的vm是一个...
  • 考研数据结构代码整理

    万次阅读 多人点赞 2019-10-07 22:10:37
    顺序表的基本操作2.1)初始化顺序表2.2)求指定位置元素2.3)插入数据元素2.4)按元素值查找2.5)删除数据元素2.6)顺序表的元素逆置2.7)删除下标为i~j的数据元素2.8)Partition操作3. 单链表的基本操作3.1)初始...
  • #include&lt;bits/stdc++.h&gt; #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; using namespace std; typedef int ElemType; typedef struct pNode{ ElemType data;......
  • //假定栈中最多保存5个数据 //定义名为stack的类,其具有栈功能 class stack { //数据成员 float num[MAX]; //存放栈数据的数组 int top; //指示栈顶位置的变量 public: //成员函数 void i
  • #include #include #define LIST_INIT_SIZE 10 /*存储空间初始分配量*/ #define LISTINCREMENT 10 /*存储空间分配增量*/ typedef struct sqlist{ int *elem; /*首地址*/ int length; /*当前长度*/ int listsize; /*...
  • 数据结构-顺序表基本操作的实现(含全部代码

    万次阅读 多人点赞 2018-09-13 22:14:57
    今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。 今天是线性表中的顺序表的实现,主要实现函数如下,读者有需要可以评论,我可以适当加几个。...
  • 1.第一步定义线性表结构 typedef struct { ElementType data[MaxSize];...2.第二步线性表初始化 //初始化线性表 Lineartable* INITAL(){ Lineartable *lineartable; lineartable = (Lineartable...
  • 图结构 非常得类似我们之前讲到过的树结构,但前者没有很多的...在数学的概念中,后者是前者的一种,不过在数据结构中我们还是认为两者有所区别,尽管如此,我们在学习图结构的时候仍可以稍微借鉴一下树结构的思想。
  • 数据结构-快速排序(含全部代码

    万次阅读 2021-03-15 17:09:19
    算法可视 函数分析 QuickSort(SqList &L,int low,high) 参数:顺序表L,待排最小下标,待排最大下标 功能:排序(默认升序)空间复杂度:O(1) 时间复杂度:O(nlog2n)-O(n) 稳定性:不稳定 代码 //快速...
  • 代码如下#include &lt;iostream&gt; #include&lt;malloc.h&gt; #define MaxSize 10 using namespace std; typedef int DataType; typedef struct { ...//创建顺序栈 初始化 SeqSt...
  • 随手练习一下,详细代码解释都在代码片里请仔细看看 如果有什么不对的地方,请在下方留言 先建立头文件: #define _CRT_SECURE_NO_WARNINGS 1 #ifndef _TEST_H #define _TEST_H //栈的链式存储结构; typedef struct...
  • C语言实现链栈的创建和基本操作(初始化,进栈,出栈等等) 往期文章: C语言实现顺序表的创建及基本操作 C语言实现单链表的创建及基本操作 C语言实现顺序栈的创建和操作(进栈,出栈,打印等等 今天闲来无事,就水一...
  • 数据结构之栈的运用
  • 数据结构中循环队列的使用

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 592,419
精华内容 236,967
关键字:

数据结构创建初始化堆代码

数据结构 订阅