C语言节点法找错误,C语言使用free出错

最新推荐文章于 2022-05-12 14:49:14 发布
最新推荐文章于 2022-05-12 14:49:14 发布
阅读量133 收藏
点赞数
文章标签： C语言节点法找错误

C语言使用free报错

在删除线程操作中一使用free就会引起中断，怎么回事，百思不得其解啊？

#include

#include

typedef struct node{

char name[5];//进程的名字

int needTime;//进程所需要的时间

int priority;//优先权

int roundTime;//进程轮流状态一共所需占用时间

int occupiedTime;//已经占用cpu的时间

struct node *next;//下一个进程节点

}PCB;

typedef struct {

PCB *head;

PCB *tail;

}LinkedQueue;

PCB pcbs[10];//创建线程的数组

int count;//线程的个数

LinkedQueue *ready;//就绪队列

void addQueue();

void priorityCreate(n);

/*对队列排序*/

void sort() {

for (int i = 0; i

if (i == 0) {

pcbs[i] = *ready->head;

}

else {

pcbs[i] = *pcbs[i - 1].next;

}

}

for (int i = 0; i 

for (int j = count - 1; j > i; j--) {

if (pcbs[j].priority > pcbs[j - 1].priority) {

PCB temp;

temp = pcbs[j];

pcbs[j] = pcbs[j-1];

pcbs[j - 1] = temp;

}

}

}

addQueue();//对拍好序的数组加入到队列

}

void initReady() {

ready = (LinkedQueue *)malloc(sizeof(LinkedQueue));

ready->head = ready->tail = NULL;

}

/*把线程数组加入到队列中*/

void addQueue() {

ready->head = ready->tail = NULL;

for (int i = 0; i 

if (i == 0) {

ready->head = &pcbs[i];

}

else if(i==count-1) {

ready->tail = &pcbs[count-1];

}

if (i 

pcbs[i].next = &pcbs[i+1];

}

}

}

/*入队操作*/

void insert(PCB *pcb) {

pcb->next = NULL;

ready->tail->next = pcb;

ready->tail = pcb;

}

/*删除线程操作*/

void delete() {

PCB *pb;

pb = ready->head;

ready->head = pb->next;

//free(pb);

count--;

if (ready->head == NULL) {

ready->tail = ready->head;

}

}

//运行

void priorityRun(int n) {

priorityCreate(n);

initReady();

addQueue();

sort();

while (count != 0) {

PCB *pcb = ready->head;//取出队列头部的

pcb->needTime--;

pcb->priority = pcb->priority - 3;

printf("队列%s  进程剩余需要的时间为%d优先级剩余为%d \n", pcb->name, pcb->needTime, pcb->priority);

if (pcb->needTime == 0) {

delete();

}

else {

sort();

}

}

}

/*按照优先权法创建线程*/

void priorityCreate(int n) {

char name[5];

PCB *p;

printf("请输入进程每个进程的名字：\n");

for (int i = 0; i 

gets_s(name,5);

p = (PCB *)malloc(sizeof(PCB));

strcpy(p->name, name);

p->priority = rand() % 10 + 10;

p->needTime = rand() % 5 + 5;

p->next = NULL;

pcbs[i] = *p;

count++;

}

}

int main()

{

priorityRun(5);

return 0;

}

------解决思路----------------------

/*对队列排序*/

void sort() {

//何用？

//for (int i = 0; i

//if (i == 0) {

//pcbs[i] = *ready->head;

//}

//else {

//pcbs[i] = *pcbs[i - 1].next;   //

//}

//}

for (int i = 0; i 

for (int j = count - 1; j > i; j--) {

if (pcbs[j].priority > pcbs[j - 1].priority) {

PCB temp;

temp = pcbs[j];

pcbs[j] = pcbs[j - 1];

pcbs[j - 1] = temp;

}

}

}

addQueue();//对拍好序的数组加入到队列

}

------解决思路----------------------

/*把线程数组加入到队列中*/

void addQueue() {

ready->head = ready->tail = NULL;

for (int i = 0; i 

if (i == 0) {

ready->head = &pcbs[i];

pcbs[0].next = &pcbs[1];   //加一句

}

else if (i == count - 1) {

ready->tail = &pcbs[count - 1];

}

if (i 

pcbs[i].next = &pcbs[i + 1];

}

}

}

