① c语言动态链表，改写程序，学生的人数由用户输入获得，使用链表实现。用malloc和free动态申请和释放内存
以前做过的类似的一个 你拿去看看改改
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BUFSIZE 1024
#define WORDSIZE 32
#define DESTSIZE 512
#define NR 26
struct node_st {
struct node_st *arr[NR];
char *str;
};
static int pos_hash(char ch)
{
return ch - 'a';
}
static int read_file(FILE *fp, char *word, char *dest)
{
char buf[BUFSIZE] = {};
if (fgets(buf, BUFSIZE, fp) == NULL)
return -1;
buf[strlen(buf)-1] = 0;
sscanf(buf, "%s %s", word, dest);
return 0;
}
static void tree_insert(struct node_st **root, const char *word, const char *dest)
{
struct node_st *new;
int i;
if (*root == NULL) {
new = malloc(sizeof(*new));
//if error
for (i = 0; i < NR; i++)
(new->arr)[i] = NULL;
new->str = NULL;
*root = new;
}
if (*word == '\0') {
(*root)->str = strp(dest);
return;
}
tree_insert(&((*root)->arr)[pos_hash(*word)], word+1, dest);
}
static char *tree_search(struct node_st *root, char *word)
{
if (root == NULL)
return NULL;
if (*word == '\0')
return root->str;
tree_search((root->arr)[pos_hash(*word)], word+1);
}
int main(int argc, char **argv)
{
FILE *fp;
struct node_st *root = NULL;
char word[WORDSIZE] = {};
char dest[DESTSIZE] = {};
char *ret;
if (argc < 3)
return 1;
fp = fopen(argv[1], "r");
//if error
while (1) {
if (read_file(fp, word, dest) < 0)
break;
tree_insert(&root, word, dest);
memset(word, '\0', WORDSIZE);
memset(dest, '\0', DESTSIZE);
}
#if 1
if ((ret = tree_search(root, argv[2])) == NULL)
printf("the word is wrong\n");
else
printf("%s: %s\n", argv[2], ret);
#endif
return 0;
}
② 为什么c语言创建链表时，要向系统自行申请内存谢谢
不一定需要从堆申请内存的啊，只是从堆分配内存比较自由一些
③ 关于C语言中指针申请内存问题
定义变量是由系统自动申请的，比如定义int i;系统自动申请一个整型变量的内存空间，定义指针只是申请一个指针的空间(一般是2字节),指向的位置需要自己申请，或指向一个已经由系统申请的空间，自己申请的必须自己free掉，系统申请的函数调用完后系统自动释放
④ 谁帮我分析下C语言链表的堆栈内存分配
s=(SLIST *)malloc(sizeof(SLIST)) ;
malloc函数是向系统申请内存的，此函数返回一个内存地址。
如下
s1=(SLIST *)malloc(sizeof(SLIST)) ;
s2=(SLIST *)malloc(sizeof(SLIST)) ;
这两条语句执行时，s1与s2是无关联的。s1,s2的值都为系统所分配内存的地址值。
s=(SLIST *)malloc(sizeof(SLIST)) ;//也就是说，此语句执行一次，系统就为程序分配一段内存并返回地址。再执行再分配。。。
⑤ C语言问题：在什么情况下需要我们手动申请内存
这个感觉手动申请内存的情况主要是在不知道你存储的数据是什么一个数量级时使用的。当然你申请一个很大的数组也可以解决这个问题，不过还浪费大量的内存空间。使用动态申请可以比较灵活的使用分配内存空间，但是不要忘记释放。我个人感觉动态内存在实际应用程序中较常见（因为此时内存使用可以控制的相对合理），但是在搞算法时就很少用动态了（比如ACM竞赛）。
⑥ c语言指针申请空间问题（简单）
这个你只要了解指针的用法你就明白了，指针是指向地址的一个数据类型 比如int b = 2; int *a = &b;那么a就指向b所在的地址。最通俗的就是a是门牌号b是房子，吧a挂在b上你就可以通过a找到b；并且如果不限制你，你也可以进入这个房子修改里面的东西。 回来说你上面的问题，如果换成
char *c；那么c就是个门牌号，如果不用malloc申请空间，就相当于只有门牌号没有房子，你通过c这个门牌号找到的房子不是你的，但是你还欺骗这些字符串说这里有房子，他们相信你了，他们进去了就和原来主人打架，然后就把房子拆了这就出错了。malloc相当于给你自己建房子，你就可以合法居住了。每个门牌号都要有一个属于自己的合法房子所以你说的移到下一个数据域时还要重新申请空间，是因为你的门牌号变了！！！！
⑦ C语言如何申请内存
1.calloc
=
2malloc
+
memset
3与4是连续的，但是他们方式不一样，3你是通过new出来的和malloc一样，它申请的堆中的内存，需要手动释放。而4char
t[10]如果你是在函数里用到就是在栈里申请的，出函数会自动释放，如果是在文件开头的全局变量那就是在静态存储区
就这点区别
⑧ 一道C语言链表问题
#include
#include
#define
NULL
0
#define
LEN
sizeof(struct
student)
struct
student
{
long
num;
/*学号*/
float
score;
/*分数，其他信息可以继续在下面增加字段*/
struct
student
*next;
/*指向下一节点的指针*/
};
int
n;
/*节点总数*/
/*
==========================
功能：创建节点
返回：指向链表表头的指针
==========================
*/
struct
student
*Create()
{
struct
student
*head;
/*头节点*/
struct
student
*p1=NULL;
/*p1保存创建的新节点的地址*/
struct
student
*p2=NULL;
/*p2保存原链表最后一个节点的地址*/
n
=
0;
/*创建前链表的节点总数为0：空链表*/
p1
=
(struct
student
*)malloc(LEN);
/*开辟一个新节点*/
p2
=
p1;
/*如果节点开辟成功，则p2先把它的指针保存下来以备后用*/
if
(p1
==
NULL)
/*节点开辟不成功*/
{
printf("\nCann't
create
it,
try
it
again
in
a
moment!\n");
return
NULL;
}
else
/*节点开辟成功*/
{
head
=
NULL;
/*开始head指向NULL*/
printf("Please
input
%d
node
--
num,score:
",n+1);
scanf("%ld,%f",&(p1->num),&(p1->score));
/*录入数据*/
}
while(p1->num
!=
0)
/*只要学号不为0，就继续录入下一个节点*/
{
n
+=
1;
/*节点总数增加1个*/
if
(n==1)
/*如果节点总数是1，则head指向刚创建的节点p1*/
{
head
=
p1;
/*
注意：
此时的p2就是p1,也就是p1->next指向NULL。
这样写目的是与下面else保持一致。
*/
p2->next
=
NULL;
}
else
{
p2->next
=
p1;
/*指向上次下面刚开辟的节点*/
}
p2
=
p1;
/*把p1的地址给p2保留，然后p1去产生新节点*/
p1
=
(struct
student
*)malloc(LEN);
printf("Please
input
%d
node
--
num,score:
",n+1);
scanf("%ld,%f",&(p1->num),&(p1->score));
}
p2->next
=
NULL;
/*此句就是根据单向链表的最后一个节点要指向NULL*/
free(p1);
/*释放p1。用malloc()、calloc()的变量都要free()*/
p1
=
NULL;
/*特别不要忘记把释放的变量清空置为NULL,否则就变成"野指针"，即地址不确定的指针。*/
return
head;
/*返回创建链表的头指针*/
}
/*
===========================
功能：输出节点
返回：
void
===========================
*/
void
Print(struct
student
*head)
{
struct
student
*p;
printf("\nNow
,
These
%d
records
are:\n",n);
p
=
head;
if(head
!=
NULL)
/*只要不是空链表，就输出链表中所有节点*/
{
printf("head
is
%o\n",
head);
/*输出头指针指向的地址*/
do
{
/*
输出相应的值：当前节点地址、各字段值、当前节点的下一节点地址。
这样输出便于读者形象看到一个单向链表在计算机中的存储结构，和我们
设计的图示是一模一样的。
*/
printf("%o
%ld
%5.1f
%o\n",
p,
p->num,
p->score,
p->next);
p
=
p->next;
/*移到下一个节点*/
}
while
(p
!=
NULL);
}
}
/*
==========================
功能：删除指定节点
(此例中是删除指定学号的节点)
返回：指向链表表头的指针
==========================
*/
/*
单向链表的删除图示：
---->[NULL]
head
图3：空链表
从图3可知，空链表显然不能删除
---->[1]---->[2]...---->[n]---->[NULL]（原链表）
head
1->next
2->next
n->next
---->[2]...---->[n]---->[NULL]（删除后链表）
head
2->next
n->next
图4：有N个节点的链表，删除第一个节点
结合原链表和删除后的链表，就很容易写出相应的代码。操作方法如下：
1、你要明白head就是第1个节点，head->next就是第2个节点；
2、删除后head指向第2个节点，就是让head=head->next,OK这样就行了。
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原链表）
head
1->next
2->next
3->next
n->next
---->[1]---->[3]...---->[n]---->[NULL]（删除后链表）
head
1->next
3->next
n->next
图5：有N个节点的链表，删除中间一个（这里图示删除第2个）
结合原链表和删除后的链表，就很容易写出相应的代码。操作方法如下：
1、你要明白head就是第1个节点，1->next就是第2个节点，2->next就是第3个节点；
2、删除后2，1指向第3个节点，就是让1->next=2->next。
*/
struct
student
*Del(struct
student
*head,
long
num)
{
struct
student
*p1;
/*p1保存当前需要检查的节点的地址*/
struct
student
*p2;
/*p2保存当前检查过的节点的地址*/
if
(head
==
NULL)
/*是空链表（结合图3理解）*/
{
printf("\nList
is
null!\n");
return
head;
}
/*定位要删除的节点*/
p1
=
head;
while
(p1->num
!=
num
&&
p1->next
!=
NULL)
/*p1指向的节点不是所要查找的，并且它不是最后一个节点，就继续往下找*/
{
p2
=
p1;
/*保存当前节点的地址*/
p1
=
p1->next;
/*后移一个节点*/
}
if
(num
==
p1->num)
/*找到了。（结合图4、5理解）*/
{
if
(p1
==
head)
/*如果要删除的节点是第一个节点*/
{
head
=
p1->next;
/*头指针指向第一个节点的后一个节点，也就是第二个节点。这样第一个节点就不在链表中，即删除。*/
}
else
/*如果是其它节点，则让原来指向当前节点的指针，指向它的下一个节点，完成删除*/
{
p2->next
=
p1->next;
}
free(p1);
/*释放当前节点*/
p1
=
NULL;
printf("\ndelete
%ld
success!\n",num);
n
-=
1;
/*节点总数减1个*/
}
else
/*没有找到*/
{
printf("\n%ld
not
been
found!\n",num);
}
return
head;
}
/*
==========================
功能：插入指定节点的后面
(此例中是指定学号的节点)
返回：指向链表表头的指针
==========================
*/
/*
单向链表的插入图示：
---->[NULL]（原链表）
head
---->[1]---->[NULL]（插入后的链表）
head
1->next
图7
空链表插入一个节点
结合原链表和插入后的链表，就很容易写出相应的代码。操作方法如下：
1、你要明白空链表head指向NULL就是head=NULL；
2、插入后head指向第1个节点，就是让head=1,1->next=NULL,OK这样就行了。
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原链表）
head
1->next
2->next
3->next
n->next
---->[1]---->[2]---->[x]---->[3]...---->[n]---->[NULL]（插入后的链表）
head
1->next
2->next
x->next
3->next
n->next
图8：有N个节点的链表，插入一个节点（这里图示插入第2个后面）
结合原链表和插入后的链表，就很容易写出相应的代码。操作方法如下：
1、你要明白原1->next就是节点2，2->next就是节点3；
2、插入后x指向第3个节点,2指向x，就是让x->next=2->next,1->next=x。
*/
struct
student
*Insert(struct
student
*head,
long
num,
struct
student
*node)
{
struct
student
*p1;
/*p1保存当前需要检查的节点的地址*/
if
(head
==
NULL)
/*（结合图示7理解）*/
{
head
=
node;
node->next
=
NULL;
n
+=
1;
return
head;
}
p1
=
head;
while
(p1->num
!=
num
&&
p1->next
!=
NULL)
/*p1指向的节点不是所要查找的，并且它不是最后一个节点，继续往下找*/
{
p1
=
p1->next;
/*后移一个节点*/
}
if
(num
==
p1->num)
/*找到了（结合图示8理解）*/
{
node->next
=
p1->next;
/*显然node的下一节点是原p1的next*/
p1->next
=
node;
/*插入后，原p1的下一节点就是要插入的node*/
n
+=
1;
/*节点总数增加1个*/
}
else
{
printf("\n%ld
not
been
found!\n",num);
}
return
head;
}
/*
==========================
功能：反序节点
(链表的头变成链表的尾，链表的尾变成头)
返回：指向链表表头的指针
==========================
*/
/*
单向链表的反序图示：
---->[1]---->[2]---->[3]...---->[n]---->[NULL]（原链表）
head
1->next
2->next
3->next
n->next
[NULL]next
2->next
3->next
n->next
head
图9：有N个节点的链表反序
结合原链表和插入后的链表，就很容易写出相应的代码。操作方法如下：
1、我们需要一个读原链表的指针p2,存反序链表的p1=NULL（刚好最后一个节点的next为NULL）,还有一个临时存储变量p；
2、p2在原链表中读出一个节点，我们就把它放到p1中，p就是用来处理节点放置顺序的问题；
3、比如，现在我们取得一个2,为了我们继续往下取节点，我们必须保存它的next值，由原链表可知p=2->next;
4、然后由反序后的链表可知，反序后2->next要指向1，则2->next=1;
5、好了，现在已经反序一个节点，接着处理下一个节点就需要保存此时的信息：
p1变成刚刚加入的2，即p1=2;p2要变成它的下一节点，就是上面我们保存的p,即p2=p。
*/
struct
student
*Reverse(struct
student
*head)
{
struct
student
*p;
/*临时存储*/
struct
student
*p1;
/*存储返回结果*/
struct
student
*p2;
/*源结果节点一个一个取*/
p1
=
NULL;
/*开始颠倒时，已颠倒的部分为空*/
p2
=
head;
/*p2指向链表的头节点*/
while
(p2
!=
NULL)
{
p
=
p2->next;
p2->next
=
p1;
p1
=
p2;
p2
=
p;
}
head
=
p1;
return
head;
}
/*
以上函数的测试程序：
提示：根据测试函数的不同注释相应的程序段，这也是一种测试方法。
*/
main()
{
struct
student
*head;
struct
student
*stu;
long
thenumber;
/*
测试Create()、Print()*/
head
=
Create();
Print(head);
/*测试Del():请编译时去掉注释块*/
/*
printf("\nWhich
one
delete:
");
scanf("%ld",&thenumber);
head
=
Del(head,thenumber);
Print(head);
*/
/*测试Insert():请编译时去掉注释块*/
/*
stu
=
(struct
student
*)malloc(LEN);
printf("\nPlease
input
insert
node
--
num,score:
");
scanf("%ld,%f",&stu->num,&stu->score);
printf("\nInsert
behind
num:
");
scanf("%ld",&thenumber);
head
=
Insert(head,thenumber,stu);
free(stu);
stu
=
NULL;
Print(head);
*/
/*测试Reverse():请编译时去掉注释块*/
/*
head
=
Reverse(head);
Print(head);
*/
printf("\n");
system("pause");
}
⑨ C语言关于链表与顺序表的结构问题，静态顺序表与静态链表的区别是什么
静态链表是用数组实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配大小。动态链表是用申请内存函数（C是malloc,C++是new）动态申请内存的，所以在链表的长度上没有限制。动态链表因为是动态申请内存的，所以每个节点的物理地址不连续，要通过指针来顺序访问。静态链表在插入、删除时也是通过修改指针域来实现的，与动态链表没有什么分别（动态链表还需要删除内存）。。不知道我的回答是不是解决了你的问题，希望可以帮到你。 （其实用链表一般都是动态链表或者结构数组）
⑩ c语言如何动态申请内存接收字符串
在C语言中，动态申请内存可以用stdlib.h中声明的malloc函数。
函数原型：
void*malloc(unsignedintnum_bytes);
num_bytes为要申请的内存数量。申请成功，则返回指向这块内存的指针；失败则返回NULL。
申请成功之后，就可以使用gets来接收字符串。代码如下：
#include<stdio.h>
#include<stdlib.h>
intmain()
{
intsize=100;
char*str;
str=malloc(size);
gets(str);
puts(str);
free(str);
return0;
}