数据结构（c语言版）（第三版）实验3

已于 2022-05-12 19:42:29 修改
阅读量2.4k 收藏 28
点赞数 4
分类专栏： 数据结构 文章标签： c++
于 2022-03-26 20:05:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanlangke/article/details/123762408
版权

1、实验3 带头节点的单链表

运行环境：Dev-C++

一、实验目的

1.理解带头节点的单链表的特点，掌握其基本操作。

2.熟练掌握运用带头节点链表表示特定形式的数据的方法，并设计出有关算法。

二、实验内容

已知带头节点的链表结构定义及头插法建表，尾插法建表和打印链表等函数定义如下（详见slnklist.h文件），基于该内容完成实验题1~实验9。

#include <stdio.h>
#include <stdlib.h>
/**************************************/
/* 链表实现的头文件，文件名slnklist.h */
/**************************************/
 typedef int datatype;
 typedef struct link_node{
   datatype info;
   struct link_node *next;
 }node;
typedef node *linklist;
/******************************************/
/*函数名称：creatbystack()                 */
/*函数功能：头插法建立带头结点的单链表    */
/******************************************/
linklist creatbystack()
{
​
    linklist  head,s;
    datatype x;
    head=(linklist)malloc(sizeof(node));
    head->next=NULL;
​
    printf("请输入整数序列（空格分开，以0结束）:\n");
    scanf("%d",&x);
    while (x!=0)
    {
        s=(linklist)malloc(sizeof(node));
        s->info=x;
​
        s->next=head->next;
        head->next=s;
​
        scanf("%d",&x);
    }
    return head;
}
/***************************************/
/*函数名称：creatbyqueue()              */
/*函数功能：尾插法建立带头结点的单链表 */
/***************************************/
linklist creatbyqueue()
{
    linklist head,r,s;
    datatype x;
    head=r=(linklist)malloc(sizeof(node));
    head->next=NULL;
    printf("请输入整数序列（空格分开，以0结束）:\n");
    scanf("%d",&x);
    while (x!=0)
    {
         s=(linklist)malloc(sizeof(node));
         s->info=x;
         r->next=s;
         r=s;
         scanf("%d",&x);
   }
    r->next=NULL;
    return head;
}
/**********************************/
/*函数名称：print()                   */
/*函数功能：输出带头结点的单链表      */
/**********************************/
void print(linklist head)
{
    linklist p;
    int i=0;
    p=head->next;
    printf("List is:\n");
    while(p)
    {
        printf("%7d",p->info);
        i++;
        if (i%10==0)    printf("\n");
        p=p->next;
    }
    printf("\n");
​
}
​
/******************************************/
/*函数名称：creatLink()                */
/*函数功能：从文件中读入n个数据构成单链表 */
/******************************************/
linklist creatLink(char *f, int n)
{
    FILE *fp;
    int i;
    linklist s,head,r;
    head=r=(linklist)malloc(sizeof(node));
    head->next=NULL;
    fp=fopen(f,"r");
    if (fp==NULL)
        return head;
    else
    {
         for (i=0;i<n;i++)
            {
                s=(linklist)malloc(sizeof(node));
                fscanf(fp,"%d",&(s->info));
                r->next=s;
                r=s;
            }
        r->next=NULL;
        fclose(fp);
        return head;
    }
}
​
/*
    函数名称：writetofile
    函数功能：将链表内容存入文件f
*/
void writetofile(linklist head, char *f)
{
    FILE *fp;
    linklist p;
    int i=0;
    fp=fopen(f,"w");
    if (fp!=NULL)
    {
        p=head->next;
        fprintf(fp,"%s","List is:\n");
        while(p)
        {
            fprintf(fp,"%7d",p->info);
            i++;
            if (i%10==0)    fprintf(fp,"%c",'\n');
            p=p->next;
        }
        fprintf(fp,"%c",'\n');
        fclose(fp);
    }
    else    printf("创建文件失败!");
​
}
​
​
/**********************************/
/*函数名称：delList()                 */
/*函数功能：释放带头结点的单链表      */
/**********************************/
void delList(linklist head)
{ linklist p=head;
  while (p)
  { head=p->next;
    free(p);
    p=head;
  }
}