------解决思路----------------------

崩溃的时候在弹出的对话框按相应按钮进入调试，按Alt+7键查看Call Stack即“调用堆栈”里面从上到下列出的对应从里层到外层的函数调用历史。双击某一行可将光标定位到此次调用的源代码或汇编指令处，看不懂时双击下一行，直到能看懂为止。

仅供参考：//带表头结点的单向链表

#include 

#include 

#include 

#include 

struct NODE {

int          data;

struct NODE *next;

} H,*head,*p,*q,*s1,*s2,*s3,*s4,*s;

int i,j,k,n,t,m;

int main() {

srand(time(NULL));

//填写头节点数据

H.data=-1;

H.next=NULL;

head=&H;

//创建10个节点的单链表

p=head;

for (i=0;i<10;i++) {

q=(struct NODE *)malloc(sizeof(struct NODE));

if (NULL==q) return 1;

q->data=rand()%100;//填写0..99的随机值

q->next=NULL;

p->next=q;

p=q;

}

//输出整个单链表

s=head->next;

while (1) {

if (NULL==s) {

printf("\n");

break;

}

printf("%02d->",s->data);

s=s->next;

}

//将值为5的结点插入到单链表的第k个结点前

k=3;

n=0;

p=head;

while (1) {

if (NULL==p) {

break;

}

n++;

if (k==n) {

q=(struct NODE *)malloc(sizeof(struct NODE));

if (NULL==q) return 1;

q->data=5;

q->next=p->next;

p->next=q;

break;

}

p=p->next;

}

//输出整个单链表

s=head->next;

while (1) {

if (NULL==s) {

printf("\n");

break;

}

printf("%02d->",s->data);

s=s->next;

}

//删除第k个节点

k=5;

n=0;

p=head;

while (1) {

if (NULL==p) {

break;

}

n++;

if (k==n) {

q=p->next;

if (q) {

p->next=q->next;

free(q);

}

break;

}

p=p->next;

}

//输出整个单链表

s=head->next;

while (1) {

if (NULL==s) {

printf("\n");

break;

}

printf("%02d->",s->data);

s=s->next;

}

//从小到大排序

for (p=head;p!=NULL && p->next!=NULL;p=p->next) {

for (q=p->next;q!=NULL && q->next!=NULL;q=q->next) {

if (p->next->data > q->next->data) {

//交换data

//              printf("swap %02d %02d\n",p->next->data,q->next->data);

//              t=p->next->data;p->next->data=q->next->data;q->next->data=t;

//或者

//交换next

//              printf("swap %02d %02d\n",p->next->data,q->next->data);

s1=p->next;

s2=p->next->next;

s3=q->next;

s4=q->next->next;

if (s2!=s3) {

p->next=s3;

s3->next=s2;

q->next=s1;

s1->next=s4;

} else {

p->next=s3;

s3->next=s1;

q=s3;

s1->next=s4;

}

//输出整个单链表

//              s=head->next;

//              while (1) {

//                  if (NULL==s) {

//                      printf("\n");

//                      break;

//                  }

//                  printf("%02d->",s->data);

//                  s=s->next;

//              }

//              getchar();

}

}

}

//输出整个单链表

s=head->next;

while (1) {

if (NULL==s) {

printf("\n");

break;

}

printf("%02d->",s->data);

s=s->next;

}

//将单链表中前 m 个结点和后 n 个结点进行互换,m+n为链表总长10

m=4;

n=6;

k=0;

p=head;

while (1) {

if (NULL==p) {

break;

}

k++;

if (m+1==k) {

q=p;

}

s=p;

p=p->next;

}

s1=head->next;

head->next=q->next;

s->next=s1;

q->next=NULL;

//输出整个单链表

s=head->next;

while (1) {

if (NULL==s) {

printf("\n");

break;

}

printf("%02d->",s->data);

s=s->next;

}

//释放所有节点

p=head->next;

while (1) {

if (NULL==p) {

break;

}

q=p->next;

free(p);

p=q;

}

return 0;

}

//18->94->58->17->27->20->43->57->75->78->