实验3.1

编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。 并构造测试用例进行测试。

/*编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。
并构造测试用例进行测试。
*/
/**********************************/
/*文件名称：lab3_01.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist delx(linklist head,datatype x)
{
    node* p=head;
    node* q=p->next;
    while(q){
        if(q->info==x){
            p->next=q->next;
            return head;
            break;
        }
        p=p->next;
        q=q->next;
    } 
}
​
int main()
{   datatype x;
    linklist head;
    head=creatbyqueue();        /*尾插入法建立带头结点的单链表*/
    print(head);
    printf("请输入要删除的值：");
    scanf("%d",&x);
    head=delx(head,x);          /*删除单链表的第一个值为x的结点*/
    print(head);
    delList(head);              /*释放单链表空间*/
    return 0;
}

实验3.2

假设线性表（a1,a2,a3,…an）采用带头结点的单链表存储，请设计算法函数linklist reverse(linklist head)， 将带头结点的单链表head就地倒置，使表变成（an,an-1,…a3.a2,a1）。并构造测试用例进行测试。

/**********************************/
/*文件名称：lab3_02.c                 */
/**********************************/
/*
假设线性表（a1,a2,a3,…an）采用带头结点的单链表存储，请设计算法函数linklist reverse(linklist  head)，
将带头结点的单链表head就地倒置，使表变成（an,an-1,…a3.a2,a1）。并构造测试用例进行测试。
*/
#include "slnklist.h"
#include<iostream>
using namespace std;
#include<vector>
/*请将本函数补充完整，并进行测试*/
linklist reverse(linklist head)
{
    vector<int> a;
    node* p=head->next;
    while(p){
        a.push_back(p->info);
        p=p->next;
    }
    p=head->next;
    while(p){
        p->info=a.back();
        a.pop_back();
        p=p->next; 
    }
    return head;
}
int main()
{   datatype x;
    linklist head;
    head=creatbystack();            /*头插入法建立带头结点的单链表*/
    print(head);                    /*输出原链表*/
    head= reverse(head);            /*倒置单链表*/
    print(head);                    /*输出倒置后的链表*/
    delList(head);
    return 0;
}

实验3.3

假设带头结点的单链表head是升序排列的，设计算法函数linklist insert(linklist head,datatype x)， 将值为x的结点插入到链表head中，并保持链表有序性。 分别构造插入到表头、表中和表尾三种情况的测试用例进行测试。

/*
假设带头结点的单链表head是升序排列的，设计算法函数linklist insert(linklist head,datatype x)，
将值为x的结点插入到链表head中，并保持链表有序性。
分别构造插入到表头、表中和表尾三种情况的测试用例进行测试。
*/
/**********************************/
/*文件名称：lab3_03.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist insert(linklist head ,datatype x)
{
    node* p=head;
    node* q=p->next;
    while(q){
        if(q->info>x){
            node* a=(node*)malloc(sizeof(node));
            p->next=a;
            a->info=x;
            a->next=q;
            return head;
        }
        else{
            p=p->next;
            q=q->next;
        }
    }
        if(q==NULL){
            node* a=(node*)malloc(sizeof(node));
            p->next=a;
            a->info=x;
            a->next=NULL;
            return head;
        }
}
int main()
{   datatype x;
    linklist head;
    printf("输入一组升序排列的整数：\n");
    head=creatbyqueue();                /*尾插入法建立带头结点的单链表*/
    print(head);
    printf("请输入要插入的值：");
    scanf("%d",&x);
    head=insert(head,x);                /*将输入的值插入到带头结点的单链表适当位置*/
    print(head);
    delList(head);
    return 0;
}

实验3.4

编写算法函数linklist delallx(linklist head, int x)，删除带头结点单链表head中所有值为x的结点。