//18->94->05->58->17->27->20->43->57->75->78->

//18->94->05->58->27->20->43->57->75->78->

//05->18->20->27->43->57->58->75->78->94->

//43->57->58->75->78->94->05->18->20->27->

//

weixin_39963830
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用完链表free的时候出错_数据结构之链表
weixin_31736005的博客
01-05 178
链表(linked list)是一种物理上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。单向链表的每一个节点包含两部分，一部分是存放数据变量data，另一部分是指向下一个节点的next指针单向链表1.private static class Node{ 2. int data; 3. Node next; 4. Node(int data){...
C语言中free()出错
dahlwuyn的专栏
10-16 9072
这是今天碰到的一个例子，使用malloc()申请了一片内存，却在free的时候意外发现释放出错。我百思不得其解，因为同样申请内存的另一个变量释放内存的时候一点问题都没有，而且这两者操作基本相同，申请，使用，再释放。经过调试，发现程序一直没错，直到free的时候，程序直接终止。后来经过查free()的实现原理的时候，我找到了问题所在。free的原理是，申请的内存片段之前存放着相应的信息，这个信息是关
C语言 FREE()函数注意点
专注大规模数据处理
03-27 1万+
C语言中，malloc, alloc, free是c定义的一组内存管理的API函数，free可以释放calloc, malloc, realloc动态分配的空间，当你调用malloc、alloc分配内存时，不仅仅是从堆里面分配得到了可用内存，实际上内存管理子系统还会维护了内存列表（你定义的普通指针不会出现这个列表中）。 而对于使用new, GlobalAlloc之类的方式分配的内存可不可以使用fr
c free时程序失去响应或崩溃
嗜简如命
11-08 3134
今天调个程序，在free时失去响应，代码大致如下 int i = 10;     char* p_buffer = (char*)malloc(4); sprintf(p_buffer,"%04x",i); free(p_buffer); 几番检查后查阅了sprint的手册才发现，sprint自动在末尾添加‘\0’的结束符。导致p_buffer访问越界。 很多str类的填充函数
链表的C语言实现之删除结点.rar_c语言前驱节点
09-23
可以使用头插法或尾插法，这里以头插法为例： ```c Node* createNode(int value) { Node* newNode = (Node*)malloc(sizeof(Node)); if (newNode == NULL) { printf("Memory allocation failed.\n"); exit(0); ...
使用C语言实现简单链表.docx
12-20
在C语言中，可以使用结构体来定义链表节点的结构，例如： ```c struct Node { int data; // 节点数据 struct Node* next; // 指向下一个节点的指针 }; ``` 三、创建链表节点 创建链表节点需要分配内存空间，可以...
c语言链表的基本操作，代码可直接使用
最新发布
12-20
在C语言中，链表操作通常涉及动态内存分配（如`malloc()`和`free()`）和指针操作。理解和熟练掌握这些基本操作是C语言编程的基础，对于理解和实现更复杂的数据结构和算法至关重要。实际编写代码时，要特别注意内存...
使用C语言构建基本的二叉树数据结构
09-03
如果找不到匹配的元素，说明输入序列有问题，程序会输出错误信息并退出。然后，它创建一个新的二叉树节点，并通过递归调用自身来构建左子树和右子树。 总结来说，构建二叉树数据结构在C语言中涉及到定义结构体、...
C语言中free()释放空间时报错
weixin_57023347的博客
06-05 1507
今天再写用链表写一个线性表时，删除节点时free()释放空间时总是报错，报错信息如下： 经过一番查询得知，free()是你申请了多少空间，就释放多少空间，在申请时，已经将你申请空间的大小记录。当时如果你使用与你申请的空间不符，就会报错。(个人理解). 在我的代码中 struct Node{ int data; struct Node* next; }; typedef struct Node * List; List Creatlist(int x){ //List list = (List)m
使用库函数free( )导致异常错误
shizhibuyi1234的博客
05-12 1941
我在使用链表的过程中，需要经常使用free( ) 函数来释放启用的结点，这次由于我写程序的失误，在程序运行到free( )函数这里时，直接进DataFault( )错误中断，后来才发现了问题所在。 首先free( ) 一般是和malloc函数或calloc函数一块使用的，后两个函数表示从堆空间申请一段连续的地址空间，当使用完毕后，使用free( )函数通知处理器释放掉该地址，也即该地址可以重新分配给别的地址了。 我这次的错误是分配空间时给指针分配的空间小了，导致free( )的时候发生了内存泄漏，也就是
free报错问题（转载-未经允许备忘用-链接在正文中）
m0_55952025的博客
11-04 457
malloc后free出错总结： 1、malloc与free配套使用。不要跨进程分配和释放； 2、指向malloc申请的堆内存的指针，在运用过程中千万不要另外赋值，否则同样导致内存泄露（我曾经犯过这样的错误） 3、malloc后，实际使用时指针长度超过了你申请的范围。再去free时肯定出问题。 4、改变指针的初始指向地址。 ———————————————— 版权声明：本文为CSDN博主「__N4c1__」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https
c语言free列表,c语言中链表里free（）问题
weixin_35330796的博客
05-19 1181
#include #includetypedef int ElemType;//元素类型typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;LinkList linkList(){//初始化链表LinkList p;p=(LNode *)malloc(sizeof(LNode));p->next=N...
处理机调度算法！
lanbeibei1987的专栏
06-02 514
#include #include typedef struct{       char name[5];       int need_time;       int privilege;       char state;}NODE; typedef struct node{       NODE data;       struct node *l
c语言使用free释放指针报错,C语言中的free函数用法执行机制分析
weixin_34122532的博客
05-20 3451
free函数是C语言或者C++程序语言的常用函数，那么free函数有什么用途呢？free函数又怎么用呢？C语言中的free函数用法执行机制分析，一起来看看free内部的机制以及和delete的对比分析。与malloc()函数配对使用，释放malloc函数申请的动态内存。另外需要注意的是，对于free(p)这句语句，如果p是NULL指针，那么free对p无论操作多少次都不会出问题。如果p不是NULL...
double free or corruption错误定位
热门推荐
手边笔记
03-17 1万+
“double free or corruption”错误定位 1. 测试程序 先写一个简单的测试程序模拟double free错误： // file: t.c #include <stdlib.h> void *func1(size_t size) { return malloc(size); } void func2(void *p) { free(p); } int main() { char *ptr = func1(sizeof(char));
C语言使用free后无法运行的原因以及解决方法
初家人的博客
04-10 7441
先看代码： #include<stdio.h> #include<malloc.h> #include<string.h> #pragma warning (disable:4996) int main() { char *temp; temp = (char *)malloc(sizeof(char)); printf("temp:"); ...
C语言使用free()函数释放链表节点时程序崩溃
qq_44948414的博客
06-17 2438
在pinta上做题目：链式表操作集，编写程序后在VS2019平台下，程序发生运行崩溃。经过一步步调试发现，程序在运行调试到free()函数这一步时发生了崩溃。
C语言建立动态链表后怎么使用free函数
05-25
在使用C语言建立动态链表时，我们需要使用malloc函数来动态地分配内存空间。当我们需要释放链表节点所占用的内存空间时，就需要使用free函数。 具体来说，当我们需要删除一个链表节点时，我们应该先将该节点从链表中移除，然后再使用free函数释放该节点所占用的内存空间。释放内存的代码如下： ```c // 定义链表节点结构体 struct Node { int data; struct Node* next; }; // 从链表中删除节点并释放内存 void deleteNode(struct Node** head_ref, int key) { // 找到要删除的节点 struct Node* temp = *head_ref, *prev; if (temp != NULL && temp->data == key) { *head_ref = temp->next; free(temp); return; } while (temp != NULL && temp->data != key) { prev = temp; temp = temp->next; } if (temp == NULL) { return; } prev->next = temp->next; free(temp); } ``` 在这个例子中，我们定义了一个名为deleteNode的函数，用于从链表中删除指定的节点。函数接受链表头指针和要删除的节点值作为参数。该函数首先遍历链表找到要删除的节点，然后将其从链表中移除，并使用free函数释放节点所占用的内存空间。 需要注意的是，在使用free函数释放内存时，我们应该确保已经删除了节点并且没有其他指针指向该节点，否则就会导致内存泄漏问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值