/*
编写算法函数linklist delallx(linklist head, int x)，删除带头结点单链表head中所有值为x的结点。
*/
/**********************************/
/*文件名称：lab3_04.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist delallx(linklist head,int x)
{
    node* p=head;
    node* q=head->next;
    while(q){
        if(q->info==x){
            p->next=q->next;
            q=q->next;
        }
        else{
            q=q->next;
            p=p->next;
        }
    }
    return head;
}
int main()
{   datatype x;
    linklist head;
    head=creatbyqueue();                /*尾插入法建立带头结点的单链表*/
    print(head);
    printf("请输入要删除的值：");
    scanf("%d",&x);
    head=delallx(head,x);
    print(head);
    delList(head);
    return 0;
}

实验3.5

已知线性表存储在带头结点的单链表head中，请设计算法函数void sort(linklist head)，将head中的结点按结点值升序排列。

/*
已知线性表存储在带头结点的单链表head中，请设计算法函数void sort(linklist head)，将head中的结点按结点值升序排列。
*/
/**********************************/
/*文件名称：lab3_05.c                 */
/**********************************/
#include "slnklist.h"
#include<vector>
#include<iostream>
using namespace std;
/*请将本函数补充完整，并进行测试*/
void  sort(linklist head){
    vector<int> a;
    node* pp=head->next;
    while(pp){
        a.push_back(pp->info);
        pp=pp->next;
    }
    head->next=NULL;
    while(!a.empty()){
        node* pp=head;
        node* q=head->next;
        while(q){
            if(q->info>a.back()){
                node* s=(node*)malloc(sizeof(node));
                pp->next=s;
                s->info=a.back();
                s->next=q;
                a.pop_back();
                break;
            }
            else{
            pp=q;
            q=q->next;
            }   
        }
            if(!q){
                node* s=(node*)malloc(sizeof(node));
                pp->next=s;
                s->next=NULL;
                s->info=a.back();
                a.pop_back(); 
            }
    }
}
​
int main()
{        linklist head;
         head=creatbyqueue();           /*尾插法建立带头结点的单链表*/
         print(head);                   /*输出单链表head*/
         sort(head);                    /*排序*/
         print(head);
         delList(head);
         return 0;
}

实验3.6

已知两个带头结点的单链表L1和L2中的结点值均已按升序排序，设计算法函数 linklist mergeAscend (linklist L1,linklist L2)将L1和L2合并成一个升序的 带头结单链表作为函数的返回结果； 设计算法函数linklist mergeDescend (linklist L1,linklist L2) 将L1和L2合并成一个降序的带头结单链表作为函数的返回结果； 并设计main()函数进行测试。

/*
已知两个带头结点的单链表L1和L2中的结点值均已按升序排序，设计算法函数
linklist mergeAscend (linklist L1,linklist L2)将L1和L2合并成一个升序的
带头结单链表作为函数的返回结果；
设计算法函数linklist mergeDescend (linklist L1,linklist L2)
将L1和L2合并成一个降序的带头结单链表作为函数的返回结果；
并设计main()函数进行测试。
*/
/**********************************/
/*文件名称：lab3_06.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist mergeAscend(linklist L1,linklist L2)
{
    node* L3=(node*)malloc(sizeof(node));
    node* r=L3;
    node* p=L1->next,*q=L2->next;
    while(p&&q){
        if(p->info>q->info){
            node* s=(node*)malloc(sizeof(node));
            s->info=q->info;
            q=q->next;
            r->next=s;
            r=s;
        }
        else{
            node* s=(node*)malloc(sizeof(node));
            s->info=p->info;
            p=p->next;
            r->next=s;
            r=s;    
        }
    }
    while(p){
        node* s=(node*)malloc(sizeof(node));
        s->info=p->info;
        p=p->next;
        r->next=s;
        r=s;
    }   
    while(q){
        node* s=(node*)malloc(sizeof(node));
        s->info=q->info;
        q=q->next;
        r->next=s;
        r=s;
    }
    r->next=NULL;
    return L3;
}
linklist mergeDescend(linklist L1,linklist L2)
{
    node* r=NULL;
    node* L3=(node*)malloc(sizeof(node));
    node* p=L1->next,*q=L2->next;
    while(p&&q){
        if(p->info>q->info){
            node* s=(node*)malloc(sizeof(node));
            s->info=q->info;
            q=q->next;
            s->next=r;
            r=s;
        }
        else{
            node* s=(node*)malloc(sizeof(node));
            s->info=p->info;
            p=p->next;
            s->next=r;
            r=s;    
        }
    }
    while(p){
            node* s=(node*)malloc(sizeof(node));
            s->info=p->info;
            p=p->next;
            s->next=r;
            r=s;
    }   
    while(q){
            node* s=(node*)malloc(sizeof(node));
            s->info=q->info;
            q=q->next;
            s->next=r;
            r=s;
    }
    L3->next=r;
    return L3;
}
int main()
{       linklist h1,h2,h3;
         h1=creatbyqueue();     /*尾插法建立单链表,请输入升序序列*/
         h2=creatbyqueue();
         print(h1);
         print(h2);
//         h3=mergeAscend(h1,h2);/*升序合并到h3*/
         h3=mergeDescend(h1,h2); //降序合并请调用
         print(h3);
         delList(h3);
         return 0;
}

实验3.7

设计一个算法linklist interSection(linklist L1,linklist L2)， 求两个单链表表示的集合L1和L2的交集，并将结果用一个新的带头 结点的单链表保存并返回表头地址。

/*
设计一个算法linklist interSection(linklist L1,linklist L2)，
求两个单链表表示的集合L1和L2的交集，并将结果用一个新的带头
结点的单链表保存并返回表头地址。
*/
/**********************************/
/*文件名称：lab3_07.c                 */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist   interSection(linklist L1, linklist L2)
{
    node* L3=(node*)malloc(sizeof(node));
    node* r=L3;
    node* p=L1->next;
    while(p){
        node* q=L2->next;           
        while(q){
            if(p->info==q->info){
                node* s=(node*)malloc(sizeof(node));
                s->info=p->info;
                r->next=s;
                r=s;
                r->next=NULL; 
            }
            q=q->next;
        }
        p=p->next;
    }
    return L3;
}
int main()
{
 linklist h1,h2,h3;
 h1=creatbyqueue();           /*尾插法建立单链表,输入时请勿输入重复数据*/
 h2=creatbyqueue();
 print(h1);                   /*输出单链表h1*/
 print(h2);
 h3=interSection(h1,h2);      /* 求h1和h2的交集*/
 print(h3);
 delList(h1);
 delList(h2);
 delList(h3);
 return 0;
}

实验3.8

请编写一个算法函数void partion(linklist head)， 将带头结点的单链表head中的所有值为奇数的结点调整 到链表的前面，所有值为偶数的结点调整到链表的后面。

/*
请编写一个算法函数void partion(linklist head)，
将带头结点的单链表head中的所有值为奇数的结点调整
到链表的前面，所有值为偶数的结点调整到链表的后面。
*/

/**********************************/
/*文件名称：lab3_08.c             */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
void partion(linklist head)
{
	if(head->next->next&&head->next){
		node* p=head->next;
		node* q=head->next->next;
		while(q){
			if(q->info%2==1){
				p->next=p->next->next;
				q->next=head->next;
			 	head->next=q;
			 	q=p->next;
			} 	 
			else{
				p=p->next;
				q=q->next;	
			}
		}
	}

}
int main()
{        linklist head;
         head=creatbyqueue();           /*尾插法建立带头结点的单链表*/
         print(head);                   /*输出单链表head*/
         partion(head);
         print(head);
         delList(head);
         return 0;
}

实验3.9

编写一个程序，用尽可能快的方法返回带头结点单链表中倒数第k个结点的地址，如果不存在，则返回NULL。

/*
编写一个程序，用尽可能快的方法返回带头结点单链表中倒数第k个结点的地址，如果不存在，则返回NULL。
*/
/**********************************/
/*文件名称：lab3_09.c             */
/**********************************/
#include "slnklist.h"
/*请将本函数补充完整，并进行测试*/
linklist   search(linklist head,int k)
{
	int i=0;
	node* p=head;
	while(p){
		i++;
		p=p->next;
	}
	p=head;
	if(i-k<=0)
		return NULL;
	else{
		for(int j=0;j<i-k;j++){
			p=p->next;
		}	
		return p;
	}

}
int main()
{
     int k;
     linklist head,p;
     head=creatbyqueue();        /*尾插法建立带头结点的单链表*/
     print(head);                  /*输出单链表head*/
     printf("k=");
     scanf("%d",&k);
     p=search(head,k);
     if (p) printf("%d\n",p->info);
     else
         printf("Not Found!\n");
     delList(head);
     return 0;
}
fanlangke
关注
  • 4
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构（C语言版)（第3版）实验三（答案）
qq_62804018的博客
03-21 2293
一共有9个实验没写思路只有代码（可以参考） 1、/*编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。 并构造测试用例进行测试 linklist delx(linklist head,datatype x){ linklist p=head->next; linklist pre=head; while(p){ if(p->info==x){ ...
【C语言】数据结构C语言版 实验3 带头结点的单链表
点滴记忆
12-09 4949
slnklist.h #include <stdio.h> #include <stdlib.h> /**************************************/ /* 链表实现的头文件，文件名slnklist.h */ /**************************************/ typedef int datatype...
数据结构实验报告（三）——带头结点的单链表
future_dreaming的博客
01-10 806
带头结点的单链表打印输出、删除奇数、有序表的插入，两降序表合并成升序表等系列操作
数据结构实验三
kexuhang的博客
06-16 1156
题目描述 树形结构是一类重要的非线性数据结构，其中以树和二叉树最为常用。对于每一个结点至多只有两棵子树的一类树，称其为二叉树。二叉树的链式存储结构是一类重要的数据结构，其形式定义如下：而二叉树的前序、中序遍历是非常重要的能够访问二叉树所有结点的算法，下面分别列出一种先序遍历和两种中序遍历的算法。第一种中序遍历的方法（算法6.3）：第二种中序遍历的方法（算法6.2）：通过读入一个字符串，建立二叉树的算法如下：在本题中，将会给出一个按照先序遍历得出的字符串，空格代表空的子节点，大写字母代表节点内容。请通过这个字
数据结构教程实验三栈的应用
Annzz123的博客
06-16 1578
三、实验要求1.用Ｃ描述栈的每种操作在顺序栈或链栈上的实现。2.将初始化栈、判断栈是否非空、入栈、出栈、十进制到二进制的转换分别定义为5个子函数，通过主函数实现对上述子函数的调用。四、实验内容 1.实现顺序栈的各种基本运算在实现顺序栈各种基本运算的基础上，设计主程序，完成如下功能：（1）初始化栈s。（2）判断栈s是否为空。3）依次将6，3，8，10元素进栈s。（4）判断栈s是否为空。（5）输出栈序列。（6）判断栈s是否为空。（7）释放栈s。
【数据结构】实验三：链表
m0_65787507的博客
07-27 2156
数据结构实验
数据结构第三版C语言-实验1.doc
08-26
数据结构实验是IT教育中的重要组成部分，它旨在帮助学生将理论知识转化为实践能力。这个实验课程专注于数据结构的基础，特别是线性表的实现，通过一系列的实验任务来增强学生的理解和应用技巧。 实验1主要涉及...
数据结构实验指导书C语言版
05-11
数据结构实验指导书C语言版 本实验指导书旨在帮助学生掌握顺序表的操作实验，包括顺序表的建立、插入、删除和查找操作。实验要求学生熟练掌握 C 语言的编程规则、方法和顺序表的基本操作算法。实验的软硬件环境要求...
数据结构第五版C语言邓文华第九章
03-09
数据结构第五版C语言邓文华第九章 本节课程主要讲解了顺序表的基本运算，包括顺序表的初始化、插入、查找和删除等操作。通过实验，学生可以掌握顺序表的基本概念和操作方法。 一、顺序表的基本概念 顺序表是一种...
数据结构(C语言版)(第2版)课后习题答案.pdf
06-18
数据结构（C语言版）（第2版）课后习题答案 本资源提供了数据结构（C语言版）（第2版）配套书的课后习题答案，涵盖了数据结构的基本概念、线性表、栈和队列、串、数组和广义表、树和二叉树、图、查找和排序等方面的...
数据结构实验指导书C语言版罗先文样本.doc
11-26
"数据结构实验指导书C语言版罗先文样本.doc" 本资源是面向计算机专业学生的一本实验指导书，旨在帮助学生更好地理解和应用数据结构的基本概念和技术。实验指导书共分为七个大单元，每个单元都基于数据结构的基本...
编写算法函数linklist delallx(linklist head, int x)，删除带头结点单链表head中所有值为x的结点。
linjiajun12123的博客
11-04 7389
/* 编写算法函数linklist delallx(linklist head, int x)，删除带头结点单链表head中所有值为x的结点。 */ linklist delallx(linklist head,int x) {    linklist p=head->next,q=NULL;    while(p!=NULL)    {        while(p->info!
带头结点的单向循环链表的定义，初始化，加工（插入，删除，修改），遍历,实例
frozen122的博客
04-05 1494
带头节点的单向循环链表 头指针指向第一个结点的地址，当头指针为空时，链表为空。 建立 typedef struct { char name[20]; float score; } STD; typedef STD ElemType; typedef struct Londe { ElemType data; //data是一个STD类型的变量 struct Lnode *next; }LNode,*LinkList; //LNode是结点数据类型，LinkList为指向节点的指针类型
写一个带头结点的循环单链表
weixin_35753431的博客
02-11 92
循环单链表是一种特殊的链表，它的最后一个节点的 next 指针指向第一个节点，形成一个环。 带头结点的循环单链表是指在循环单链表的开头添加了一个虚拟的头结点，头结点不存储任何数据，只是为了方便链表的操作。 下面是带头结点的循环单链表的实现代码： class Node: def __init__(self, data): self.data = data se...
带头节点循环单链表【详细解析+完整代码】
ChenLin55的博客
05-17 5246
循环单链表在单链表的基础上进行改进。思考一下，普通单链表从表头遍历到表尾，时间复杂度为o(n)，如果我想从表尾找到表头呢？时间复杂度也还是o(n)。怎么快速从表尾找到表头，于是引入了循环链表。整个链表形成闭环，表尾找到表头，时间复杂度为o(1)。循环单链表是首尾相连的一种单链表，即将最后一个结点的空指针改为指向头结点或第一个结点的形成一个环型，最后一个结点称为尾指针:tail。判断单链表为空的条件是 head->next == NULL，而判断循环单链表为空的条件是。
[数据结构]线性链式存储-带头结点的单链表，循环单链表
qq_61109509的博客
03-15 2931
文章目录链表带头结点和不带头结点的区别实验一 链表带头结点和不带头结点的区别 所有链表都有一个头指针head，带头结点中head数据为空，不带头结点在头结点存在数据，此时从头插入数据是时，head时刻变化 1带头结点链表插入,使用p等于插入前的结点 x->next=p->next; p->next=x; 2不带头结点插入 插入链表开头 x->next=head->next; head=x//这里不是head->next=x 插入链表其他位置,用p等于插入前的结点
【数据结构】实验三 求两个集合（用单链表表示）的并、交和差运算
weixin_61693556的博客
04-08 5803
实验要求：在实验二的基础上，使用单链表表示集合，编写三个算法（求交算法、求并算法、集合求差），并输出最终的结果。 例如： 集合A为（3、4、1、6），集合B为（2、3、6、7） 交集为：（3、6） 并集为：（1、2、3、4、6、7） 差集为：（1、4） （注意：差集C=A-B,即属于A但不属于B的元素的集合） #include<iostream> using namespace std; #define ElemType char typedef struct LNode // 定义结构体.
C语言 之 理解指针（1）
最新发布
fallzzzzz的博客
07-20 1190
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
谭浩强C语言程序设计第三版精华概览
"谭浩强《C语言程序设计》第三版pdf包含目录，代码可复制，高清，4M大小，是第三版的最佳PDF版本。" 本书是针对C语言编程的一本经典教程，由谭浩强编写，适用于初学者和有一定基础的学习者。以下是该书的一些关键...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

fanlangke

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值