循坏链表队列中尾指针与头指针的分别指向哪里

我看人民邮电出版社的数据结构(c语言版)第2版,课本例题里链队的头指针front是指向队头元素,尾指针是指向队尾元素的下一位,但在后面的习题里的循坏链表队列的头指针front是指向队头元素的下一位,而尾指针是指向队尾元素,这是自己想指向哪里就指向哪里吗?有没有什么规定的?例题里是普通链队,习题里是循坏链表队列,跟这个有关吗?

3个回答

其实没有什么规定,只要是循环的,链表都算是循环链表。如果你多找基本书来看,就发现了。

这也是我一直都在强调的,看书千万不要只看一本。否则你没办法知道哪些是特殊,哪些是一般。好比如果你只见过一只熊猫,你不知道它没睡好还是熊猫有黑眼圈。但是如果你见到过10只,这个问题就不言自明了。

sinat_33781723
无脸男小姐 明白,谢谢
大约 4 年之前 回复

链表,与循环链表,还是有一定的区别的。
一般来说,头指针指向第一个可以取到的链表项;尾指针,指向当前项的下一项。

如果是循环队列,就没有明显的头和尾,所以所谓的头/尾指针也只是一个概念。这个没有什么规定,只是方便理解罢了!

Csdn user default icon
上传中...
上传图片
插入图片
抄袭、复制答案,以达到刷声望分或其他目的的行为,在CSDN问答是严格禁止的,一经发现立刻封号。是时候展现真正的技术了!
其他相关推荐
只有一个指针指向队尾元素的循环链表表示的队列怎么求长度
创建一个带头节点的循环链表表示的队列,并且只有一个指针指向队尾元素
关于c++的队列模板链表实现代码
template <class T> class QueueTp { private: struct Node {T item; struct Node * next;}; enum { Q_SIZE = 10 };//默认队列长度 Node * front;//指向队列首个对象的指针 Node * rear;//队列尾部对象的指针 int items;//队列中的对象个数 const int qsize;//队列长度 QueueTp(const QueueTp & q) :qsize(0) { }//伪私有方法 QueueTp & operator=(const QueueTp & q) { return *this; }//伪私有方法 public: QueueTp(int qs = Q_SIZE); ~QueueTp(); bool isempty()const; bool isfull()const; int queuecount()const; bool enqueue(const T & item); bool dequeue(T & item); }; //不能将模板成员函数放在独立的实现文件中 template<class T> QueueTp<T>::QueueTp(int qs) :qsize(qs) { front = rear = NULL; items = 0; } template<class T> QueueTp<T>::~QueueTp() { Node * temp; while (front != NULL) { temp = front; front = front->next;//到这里,front->打出来后显示没有可用成员 怎么回事? delete temp; } } 这几个template后面括号里是写上了的 不知道为什么没显出来
C语言指针内存分配相关问题,求大神指导。。。
这里有两段程序,基本上是一样的。都是使用链表来实现队列。这里实现了出队和入队操作。第一段程序能够正确执行,但是第二段程序不可以,原因是rear和front总是相同的,所以输出的都是-1。我检查了一下,发现每一次rear改变会是的front同时改变。这是为什么?第一段程序通过一个结构体传递rear和front确可以,这是为什么?是通过结构体构建了二级指针吗?求大牛。。。我都快绕晕了,好几次遇到这个问题了。。。 能够正确执行的程序: ``` #include<stdio.h> #include<stdlib.h> typedef struct Node { int data; struct Node *next; }Node; typedef struct Q { Node *front; Node *rear; }Q; void push(Q*q, int e) { Node *node = (Node*)malloc(sizeof(Node)); //分配空间 node->data = e; //数据域 node->next = NULL; //指针域 q->rear->next = node; //添加到末尾 q->rear = node; //更新尾指针 } int pop(Q* q) { if (q->front == q->rear) return -1; Node *t = q->front->next; //获取队首元素 int e = t->data; //获取队首数据域 q->front->next = t->next; //更新队首指针 if (t == q->front) //如果队首与队尾相同,则将队尾指针指向队首 q->rear = q->front; free(t); //释放 return e; //返回队首数据域 } int main() { Q queue; queue.rear = (Node*)malloc(sizeof(Node)); queue.front = queue.rear; push(&queue, 1); push(&queue, 2); push(&queue, 3); int k = pop(&queue); printf("%d\n", k); k = pop(&queue); printf("%d\n", k); k = pop(&queue); printf("%d\n", k); return 0; } ``` 不能够正确执行的: ``` #include<stdio.h> #include<stdlib.h> typedef struct Node { int data; struct Node *next; }Node; void push(Node* rear, int e) { Node *node = (Node*)malloc(sizeof(Node)); //分配空间 node->data = e; //数据域 node->next = NULL; //指针域 rear->next = node; //添加到末尾 rear = node; //更新尾指针 } int pop(Node* rear, Node* front) { if (front == rear) return -1; Node *t = front->next; //获取队首元素 int e = t->data; //获取队首数据域 front->next = t->next; //更新队首指针 if (t == front) //如果队首与队尾相同,则将队尾指针指向队首 rear = front; free(t); //释放 return e; //返回队首数据域 } int main() { Node *rear = (Node*)malloc(sizeof(Node)); Node *front = rear; push(rear, 1); push(rear, 2); push(rear, 3); int k = pop(rear,front); printf("%d\n", k); k = pop(rear, front); printf("%d\n", k); k = pop(rear, front); printf("%d\n", k); return 0; } ```
用fgets或者fscanf从文件输入到链表中的内容错误!!
#include <iostream> #include<fstream> #include<stdlib.h> #include<string.h> #include<stdio.h> typedef struct node{ char question[200]; char option_A[50]; char option_B[50]; char option_C[50]; char option_D[50]; char answer[3]; char respond[3]; char analysis[200]; int length; struct node *next; }LNODE,*LinkList; int main(void) { LNODE *L; L=new LNODE; L->next=NULL; L->length=0; LNODE *p; LNODE *q; q=L; int i; FILE *tk; if((tk=fopen("//Users//apple//Documents//Test System//test question.txt","r"))==NULL) { printf("File open error!\n"); exit(0); } while(!feof(tk)) { fgets(q->question,sizeof(LNODE),tk); fgets(q->option_A,sizeof(LNODE),tk); fgets(q->option_B,sizeof(LNODE),tk); fgets(q->option_C,sizeof(LNODE),tk); fgets(q->option_D,sizeof(LNODE),tk); fgets(q->answer,sizeof(LNODE),tk); fgets(q->analysis,sizeof(LNODE),tk); p=new LNODE; p->next=NULL; q->next=p; q=q->next; } if(fclose(tk)) { printf("Can not close the file!\n"); exit(0); } q=L; while(q->next) { printf("%s",q->question); printf("%s",q->option_A); printf("%s",q->option_B); printf("%s",q->option_C); printf("%s",q->option_D); printf("%s",q->answer); printf("%s",q->analysis); q=q->next; } } ```下面是文档的内容,图片是输出后的内容,第一题的题目变成了略,是为什么?已经崩溃了!求大神救救小白! 在数据结构中,从逻辑结构上可以把数据结构分成() A.动态结构和静态结构 B.紧凑结构和非紧凑结构 C.线性结构和非线性结构 D.内部结构和外部结构 C 略 与数据元素本身的形式,内容,相对位置,个数无关的是数据的() A.存储结构 B.存储实现 C.逻辑结构 D.运算实现 C 略 通常要求同一逻辑结构中的所有数据元素具有相同的特性,这意味着() A.数据具有同一特点 B.每个数据元素都一样 C.不仅每个数据元素所包含的数据项都一样,而且对应数据项的类型要一致 D.数据元素所包含的数据项的个数要相等 C 只有这样系统才能高效统一的对数据进行管理。 算法的时间复杂度取决于() A.问题的规模 B.待处理的数据的初态 C.计算机的配置 D.A和B D 略 顺序表中第一个元素的储存地址是100,每个元素的长度为2,则第5个元素的地址是() A.100 B.108 C.100 D.120 B 100+(5-1)*2==108 线性表若采用链式存储结构,要求内存中可用存储单元的地址() A.部分是连续的 B.一定是不连续的 C.必须是连续的 D.连续或不连续都可以 D 因为链表有指针跟踪从而连不连续都可以。 用链接方式存储的队列,在进行删除运算时() A.仅修改头指针 B.仅修改尾指针 C.头尾指针都一定要修改 D.头尾指针可能都要修改 D 一般只修改头指针,但是删除的结点若为最后一个时,则要重新对尾指针赋值。 一个递归算法必须包括() A.递归部分 B.终止条件和递归部分 C.迭代部分 D.终止条件和迭代部分 D 略 串是一种特殊的线性表,其特殊性体现在() A.可以顺序储存 B.可以链式储存 C.数据元素是单个字符 D.数据元素可以是多个字符 C 串是一种内容受限的线性表。 把一棵树转化为二叉树后,这棵二叉树的形态是() A.唯一的 B.有多种 C.有多种,但根结点都没有左孩子 D.有多种,但根结点都没有右孩子 A 略。 利用二叉链表存储树,则根结点的右指针() A.指向最左孩子 B.指向最右孩子 C.非空 D.为空 C 右指针指向兄弟结点。 在以下的存储形式中,不是树的存储形式的是() A.双亲表示法 B.孩子链表表示法 C.孩子兄弟表示法 D.顺序存储表示法 D 常用孩子兄弟表示法转化为二叉树进行储存。 在一个无向图,所有顶点的度数之和等于图的边数的()倍 A.1/2 B.1 C.2 D.4 A 略 折半查找与二叉排序树的时间性能() A.相同 B.完全不同 C.有时不相同 D.数量级都是O(log2n) C 要看初始数据的状态。 堆的形状是一棵() A.二叉排序树 B.满二叉树 C.完全二叉树 D.平衡二叉树 C 略 若一组记录的排序码为(46,79,56,38,40,84),则利用堆排序的方式建立的初始堆为() A.79,46,56,38,40,84 B.84,79,56,38,40,46 C.84,79,56,46,40,38 D.84,56,79,40,46,38 C 画出图去找矛盾。 快速排序在下列()最易发挥作用 A.被排序的数据中具有多个相同的排序码 B.被排序的数据已经基本有序 C.被排序的数据完全无序 D.被排序的数据中的最大值和最小值相差悬殊 C 完全无序时用快速排序。 ```[图片说明](https://img-ask.csdn.net/upload/201812/31/1546186739_926263.jpeg) [图片说明](https://img-ask.csdn.net/upload/201812/31/1546186723_760510.jpeg)
用fscanf和fgets从文件读取数据存储到链表失败是为什么??
我建立了链表结构,然后从文件导入数据,然后输出链表内容,发现输出的内容顺序不对内容也有点地方出错了! (下面是代码) #include <iostream> #include<fstream> #include<stdlib.h> #include<string.h> #include<stdio.h> typedef struct node{ char question[200]; char option_A[50]; char option_B[50]; char option_C[50]; char option_D[50]; char answer[3]; char respond[3]; char analysis[200]; int length; struct node *next; }LNODE,*LinkList; int main(void) { LNODE *L; L=new LNODE; L->next=NULL; L->length=0; LNODE *p; LNODE *q; q=L; int i; FILE *tk; if((tk=fopen("//Users//apple//Documents//Test System//test question.txt","r"))==NULL) { printf("File open error!\n"); exit(0); } while(!feof(tk)) { fgets(q->question,sizeof(LNODE),tk); fgets(q->option_A,sizeof(LNODE),tk); fgets(q->option_B,sizeof(LNODE),tk); fgets(q->option_C,sizeof(LNODE),tk); fgets(q->option_D,sizeof(LNODE),tk); fgets(q->answer,sizeof(LNODE),tk); fgets(q->analysis,sizeof(LNODE),tk); p=new LNODE; p->next=NULL; q->next=p; q=q->next; } if(fclose(tk)) { printf("Can not close the file!\n"); exit(0); } q=L; while(q->next) { printf("%s",q->question); printf("%s",q->option_A); printf("%s",q->option_B); printf("%s",q->option_C); printf("%s",q->option_D); printf("%s",q->answer); printf("%s",q->analysis); q=q->next; } } (这是文档里的内容) 在数据结构中,从逻辑结构上可以把数据结构分成() A.动态结构和静态结构 B.紧凑结构和非紧凑结构 C.线性结构和非线性结构 D.内部结构和外部结构 C 略 与数据元素本身的形式,内容,相对位置,个数无关的是数据的() A.存储结构 B.存储实现 C.逻辑结构 D.运算实现 C 略 通常要求同一逻辑结构中的所有数据元素具有相同的特性,这意味着() A.数据具有同一特点 B.每个数据元素都一样 C.不仅每个数据元素所包含的数据项都一样,而且对应数据项的类型要一致 D.数据元素所包含的数据项的个数要相等 C 只有这样系统才能高效统一的对数据进行管理。 算法的时间复杂度取决于() A.问题的规模 B.待处理的数据的初态 C.计算机的配置 D.A和B D 略 顺序表中第一个元素的储存地址是100,每个元素的长度为2,则第5个元素的地址是() A.100 B.108 C.100 D.120 B 100+(5-1)*2==108 线性表若采用链式存储结构,要求内存中可用存储单元的地址() A.部分是连续的 B.一定是不连续的 C.必须是连续的 D.连续或不连续都可以 D 因为链表有指针跟踪从而连不连续都可以。 用链接方式存储的队列,在进行删除运算时() A.仅修改头指针 B.仅修改尾指针 C.头尾指针都一定要修改 D.头尾指针可能都要修改 D 一般只修改头指针,但是删除的结点若为最后一个时,则要重新对尾指针赋值。 一个递归算法必须包括() A.递归部分 B.终止条件和递归部分 C.迭代部分 D.终止条件和迭代部分 D 略 串是一种特殊的线性表,其特殊性体现在() A.可以顺序储存 B.可以链式储存 C.数据元素是单个字符 D.数据元素可以是多个字符 C 串是一种内容受限的线性表。 把一棵树转化为二叉树后,这棵二叉树的形态是() A.唯一的 B.有多种 C.有多种,但根结点都没有左孩子 D.有多种,但根结点都没有右孩子 A 略。 利用二叉链表存储树,则根结点的右指针() A.指向最左孩子 B.指向最右孩子 C.非空 D.为空 C 右指针指向兄弟结点。 在以下的存储形式中,不是树的存储形式的是() A.双亲表示法 B.孩子链表表示法 C.孩子兄弟表示法 D.顺序存储表示法 D 常用孩子兄弟表示法转化为二叉树进行储存。 在一个无向图,所有顶点的度数之和等于图的边数的()倍 A.1/2 B.1 C.2 D.4 A 略 折半查找与二叉排序树的时间性能() A.相同 B.完全不同 C.有时不相同 D.数量级都是O(log2n) C 要看初始数据的状态。 堆的形状是一棵() A.二叉排序树 B.满二叉树 C.完全二叉树 D.平衡二叉树 C 略 若一组记录的排序码为(46,79,56,38,40,84),则利用堆排序的方式建立的初始堆为() A.79,46,56,38,40,84 B.84,79,56,38,40,46 C.84,79,56,46,40,38 D.84,56,79,40,46,38 C 画出图去找矛盾。 快速排序在下列()最易发挥作用 A.被排序的数据中具有多个相同的排序码 B.被排序的数据已经基本有序 C.被排序的数据完全无序 D.被排序的数据中的最大值和最小值相差悬殊 C 完全无序时用快速排序。 (这是输出后的内容,第一行与原文档的根本不同,而且后面也有很多乱的错误的) ![图片说明](https://img-ask.csdn.net/upload/201812/31/1546187214_133620.jpeg) 有哪位大神指导一下小白!!
求问数据结构基础循环队列问题,完善修改一下代码
编程建立循环队列存储结构,对排队买票过程进行模拟,要求程序在控制台屏幕上显示菜单:1.排队—输入新到达的买票人姓名,加入买票队列中。 2.售票—排队队列中最前面的人买票成功,显示信息并将其从队列中删除。3.—查看队列—从队首到队尾依次列出所有排队人姓名;4.—结束退出系统。 “排队”时,若队满,提示等待。 售票时,若队空,提示无人排队(售票失败) ```#include<iostream>   #include <string> using namespace std; typedef string QElemType; typedef int Status; //--------------(队列的顺序存储结构)-------------   typedef struct QUEUE { QElemType *base;//初始化的动态分配存储空间   int front;//头指针   int rear;//尾指针   }SqQueue; Status InitQueue(SqQueue &Q) { Q.base = (QElemType*)malloc(10*sizeof(QElemType));//初始化队列   if (!Q.base) { exit(0); } Q.rear = Q.front = 0; return 1; } Status QueueEmpty(SqQueue Q)//判断队空 { if (Q.front == Q.rear) { return 1; }else { return 0; } } Status EnQueue(SqQueue &Q, QElemType e)//排队 { if ((Q.rear+1) % 10==Q.front)//如果队满   { return 0; } Q.base[Q.rear] = e; Q.rear = (Q.rear+1) %10; return 1; } Status Dequeue(SqQueue Q, QElemType &e)//售票 { if (Q.front == Q.rear)//队空    { return 0; } e = Q.base[Q.front]; Q.front = (Q.front + 1) %100; return 1; } Status QueueTraverse(SqQueue Q, QElemType e)//查看队列 { int i; i = Q.front; while (i!= Q.rear) { cout << Q.base[i]; i = (i + 1) %10; } cout << endl; return 1; } int main() { cout << "排队:1 售票:2 查看队列:3 结束:4" << endl; Status InitQueue(); int a; loop:cin >> a; if (a == 1) { int b; string e; cin>>e; Status EnQueue(SqQueue &Q, QElemType e); b = EnQueue; if (0); cout<< "waiting" <<endl; goto loop; } if(a==2) { char e; Status Dequeue(SqQueue Q, QElemType &e); if (Dequeue==0); cout << "no man waiting!" << endl; if (Dequeue==1); cout << e << "购票成功" << endl; goto loop; } if (a == 3) { Status QueueTraverse(); goto loop; } if (a == 4); return 0; } ```不懂返回值。。
代码没有错误,为什么程序没运行完就直接结束了?
![图片说明](https://img-ask.csdn.net/upload/201908/08/1565246195_162168.png) ![图片说明](https://img-ask.csdn.net/upload/201908/08/1565246218_224284.png) ``` //主要功能:实现带小数二进制和十进制之间数据的转换 #include <iostream.h> #include <windows.h> #include <fstream.h> #include <string> #include <math.h> using namespace std; const int TAILMAXLENTH=10;//定义十进制转换成二进制小数部分最大位数 const int DABAMAXLENTH=40;//定义原始数据的最大长度 const double ADDMENBERNUM=111.11;//定义一个加数用于检测数据真实可用 /********************************************************************************************************* *栈的部分 *********************************************************************************************************/ class Stack;//类Stack的声明 /* 定义一个链栈结点类Stacknode */ class Stacknode { friend class Stack;//申请友元类 private: Stacknode(Stacknode *nextp=NULL);//构造函数 Stacknode(int &newdata,Stacknode *nextp=NULL);//构造函数 int data;//数据元素 Stacknode *next;//递归定义指向后继结点的指针 }; /* Stacknode的实现部分 */ Stacknode::Stacknode(Stacknode *nextp)//构造函数 { next=nextp; } Stacknode::Stacknode(int &newdata,Stacknode *nextp)//构造函数 { data=newdata; next=nextp; } //结点类Stacknode的定义结束 /* 定义一个链栈类Stack */ class Stack { public: Stack();//创建一个空栈 ~Stack();//回收一个栈 void clear();//销毁一个栈 bool empty() const;//确定栈是否已空 bool push(int &item);//把数据压进栈 bool pop();//出栈 bool top(int &item) const;//取出栈顶元素 private: Stacknode *newnode(Stacknode *nextp=NULL); Stacknode *newnode(int &item,Stacknode *nextp=NULL);//创建新的结点 Stacknode *Stacktop; int Stacklength; }; /* Stack的实现部分 */ Stacknode *Stack::newnode(Stacknode *nextp)//创建新的结点,不带数据 { return new Stacknode(nextp); } Stacknode *Stack::newnode(int &item,Stacknode *nextp)//创建新的结点,数据域赋值 { return new Stacknode(item,nextp); } //以下为栈类Stack的函数定义 Stack::Stack()//创建一个空栈 { Stacktop=newnode();//创建一个栈顶指针初始化,相当于Stacktop=NULL;本链表没有用头结点 Stacklength=0; } Stack::~Stack()//回收一个栈 { clear(); delete Stacktop;//释放栈底 } void Stack::clear()//销毁一个栈 { //while(pop());//不停地出栈,而每次释放空间在出栈函数中完成 Stacknode *usednodep;//定义指针usednodep,准备指向出栈的结点 while(Stacktop->next!=NULL) { usednodep=Stacktop;//指向出栈的结点 Stacktop=Stacktop->next;//栈顶指针后移 delete usednodep;//释放空间 } } bool Stack::empty() const//确定栈是否已空 { return Stacklength<=0?true:false; } bool Stack::push(int &item)//数据进栈 { Stacknode *newnodep;//定义指针newnodep,准备指向申请的新结点 newnodep=newnode(item,Stacktop);//申请新结点,把数据存入,把指针域指向头指针 if(!newnodep)//如果没有申请到空间,返回失败 return false; Stacktop=newnodep;//改链,完成进栈 Stacklength++;//栈的长度增加 return true;//本次操作成功 } bool Stack::pop()//出栈,不要栈顶数据 { Stacknode *usednodep;//定义指针usednodep,准备指向出栈的结点 if(!empty())//判断是否栈空 { usednodep=Stacktop;//指向出栈的结点 Stacktop=Stacktop->next;//栈顶指针后移 // delete usednodep;//释放空间 Stacklength--;//栈的长度减少 return true;//本次操作成功 } return false;//否则本次操作失败 } bool Stack::top(int &item) const//取出栈顶数据返回去 { if(!empty())//如果栈不空,记录当前栈顶元素 { item=Stacktop->data;//通过item返回去 return true;//本次操作成功 } return false;//否则本次操作失败 } /********************************************************************************************************* *队列的部分 *********************************************************************************************************/ /* 定义一个结点类node */ class node { public: int data; node *next; }; /* 定义一个链队类Queue */ class Queue { private: node *rear; node *front; protected: int count;//计数器,统计结点个数即线性队列的长度 public: Queue();//构造函数 ~Queue();//析构函数 void clear(void);//清空链队 bool empty(void) const;//判断是否空队 bool retrieve(int &item) const;//读取队头 bool append(const int &item);//数据入队 bool serve();//数据出队 }; /* 类Queue的实现部分 */ Queue::Queue()//构造函数 { front=new node;//申请新结点,作为队头结点 front->next=NULL; rear=front;//队尾指针指向队头 count=0;//计数器清零,队列开始时没有实际数据 } Queue::~Queue()//析构函数 { clear();//删除所有数据,释放所有结点 delete front;//把头结点也释放掉 count=0;//计数器清零,队列开始时没有实际数据 } void Queue::clear(void)//清空链队 { node *searchp=front->next,*followp=front;//初始化两个指针 while(searchp!=rear) { followp=searchp; searchp=searchp->next; delete followp; } front->next=NULL;//保留了最后一个结点,就是头结点,并且链域置为空 rear=front; count=0;//计数器也清零 } bool Queue::empty(void) const//判断是否空链 { return count==0?true:false; } bool Queue::retrieve(int &item) const//读取队头 { if(empty())//处理意外 return false; item=front->next->data;//返回读取的数据 return true;//本次操作成功 } bool Queue::append(const int &item)//进队 { node *newnodep=new node; newnodep->data=item;//给数据赋值 rear->next=newnodep;//这一步可以看出有头结点 rear=rear->next;//改动队尾指针的位置 count++;//计数器加1 return true; } bool Queue::serve()//出队 { if(empty())//空队处理 return false; node *tempp=front->next; // item=tempp->data;//保存数据 front->next=tempp->next;//改变指针 delete tempp;//释放该结点 count--;//计数器减1 return true; } /********************************************************************************************************* *定义一个功能类NumSysConversion *********************************************************************************************************/ class NumSysConversion { private: int inter; float floater; Stack *stack; Queue *queue; public: NumSysConversion();//构造函数 ~NumSysConversion();//析构函数 bool check(char *array,int number);//检查输入数据是否符合要求 void change(char *array,int number);//将原始数据转化成数值 double change_to_aim(int tokind);//将原始数据转化成目标进制的数据 }; NumSysConversion::NumSysConversion()//构造函数 { stack=new Stack; queue=new Queue; inter=0; floater=0; } NumSysConversion::~NumSysConversion()//析构函数 { delete stack; delete queue; } bool NumSysConversion::check(char *array,int number)//检查输入数据是否符合要求 { bool flag=true; for(int i=0;array[i]!='\0';i++) { cout<<array[i]; if(array[i]-48>=number) { flag=false; break; } } return flag; } void NumSysConversion::change(char *array,int number)//将原始数据转化成数值 { int flag=0,j=0; for(int i=0;array[i]!='\0';i++) { if(array[i]=='.') { flag=1; continue; } if(flag==0)//取整数数据 inter=inter*number+array[i]-48; if(flag==1)//取小数数据 floater+=(float)(((int)array[i]-48)*(float)pow(number,--j)); } } double NumSysConversion::change_to_aim(int tokind)//将原始数据转化成目标进制的数据 { int count=0,temp,flag=0,num; double resnumb=0; //第一步:先将整数部分转换进制后的数据依次入栈 while(inter) { num=inter%tokind; stack->push(num); inter/=tokind; } //第二步:再将小数部分转换进制后的数据依次入队 while(floater&&count<TAILMAXLENTH) { queue->append(int(floater*tokind)); floater*=tokind; if(floater>=1) floater-=(int)floater; count++; } //第三步:显示栈和队中的数据并将其转换成可用数据 cout<<"数据转换后为:"; while(!stack->empty()) { stack->top(temp); stack->pop(); cout<<temp; resnumb=resnumb*tokind+temp; flag=1; } if(!queue->empty()) { if(flag==0) cout<<"0"; cout<<"."; count=-1; } while(!queue->empty()) { queue->retrieve(temp); queue->serve(); cout<<temp; resnumb+=temp*pow(tokind,count--); } cout<<endl; //第四步:清空栈和队中的数据 stack->clear(); queue->clear(); inter=0; floater=0; //第五步:将可用数据信息返回 return resnumb; } /* 定义一个实现进制转换功能的菜单处理类interfacebase */ class interfacebase { private: NumSysConversion NumSysConversiononface; public: void clearscreen(void);//清屏 void showmenu(void);//显示菜单函数 int userchoice(void);//用户的选项 void processmenu(int menuchoice);//菜单函数 }; /* 类interfacebase的实现部分 */ void interfacebase::clearscreen(void) { system("cls"); } void interfacebase::showmenu(void) { cout<<"进制转换功能菜单"<<endl; cout<<"================"<<endl; cout<<"1.十进制转换为二进制"<<endl; cout<<"2.二进制转换为十进制"<<endl; cout<<"0.结束程序"<<endl; cout<<"================"<<endl; } int interfacebase::userchoice(void) { int menuchoice; cout<<"请输入您的选择:"; cin>>menuchoice; return menuchoice; } void interfacebase::processmenu(int menuchoice) { switch(menuchoice)//根据用户的选择进行相应的操作 { case 1: { char array[10]={'0','.','1','2','5'}; int number=10; if(NumSysConversiononface.check(array,number)) cout<<"符合要求!"<<endl; else cout<<"不符合要求!"<<endl; NumSysConversiononface.change(array,number); cout<<NumSysConversiononface.change_to_aim(2)<<endl; cout<<"进制转换成功!"<<endl; } break; case 2: { char array[10]={'1','1','1','1'}; int number=2; if(NumSysConversiononface.check(array,number)) cout<<"符合要求!"<<endl; else cout<<"不符合要求!"<<endl; NumSysConversiononface.change(array,number); cout<<NumSysConversiononface.change_to_aim(10)<<endl; cout<<"进制转换成功!"<<endl; } break; case 0: exit(0); default: cout<<"对不起,您输入的功能编号有错!请重新输入!!!"<<endl; break; } } /* 程序主入口 */ void main(void) { int menuchoice;//定义变量,菜单选单项的选择 interfacebase interfacenow; system("color f0");//修改屏幕的背景色和字的颜色 interfacenow.clearscreen();//清屏 while(1)//永真循环 { interfacenow.showmenu();//显示菜单 menuchoice=interfacenow.userchoice();//获取用户的选择 interfacenow.processmenu(menuchoice);//处理用户的选择 system("pause");//暂停 interfacenow.clearscreen();//清屏 } }//主函数结束 ```
数据结构基础问题 这个链队列为什么不能入队和出队?
程序可以运行,界面如下;反复检查代码似乎都没有问题,为什么出不了结果呢。。恳求大神指教!! [图片说明](https://img-ask.csdn.net/upload/201610/12/1476275788_812251.png) //链队列 #include "stdAfx.h" #include <iostream> using namespace std; typedef int ElemType; extern void Error( char * s ); enum Status{ ERROR, OVERFLOW1, OK }; //链队列的类型定义 typedef struct QNode /* 结点结构 */ { ElemType data; struct QNode *next; } QNode,*QueuePtr; typedef struct /* 队列的链表结构 */ { QueuePtr front,rear; /* 队头、队尾指针 */ } LinkQueue; ////////////////////////////////算法实现////////////////////////////////// //1.初始化队列 Status InitQueue_L( LinkQueue &Q ) { if( Q.front != NULL) return OVERFLOW1; Q.front = Q.rear ; Q.front->next = NULL; return OK; } //2. 销毁队列 Status DestroyQueue_L( LinkQueue &Q ) { if(Q.front==Q.rear) return ERROR; delete Q.front ; Q.front =Q.rear =NULL; return OK; } //3. 入队:把x插入队尾 Status EnQueue_L( LinkQueue &Q , ElemType x ) { QNode*p = new QNode; if(p!=NULL) return OVERFLOW1; p->data = x; p->next =NULL; Q.rear->next = p; Q.rear = p; return OK; } //4. 从出队: 如果队空,返回false;否则返回队头元素到x Status DeQueue_L( LinkQueue &Q , ElemType &x ) { QNode*p = new QNode; if(Q.front==Q.rear) return ERROR; p=Q.front->next; Q.front->next=p->next; if(Q.front->next==NULL) { Q.rear=Q.front; } x = p->data; delete p; return OK; } int main(int argc, char* argv[]) { //测试链队列 LinkQueue queue; cout<<"测试链队列"<<endl; InitQueue_L( queue );//初始化队列 for ( int i = 0 ; i < 100 ; i ++ ) { EnQueue_L( queue , i );//入入队的顺序为0,1,2,3,...,99(自行添加出错处理) } cout<<"队列的测试"<<endl; while ( DeQueue_L( queue , i ) == OK )//出队,输出出队的元素 { cout<< i <<" "; } cout<<endl; DestroyQueue_L( queue );//销毁队列 cout<<"退出main函数"<<endl; system("pause"); return 0; }
数据结构C++实现二叉树的基本操作,创建二叉树时总是显示“无法读取内存”
0x7763B48B (ntdll.dll) (二叉排序树基本操作.exe 中)处有未经处理的异常: 0xC0000005: 写入位置 0x004C0FFC 时发生访问冲突。 求大神解答!!! ![图片说明](https://img-ask.csdn.net/upload/201611/11/1478870210_16721.png) 存储结构 ``` template<class ElemType> struct Btnode { ElemType Data; Btnode<ElemType> *Lchild, *Rchild; }; ``` 创建二叉树 ``` //按以先序次序输入节点值的方式建立二叉树 template<class ElemType> void BinaryTree<ElemType>::_Create1(Btnode<ElemType> * &T, ElemType ch[], const ElemType &c, int &i) { if (ch[i] == c) //c为特殊数据,如#、¥,用以标示空指针 { T = NULL; } else { T = new Btnode<ElemType>; //T = (Btnode<ElemType> *)malloc(sizeof(Btnode<ElemType>)); T->Data = ch[i]; _Create1(T->Lchild, ch, c, ++i); _Create1(T->Rchild, ch, c, ++i); } } ``` 全部代码: .h ``` #ifndef _BINARYTREE_H #define _BINARYTREE_H #include <stack> #include <queue> using namespace std; template<class ElemType> struct Btnode { ElemType Data; Btnode<ElemType> *Lchild, *Rchild; }; //二叉链表类 template<class ElemType> class BinaryTree { public: //构造函数 BinaryTree() : m_root(NULL){} //拷贝函数 BinaryTree(const BinaryTree &rhs) { m_root = _Copy(rhs.m_root); } //赋值重载 BinaryTree& operator=(const BinaryTree &rhs) { if (&rhs == this) { return *this; } _Destroy(m_root); m_root = _Copy(rhs.m_root); return *this; } //析构函数 ~BinaryTree() { _Destroy(m_root); } //按以先序次序输入节点值的方式建立二叉树的接口函数 void Create1(ElemType ch[], const ElemType &c); //以二叉树的先序和中序次序建立二叉树的接口函数 void Create2(ElemType ch1[], ElemType ch2[], int); //置空二叉树 void Clear() { _Destroy(m_root); } //判断二叉树是否为空 bool IsEmpty() const{ return m_root == NULL; } //返回根节点的指针 Btnode<ElemType>* Root() const{ return m_root ; } //返回二叉树T中元素为e的节点的指针 Btnode<ElemType>* Locate(ElemType &e) { return _Locate(m_root, e); } //求二叉树深度 int Depth() { return _Depth(m_root); } //返回节点的双亲节点 Btnode<ElemType>* Parent(Btnode<ElemType> *p) { return _Parent(m_root, p); } //返回节点的左孩子 Btnode<ElemType>* LeftChild(Btnode<ElemType> *p) { return p->Lchild; } //返回节点的右孩子 Btnode<ElemType>* RightChild(Btnode<ElemType> *p) { return p->Rchild; } //返回节点的左兄弟节点 Btnode<ElemType>* LeftSibling(Btnode<ElemType> *p); //返回节点的右兄弟节点 Btnode<ElemType>* RightSibling(Btnode<ElemType> *p); //先序递归遍历二叉树的接口函数 void PreorderTraverse(void(*visit)(const ElemType &)); //先序非递归遍历二叉树的接口函数 void PreorderTraverseNoRecursive(void(*visit)(const ElemType &)); //中序递归遍历二叉树的接口函数 void InordTraverse(void(*visit)(const ElemType &)); //后序递归遍历二叉树的接口函数 void PostorderTraverse(void(*visit)(const ElemType &)); //层序遍历二叉树 void LevelTraverse(void(*visit)(const ElemType &e)); private: Btnode<ElemType> *m_root; //二叉树根节点指针 //复制二叉树 Btnode<ElemType> *_Copy(Btnode<ElemType> *); //按以先序次序输入节点值的方式建立二叉树 void _Create1(Btnode<ElemType> * &, ElemType ch[], const ElemType &, int &); //销毁二叉树 void _Destroy(Btnode<ElemType> * &); //求二叉树的深度 int _Depth(Btnode<ElemType> *); //返回二叉树中元素值为e的节点的指针 Btnode<ElemType> * _Locate(Btnode<ElemType>*, const ElemType &); //返回e节点的双亲节点指针 Btnode<ElemType> * _Parent(Btnode<ElemType>*, Btnode<ElemType>*); //先序递归遍历二叉树 void _PreorderTraverse(Btnode<ElemType>*T, void(*visit)(const ElemType &e)); //中序递归遍历二叉树 void _InorderTraverse(Btnode<ElemType>*T, void(*visit)(const ElemType &e)); //后序递归遍历二叉树 void _PostorderTraverse(Btnode<ElemType>*T, void(*visit)(const ElemType &e)); }; #endif ``` .cpp ``` // #include "BinaryTree.h" #include <iostream> #include <stack> #include <queue> #include "BinaryTree.h" using namespace std; //先序递归遍历二叉树 template<class ElemType> void BinaryTree<ElemType>::_PreorderTraverse(Btnode<ElemType>*T, void(*visit) (const ElemType &e)) { if (T) { visit(T->Data); _PreorderTraverse(T->Lchild, visit); _PreorderTraverse(T->Rchild, visit); } } //先序递归遍历二叉树的接口函数 template<class ElemType> void BinaryTree<ElemType>::PreorderTraverse(void(*visit)(const ElemType &)) { _PreorderTraverse(m_root, visit); } //中序递归遍历二叉树 template<class ElemType> void BinaryTree<ElemType>::_InorderTraverse(Btnode<ElemType>*T, void(*visit) (const ElemType &e)) { if (T) { _InorderTraverse(T->Lchild, visit); visit(T->Data); _InorderTraverse(T->Rchild, visit); } } //中序递归遍历二叉树的接口函数 template<class ElemType> void BinaryTree<ElemType>::InordTraverse(void(*visit)(const ElemType &)) { _InorderTraverse(m_root, visit); } //后序递归遍历二叉树 template<class ElemType> void BinaryTree<ElemType>::_PostorderTraverse(Btnode<ElemType>*T, void(*visit) (const ElemType &e)) { if (T) { _PostorderTraverse(T->Lchild, visit); _PostorderTraverse(T->Rchild, visit); visit(T->Data); } } //后序递归遍历二叉树的接口函数 template<class ElemType> void BinaryTree<ElemType>::PostorderTraverse(void(*visit)(const ElemType &)) { _PostorderTraverse(m_root, visit); } //按以先序次序输入节点值的方式建立二叉树 template<class ElemType> void BinaryTree<ElemType>::_Create1(Btnode<ElemType> * &T, ElemType ch[], const ElemType &c, int &i) { if (ch[i] == c) //c为特殊数据,如#、¥,用以标示空指针 { T = NULL; } else { T = new Btnode<ElemType>; //T = (Btnode<ElemType> *)malloc(sizeof(Btnode<ElemType>)); T->Data = ch[i]; _Create1(T->Lchild, ch, c, ++i); _Create1(T->Rchild, ch, c, ++i); } } //按以先序次序输入节点值的方式建立二叉树的接口函数 template<class ElemType> void BinaryTree<ElemType>::Create1(ElemType ch[], const ElemType &c) { int i = 0; _Create1(m_root, ch, c, i); } //销毁二叉树 template<class ElemType> void BinaryTree<ElemType>::_Destroy(Btnode<ElemType> * &T) { if (T) { _Destroy(T->Lchild); _Destroy(T->Rchild); delete T; } T = NULL; } //求二叉树的深度 template<class ElemType> int BinaryTree<ElemType>::_Depth(Btnode<ElemType> *T) { if (!T) { return 0; } int h1, h2; h1 = _Depth(T->Lchild); h2 = _Depth(T->Rchild); return h1 > h2 ? h1 + 1 : h2 + 1; } //层序遍历二叉树--利用队列 template<class ElemType> void BinaryTree<ElemType>::LevelTraverse(void(*visit)(const ElemType &e)) { queue<Btnode<ElemType>*> Q; if (m_root) { Q.push(m_root); //根指针进队 } while (!Q.empty()) { Btnode < ElemType> *p; p = Q.front(); //取队头指针 Q.pop(); //出队 visit(p->Data); //访问队头指针所指元素 if (p->Lchild) { Q.push(p->Lchild);//非空的左孩子的指针进队 } if (p->Rchild) { Q.push(p->Rchild);//非空的左孩子的指针进队 } } } // 返回节点的左兄弟节点 template<class ElemType> Btnode<ElemType>* BinaryTree<ElemType>::LeftSibling(Btnode<ElemType> *p) { Btnode<ElemType> * father; father = Parent(p); if (father && father->Rchild == p) { return father->Lchild; } return NULL; } //返回节点的右兄弟节点 template<class ElemType> Btnode<ElemType>* BinaryTree<ElemType>::RightSibling(Btnode<ElemType> *p) { Btnode<ElemType> * father; father = Parent(p); if (father && father->Lchild == p) { return father->Rchild; } return NULL; } //复制一颗子二叉树 template<class ElemType> Btnode<ElemType>* BinaryTree<ElemType>::_Copy(Btnode<ElemType> *T) { if (T==NULL) { return NULL; } Btnode<ElemType> *p; p = new Btnode<ElemType>; p->Data = T->Data; p->Lchild = _Copy(T->Lchild); p->Rchild = _Copy(T->Rchild); return p; } //返回二叉树中元素值为e的节点的指针 template<class ElemType> Btnode<ElemType>* BinaryTree<ElemType>::_Locate(Btnode<ElemType>*bt, const ElemType &e) { if (!bt || bt->Data == e) { return bt; } Btnode<ElemType> *q; q = _Locate(bt->Lchild, e); if (q) { return q; } q = _Locate(bt->Rchild, e); return q; } //返回e节点的双亲节点指针 template<class ElemType> Btnode<ElemType>* BinaryTree<ElemType>::_Parent(Btnode<ElemType>* T, Btnode<ElemType>*p) { if (T==NULL || T == p) { return NULL; } if (T->Lchild == p || T->Rchild==p) { return T; } Btnode<ElemType> *q; q = _Parent(T->Lchild, p); if (q) return q; q = _Parent(T->Rchild, p); if (q) return q; } #include <iostream> #include "BinaryTree.h" using namespace std; void Print(const char &c) //遍历中访问的具体操作 { cout << c << "\t"; } int main() { cout << "-- 二叉树部分基本操作的演示实例--" << endl << endl; BinaryTree<char> bt1; char c = '#'; char e, ch1[256]; cout << "请按先序方式输入所需建的树的数据(此处空指针用 # 表示,数据用以建立对象:" << endl; cin >> ch1; bt1.Create1(ch1, c); cout << endl; cout << "当前二叉树的深度是:"; cout << bt1.Depth() << endl; cout << "对当前二叉树先序递归遍历的结果是:" << endl; bt1.PreorderTraverse(Print); cout << endl; cout << "对当前二叉树中序递归遍历的结果是:" << endl; bt1.InordTraverse(Print); cout << endl; cout << "对当前二叉树后序递归遍历的结果是:" << endl; bt1.PostorderTraverse(Print); cout << endl; cout << "对当前二叉树按层次遍历的结果是:" << endl; bt1.LevelTraverse(Print); cout << endl; Btnode<char> *p, *q; p = bt1.Root(); if (p) { cout << "当前二叉树的根:"; cout << bt1.Root()->Data << endl; } else cout << "当前二叉树是空树" << endl; cout << "请输入当前二叉树中的一个值:" << endl; cin >> e; p = bt1.Locate(e); if (p) { cout << "当前节点的双亲是:" << endl; q = bt1.Parent(p); if (q) { cout << q->Data << endl; } else cout << "无" << endl; cout << "当前节点的左孩子是:" << endl; q = bt1.LeftChild(p); if (q) cout << q->Data << endl; else cout << "无" << endl; cout << "当前节点的右孩子是:" << endl; q = bt1.RightChild(p); if (q) cout << q->Data << endl; else cout << "无" << endl; cout << "当前节点的左兄弟是:" << endl; q = bt1.LeftSibling(p); if (q) cout << q->Data << endl; else cout << "无" << endl; cout << "当前节点的右兄弟是:" << endl; q = bt1.RightSibling(p); if (q) cout << q->Data << endl; else cout << "无" << endl; } else cout << "当前树中无此节点" << endl; system("pause"); return 0; } ```
简易家谱系统——哪位大神能帮我看看下面的代码有什么问题,非常感谢!!!
/*在DEV C++编译有问题,但在CodeBlocks编译没问题而且能运行,但是运行时又在数据测试在删除结点后程序运行异常结束*/ #include <stdio.h> #include <stdlib.h> #include <string.h> #define M 100+1 // 宏定义,定义最大名字字母长度 typedef struct elem { char* name; char* post; }element; //双亲孩子表示法 typedef struct tree { element* item; int level; int childNum; struct tree* parent; struct tree* nextSibling; struct tree* prevSibling; struct tree* firstChild; }Node; // 实现一个栈,用于后续操作 typedef struct stack_t { Node** array; // array是个数组,其元素为Node*型指针 int index; // 指示栈顶元素 int size; // 栈的大小 } STACK; // 重命名 // 实现一个队列,用于后续操作 typedef struct queue_t { Node** array; // array是个数组,其内部元素为Node*型指针 int head; // 队列的头 int tail; // 队列的尾 int num; // 队列中元素的个数 int size; // 队列的大小 } QUEUE; // 这里的栈和队列,都是用动态数组实现的,另一种实现方式是用链表 // 内存分配函数 void* util_malloc(int size) { void* ptr = malloc(size); if (ptr == NULL) // 如果分配失败,则终止程序 { printf("Memory allocation error!\n"); exit(EXIT_FAILURE); } // 分配成功,则返回 return ptr; } // 实现一些栈操作 // 栈的初始化 STACK* STACKinit(int size)// 初始化栈大小为size { STACK* sp; sp = (STACK*)util_malloc(sizeof (STACK)); sp->size = size; sp->index = 0; sp->array = (Node**)util_malloc(size * sizeof (Node*)); return sp; } // 检测栈是否为空 // 如果为空返回1,否则返回0 int STACKempty(STACK* sp) { if (sp == NULL || sp->index <= 0) // 空 { return 1; } return 0; } // 入栈操作 int STACKpush(STACK* sp, Node* data) { if (sp == NULL || sp->index >= sp->size) // sp没有被初始化,或者已满 { return 0; // 入栈失败 } sp->array[sp->index++] = data; // 入栈 return 1; } // 出栈操作 int STACKpop(STACK* sp, Node** data_ptr) { if (sp == NULL || sp->index <= 0) // sp为初始化,或者为空没有元素 { return 0; } *data_ptr = sp->array[--sp->index]; // 出栈并把栈顶元素由参数data_ptr带回,成功则返回1 return 1; } // 将栈消毁 void STACKdestroy(STACK* sp) { free(sp->array); free(sp); } // 以上是栈的操作 // 实现队列的操作 QUEUE* QUEUEinit(int size) { QUEUE* qp; qp = (QUEUE*)util_malloc(sizeof (QUEUE)); qp->size = size; qp->head = qp->tail = qp->num = 0; //初始化队列的头、尾、元素个数都为0 qp->array = (Node**)util_malloc(size * sizeof (Node*)); return qp; } // 入队列 int QUEUEenqueue(QUEUE* qp, Node* data) { if (qp == NULL || qp->num >= qp->size) // qp未初始化或已满 { return 0; //入队失败 } qp->array[qp->tail] = data; // 入队,tail一直指向最后一个元素的下一个位置 qp->tail = (qp->tail + 1) % (qp->size); // 循环队列 ++qp->num; return 1; } // 出队列 int QUEUEdequeue(QUEUE* qp, Node** data_ptr) { if (qp == NULL || qp->num <= 0) // qp未初始化或队列内无元素 { return 0; } *data_ptr = qp->array[qp->head]; // 出队 qp->head = (qp->head + 1) % (qp->size); // 循环队列 --qp->num; return 1; } // 检测队列是否为空 int QUEUEempty(QUEUE* qp) { if (qp == NULL || qp->num <= 0) { return 1; } return 0; } // 销毁队列 void QUEUEdestroy(QUEUE* qp) { free(qp->array); free(qp); } // 以上是队列的有关操作实现 //创建元素 element* createElement() { element* temp = (element*)util_malloc(sizeof(element)); printf("请输入姓名和职业:\r\n"); temp->name = (char*)util_malloc(M); temp->post = (char*)util_malloc(M); scanf("%s %s",temp->name,temp->post); return temp; } //创建新结点 Node* createNode() { Node* temp = (Node*)util_malloc(sizeof(Node)); temp->childNum = 0; temp->level = 0; temp->firstChild = temp->parent = temp->nextSibling = temp->prevSibling = NULL; temp->item = createElement(); return temp; } //通过姓名查找结点元素 Node* searchNodeByName(char* name,Node* tree)//采用二叉树层序遍历的算法 { Node* head = tree; Node* result = NULL; QUEUE* que = QUEUEinit(M); QUEUEenqueue(que,head); while(QUEUEempty(que)==0&&result == NULL) { Node* temp; QUEUEdequeue(que,&temp); // &代表取地址 if (strcmp(name,temp->item->name) == 0) { result = temp; } else { temp = temp->firstChild; while(temp != NULL) { QUEUEenqueue(que,temp); temp = temp->nextSibling; } } } /* if (tree!=NULL) { if (strcmp(name,tree->item->name) == 0) { temp = tree; } else { while(temp!=NULL&&tree->nextSibling!=NULL){ temp = searchNodeByName(name,tree->firstChild); } } } */ return result; } //插入节点 void insertNode(Node* tree) { printf(" 请输入双亲的名字:\r\n"); char* parentName = (char*)util_malloc(M); scanf("%s",parentName); Node* parent = searchNodeByName(parentName,tree); if (parent!=NULL) { printf("找到双亲姓名:%s 职位:%s",parent->item->name,parent->item->post); Node* child = createNode(); child->parent = parent; if (parent->firstChild == NULL) { parent->firstChild = child; } else { Node* lastChild = parent->firstChild; while(lastChild->nextSibling!=NULL) { lastChild = lastChild->nextSibling; } lastChild->nextSibling = child; child->prevSibling = lastChild; } printf("插入成功\r\n"); } else { printf("没有找到双亲\r\n"); system("pause"); } free(parentName); } //释放结点所占空间 void FreeNode(Node* Node) { free(Node->item->name); free(Node->item->post); free(Node->item); free(Node->firstChild); free(Node->parent); free(Node->nextSibling); free(Node); } //倒叙层次遍历, 从右往左,从孩子到父亲 void ReverseTraversal(Node* node,void (*func)(Node*)) { STACK* stack = STACKinit(M); Node *temp = node; STACKpush(stack,temp); if (temp!=NULL) { if (temp->firstChild == NULL&&temp->nextSibling == NULL) { func(temp); } else { temp = temp->firstChild; while (temp!=NULL) { STACKpush(stack,temp); temp = temp->nextSibling; } while(STACKempty(stack) == 0) { Node* pop; STACKpop(stack,&pop); ReverseTraversal(pop,func); } } } } //层次遍历 void OrderTraversal(Node* node,void (*func)(Node*)) { QUEUE* que = QUEUEinit(M); Node* head = node; QUEUEenqueue(que,head); while(QUEUEempty(que) == 0) { Node* deque; QUEUEdequeue(que,&deque); func(deque); deque = deque->firstChild; while(deque) { QUEUEenqueue(que,deque); deque = deque->nextSibling; } } } void delNode(Node* tree) { printf("请输入要删除的姓名\r\n"); char * name = (char*)util_malloc(M); scanf("%s",name); Node* temp = searchNodeByName(name,tree); if(temp->nextSibling!=NULL&&temp->prevSibling!=NULL){ temp->prevSibling->nextSibling = temp->nextSibling; temp->nextSibling->prevSibling = temp->prevSibling; } else if(temp->prevSibling==NULL&&temp->nextSibling!=NULL){ temp->parent->firstChild = temp->nextSibling; temp->nextSibling->prevSibling = NULL; } else if(temp->prevSibling!=NULL&&temp->nextSibling == NULL){ temp->prevSibling->nextSibling == NULL; } else if(temp->prevSibling==NULL&&temp->nextSibling==NULL) { temp->parent->firstChild = NULL; } ReverseTraversal(temp,FreeNode); printf("删除成功\r\n"); free(name); } void printNode(Node* node) { printf("%5s",node->item->name); } int count(Node* tree) { int result = 0; QUEUE* que = QUEUEinit(M); Node* head = tree; QUEUEenqueue(que,head); while(QUEUEempty(que) == 0) { Node* deque; QUEUEdequeue(que,&deque); result ++; deque = deque->firstChild; while(deque) { QUEUEenqueue(que,deque); deque = deque->nextSibling; } } return result; } void search(Node* tree){ printf("请输入节点的名字:\r\n"); char* parentName = (char*)util_malloc(M); scanf("%s",parentName); Node* parent = searchNodeByName(parentName,tree); if (parent!=NULL) { printf("找到节点姓名:%s 职位:%s\n",parent->item->name,parent->item->post); } else { printf("查无此人!\r\n"); } } void modify(Node* tree) { printf("请输入要修改的姓名\r\n"); char * name = (char*)util_malloc(M); scanf("%s",name); Node* temp = searchNodeByName(name,tree); printf("请输入姓名和职业:\r\n"); scanf("%s %s",temp->item->name,temp->item->post); printf("修改成功\r\n"); } void searchSiblings(Node* node){ printf("请输入要查找同辈的姓名\r\n"); char * name = (char*)util_malloc(M); scanf("%s",name); Node* temp = searchNodeByName(name,node); Node* parent = temp->parent; Node* siblings = parent->firstChild; if (siblings!=NULL) { printf("和你同辈的人有:"); while(siblings!=NULL){ printf("%2s",siblings->item->name); siblings = siblings->nextSibling; } } else { printf("没有找到同辈\r\n"); } } void getParent(Node* node){ printf("请输入节点的名字:\r\n"); char* parentName = (char*)util_malloc(M); scanf("%s",parentName); Node* parent = searchNodeByName(parentName,node); parent = parent->parent; if (parent!=NULL) { printf("找到祖先姓名:%s 职位:%s",parent->item->name,parent->item->post); } else { printf("查无此人!\r\n"); } } void statistical(Node* tree){ printf("请输入要查找的职业\r\n"); char *post = (char *)util_malloc(M); scanf("%s",post); int result = 0; QUEUE* que = QUEUEinit(M); Node* head = tree; QUEUEenqueue(que,head); while(QUEUEempty(que) == 0){ Node* deque; QUEUEdequeue(que,&deque); if (strcmp(post,deque->item->post) == 0) { result++; } deque = deque->firstChild; while(deque){ QUEUEenqueue(que,deque); deque = deque->nextSibling; } } printf("从事%s的人数共%d",post,result); } //主函数 int main() { printf("请创建一份您的简易家谱系统\r\n"); Node* tree = createNode(); printf("家谱初始化成功\r\n"); system("pause"); for(;;) { system("cls"); printf("请选择所需要的功能\r\n"); printf("1.添加子孙\r\n"); printf("2.修改信息\r\n"); printf("3.删除信息\r\n"); printf("4.查询信息\r\n"); printf("5.族谱中集合\r\n"); printf("6.查找同辈\r\n"); printf("7.查询上一辈\r\n"); printf("8.统计总人数\r\n"); printf("9.统计从事某一种职业的人数\r\n"); int option = 0; scanf("%d",&option); system("cls"); switch (option) { case 1: insertNode(tree); system("pause"); break; case 2: modify(tree); system("pause"); break; case 3: delNode(tree); system("pause"); break; case 4: search(tree); system("pause"); break; case 5: OrderTraversal(tree,&printNode); system("pause"); break; case 6: searchSiblings(tree); system("pause"); break; case 7: getParent(tree); system("pause"); break; case 8: printf("族谱中总人数%d",count(tree)); system("pause"); break; case 9: statistical(tree); system("pause"); break; default: printf("暂时没有此功能\r\n"); system("pause"); } } return 0; }
用单链表实现磁盘调度算法的时候,最短寻道时间算法不知道哪错了
#include <stdio.h> #include <malloc.h> #include <math.h> #define Max 5 typedef struct DiskLine {//磁盘请求链表 int Location;//磁盘请求位置 DiskLine *next;//指向下一节点的指针 }DiskLine; //初始化磁盘链表 void InitList(DiskLine *&L) { L=(DiskLine *)malloc(sizeof(DiskLine)); L->next=NULL; } void CreateLine(DiskLine *&L,int a[],int n) { DiskLine *s,*r; int i; //L=(DiskLine *)malloc(sizeof(DiskLine)); r=L; for(i=0;i<=n;i++) { s=(DiskLine *)malloc(sizeof(DiskLine)); s->Location=a[i]; r->next=s; r=s; } r->next=NULL; } void Delet(DiskLine *L) {//销毁磁盘请求链表 DiskLine *p,*q; for(p = L; p != NULL; ) { q = p; p = p->next; free(q); } p = q =NULL; }//Delet void FCFS(DiskLine *L) { //先进先出算法 DiskLine *temp1,*temp2; temp2 = L; printf("%d\n",temp2->Location); int i=0,Sum = 0; printf("先进先出算法调度的顺序:\n"); for( temp1 = L->next; temp1->next!= NULL; temp1 = temp1->next, temp2 = temp2->next) { //顺序输出 printf("%d ",temp1->Location); Sum += abs(temp1->Location - temp2->Location); i++; } printf("\n"); printf("磁盘的寻道长度为%d\n",Sum); printf("磁盘的平均寻道长度为%d\n",Sum/i); }//FCFS int SSTF(DiskLine *L) {//最短寻道时间优先算法 DiskLine *L2; DiskLine *p,*q1,*q2; DiskLine *temp1,*temp,*temp2; int min,Sum = 0; //按照距离上一次磁头位置最近的顺序重新排列调度请求链表 L2 = (DiskLine *)malloc(sizeof(DiskLine));//重排列后的链表头节点 L2->Location = L->Location;//初始位置 L2->next = NULL; q2 = L2; temp1 = L; for(temp2= L; temp2->next != NULL; temp2=temp2->next) { min =abs(temp2->next->Location -temp1->Location); for(p = L; p->next != NULL; p = p->next) {//从原链表中选取距离磁头最近的请求位置,将其插入L2的链尾 if(abs(p->next->Location - temp1->Location) < min) { min = abs(p->next->Location - temp1->Location); q1 = p->next; } } //将节点从原链表删除 q2->next = q1->next; q1->next = q1->next->next; q2->next->next = NULL; Sum += min; /*if(L->next == NULL) break;//退出循环条件*/ }// for(temp = L2->next;temp->next!= NULL; temp = temp->next) {//输出重排列的链表 printf(" %d ",temp->Location); } L = L2;//便于销毁操作 return Sum; } int SCAN(DiskLine *L) {//扫描算法 DiskLine *L2,*L3; DiskLine *p2,*p3; int Sum = 0,Sum1,Sum2; DiskLine *temp = L->next; L2 = (DiskLine *)malloc(sizeof(DiskLine)); L2->Location = 53; L2->next = NULL; p2 = (DiskLine *)malloc(sizeof(DiskLine)); //保证磁头可到达0位置 p2->Location = 0; p2->next = L2->next; L2->next = p2; L3 = (DiskLine *)malloc(sizeof(DiskLine)); L3->Location = 0; L3->next = NULL; p2 = L2->next; p3 = L3; while(temp != NULL) { if((temp->Location - L->Location) <= 0) {//选出原链表中请求位置小于等于磁头初始位置的节点插入L2链尾 p2->next = temp; temp = temp->next; p2 = p2->next; p2->next = NULL; } else {//选出原链表中请求位置大于磁头初始位置的节点插入L3链尾 p3->next = temp; temp = temp->next; p3 = p3->next; p3->next = NULL; } } Sum1=SSTF(L2);//对链表L2调用SSTF算法 Sum2=SSTF(L3);//对链表L3调用SSTF算法 Sum=Sum1 + Sum2; return Sum; }//SCAN int C_SCAN(DiskLine *L) {//循环扫描算法 DiskLine *L2,*L3; DiskLine *p2,*p3; int Sum = 0,Sum1,Sum2; DiskLine *temp = L->next; L2 = (DiskLine *)malloc(sizeof(DiskLine)); L2->Location = 0; L2->next = NULL; //保证磁头能到达0位置 p2 = (DiskLine *)malloc(sizeof(DiskLine)); p2->Location = 0; p2->next = L2->next; L2->next = p2; L3 = (DiskLine *)malloc(sizeof(DiskLine)); L3->Location = 53; L3->next = NULL; //保证磁头能到达200位置 p3 = (DiskLine *)malloc(sizeof(DiskLine)); p3->Location = 200; p3->next = L3->next; L3->next = p3; p2 = L2->next; p3 = L3->next; while(temp != NULL) {//同SCAN if((temp->Location - L->Location) <= 0) { p2->next = temp; temp = temp->next; p2 = p2->next; p2->next = NULL; } else { p3->next = temp; temp = temp->next; p3 = p3->next; p3->next = NULL; } } Sum1 = SSTF(L3); Sum2 = SSTF(L2); Sum = Sum1 + Sum2; return Sum; }//C_SCAN void main() { DiskLine *L,*r; InitList(L); int choice,Queue[Max]; printf("----------------------磁盘调度模拟----------------\n"); printf("请输入磁盘请求的个数:"); printf("%d\n",Max); printf("-----------------------初始状态-------------------\n"); printf("\n\n"); printf("磁头初始位置为:"); scanf("%d",&L->Location); printf("磁盘调度请求队列:\n"); for(int i=0;i<Max;i++) scanf("%d",&Queue[i]); CreateLine(L,Queue,Max); printf("请选择调度算法:\n"); printf(" 1 为FCFS<先来先服务调度法>;\n"); printf(" 2 为SSTF<最短寻道时间优先扫描算法>;\n"); printf(" 3 为SCAN<扫描算法>;\n"); printf(" 4 为C_SCAN<循环扫描算法>;\n"); printf(" 5 为退出;\n"); printf("请输入你的选择:"); scanf("%d",&choice); switch(choice) { case 1:FCFS(L);break; case 2:SSTF(L);break; case 3:SCAN(L);break; case 4:C_SCAN(L);break; case 5:break; default:printf("ERROR!"); } } 注:这是老师给的算法,但是基本上都有问题,目前SSTF被我改成这样,我真的不知道哪儿错了,求指点
有大神帮忙看一下这个代码存在什么问题吗?万分感谢!
一个数据结构的问题,在主函数中的‘B’情况运行到EnQueue(Q1,e)的时候出现异常。 using namespace std; #include<iostream> #include<stdlib.h> #include<cmath> #include<cstring> typedef int Status; #define int Status #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define MAXSIZE 100 //链栈 typedef struct StackNode { char data; struct StackNode *next; }StackNode, *LinkStackPtr; typedef struct LinkStack { LinkStackPtr top; int size; }LinkStack; //重要操作 LinkStack //判断是否为空栈 Status StackEmpty(LinkStack *S) { if (S->size == 0) { return TRUE; } else { return FALSE; } } //初始化一个栈 Status InitStack(LinkStack *S) { S->top = NULL; S->size = 0; return OK; } //返回栈顶元素 Status GetTop(LinkStack *S, char * e) {//char if (S->size == 0) { return ERROR; } else { *e = S->top->data; } return OK; } //进栈操作 Status push(LinkStack *S, char e) { LinkStackPtr s = (LinkStackPtr)malloc(sizeof(StackNode)); s->data = e; s->next = S->top; S->top = s; S->size++; return OK; } //出栈操作 Status pop(LinkStack *S, char *e) { if (StackEmpty(S)) { return FALSE; } else { *e = S->top->data; LinkStackPtr s = S->top; S->top = s->next; S->size--; free(s); return OK; } } //链队列 typedef struct QNode { char data; struct QNode *next; }QNode, *QueuePtr;//结点结构 typedef struct { QueuePtr front, rear; int Size; }LinkQueue;//队列的链表结构 //重要操作 LinkQueue //判断是否为空队列 Status QueueEmpty(LinkQueue *Q) { if (Q->Size == 0) { return TRUE; } else { return FALSE; } } //初始化 Status InitQueue(LinkQueue *Q) { Q->front = Q->rear = (QueuePtr)malloc(sizeof(QNode)); if (!Q->front) exit(OVERFLOW); Q->front->next = NULL; Q->Size = 0; return OK; } //入队列 Status EnQueue(LinkQueue *Q, char e) {//链队列是带头节点的,头指针永远指向头节点 QueuePtr q = (QueuePtr)malloc(sizeof(QNode)); if (!q) exit(OVERFLOW); q->data = e; q->next = NULL; Q->rear->next = q; Q->rear = q; Q->Size++; return OK; } //出队列 Status DeQueue(LinkQueue *Q, char *e) { if (Q->front == Q->rear) return ERROR; *e = Q->front->data; QueuePtr q = Q->front->next; Q->front->next = q->next; if (q == Q->rear) Q->rear = Q->front; Q->Size--; free(q); return OK; } //talk函数用于将魔王的语言进行压栈 Status Language_Talk(LinkStack *S) { char word[MAXSIZE]; cout << "请输入魔王的语言"; cin >> word; int i; int j = 0; int left = 0, right = 0; cout << "魔王语言为"<<word << endl; int len = strlen(word) - 1; cout <<"魔王语言长度为"<< len+1 << endl; cout << "成功输入魔王语言"; while (j<len) { if (word[j] == '(') left++; if (word[j] == ')') right++; j++; } if (len+1==0) { cout << "魔王没有说话"; return ERROR; } else { if (left != right) { cout << "魔王说了错误的话"; return ERROR; } else { for (i = len;i >= 0;i--) { push(S, word[i]); } } } return OK; } //已经解析的语言存入数组 Status Language_Record(LinkQueue *Q, LinkQueue *Q1) { //char *e=; char *e = (char *)malloc(sizeof(char)); while (!QueueEmpty(Q)) { DeQueue(Q, e); EnQueue(Q1, *e); } return OK; } //词汇依次出栈进行处理 //A情况 char Language_explanA(LinkStack *S, LinkQueue *Q) { //char *e; char *e = (char *)malloc(sizeof(char)); pop(S, e); char E = *e; free(e); int a = 0; char A[10] = "sae"; while (a <= 2) { EnQueue(Q, A[a]); a++; } return *e; /*cout << A; cout << "输出第一个元素"; cout << Q->front->data;*/ //return OK; } //B情况 Status Language_explanB(LinkStack *S, LinkQueue *Q) { //char *e; char *e = (char*)malloc(sizeof(char)); pop(S, e); int b = 0; char B[10] = "tsaedsae"; while (B[b]) { EnQueue(Q, B[b]); b++; } return 0; } //‘(’情况 Status Language_explanleft(LinkStack *S, LinkQueue *Q) { //char *e; char *e = (char*)malloc(sizeof(char)); pop(S, e); pop(S, e); char sita = *e; EnQueue(Q, sita); while (S->top->data != ')') { pop(S, e); EnQueue(Q, *e); EnQueue(Q, sita); } return 0; } //')'情况 Status Language_explanright(LinkStack *S, LinkQueue *Q) { //char *e; char *e = (char*)malloc(sizeof(char)); pop(S, e); while (!QueueEmpty) { DeQueue(Q, e); push(S, *e); } return OK; } int main() { int position = 0; LinkStack *Link_Stack = (LinkStack *)malloc(sizeof(StackNode)); LinkQueue *Link_Queue = (LinkQueue *)malloc(sizeof(QNode)); LinkQueue *Humanwords = (LinkQueue *)malloc(sizeof(QNode)); InitStack(Link_Stack); InitQueue(Link_Queue); char Devilwords[MAXSIZE]; Language_Talk(Link_Stack); cout << Link_Stack->size; cout << Link_Stack->top->data << endl; while (!StackEmpty(Link_Stack)) { if (Link_Stack->top->data == 'A') { Language_explanA(Link_Stack, Link_Queue); cout << "执行了A"; cout << Link_Queue->Size << endl; cout << Link_Stack->size << endl; } if (Link_Stack->top->data == 'B') { Language_explanB(Link_Stack, Link_Queue); cout << Link_Queue->Size << endl; cout << Link_Stack->size << endl; } if (Link_Stack->top->data == '(') { Language_Record(Link_Queue, Humanwords); Language_explanleft(Link_Stack, Link_Queue); } if (Link_Stack->top->data == ')') Language_explanright(Link_Stack, Link_Queue); } cout << Humanwords; system("pause"); return OK; }
大学四年自学走来,这些私藏的实用工具/学习网站我贡献出来了
大学四年,看课本是不可能一直看课本的了,对于学习,特别是自学,善于搜索网上的一些资源来辅助,还是非常有必要的,下面我就把这几年私藏的各种资源,网站贡献出来给你们。主要有:电子书搜索、实用工具、在线视频学习网站、非视频学习网站、软件下载、面试/求职必备网站。 注意:文中提到的所有资源,文末我都给你整理好了,你们只管拿去,如果觉得不错,转发、分享就是最大的支持了。 一、电子书搜索 对于大部分程序员...
【JSON解析】浅谈JSONObject的使用
简介 在程序开发过程中,在参数传递,函数返回值等方面,越来越多的使用JSON。JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,同时也易于机器解析和生成、易于理解、阅读和撰写,而且Json采用完全独立于语言的文本格式,这使得Json成为理想的数据交换语言。 JSON建构于两种结构: “名称/值”对的集合(A Collection of name/va...
《MySQL 性能优化》之理解 MySQL 体系结构
本文介绍 MySQL 的体系结构,包括物理结构、逻辑结构以及插件式存储引擎。
程序员请照顾好自己,周末病魔差点一套带走我。
程序员在一个周末的时间,得了重病,差点当场去世,还好及时挽救回来了。
卸载 x 雷某度!GitHub 标星 1.5w+,从此我只用这款全能高速下载工具!
作者 | Rocky0429 来源 | Python空间 大家好,我是 Rocky0429,一个喜欢在网上收集各种资源的蒟蒻… 网上资源眼花缭乱,下载的方式也同样千奇百怪,比如 BT 下载,磁力链接,网盘资源等等等等,下个资源可真不容易,不一样的方式要用不同的下载软件,因此某比较有名的 x 雷和某度网盘成了我经常使用的工具。 作为一个没有钱的穷鬼,某度网盘几十 kb 的下载速度让我...
只因接了一个电话,程序员被骗 30 万!
今天想给大家说一个刚刚发生在我身边的一起真实的诈骗经历,我的朋友因此被骗走30万。注:为了保护当事人隐私,部分情节进行了修改。1平安夜突来的电话开始以为就像普通的诈骗一样,想办法让你把钱...
我一个37岁的程序员朋友
周末了,人一旦没有点事情干,心里就瞎想,而且跟几个老男人坐在一起,更容易瞎想,我自己现在也是 30 岁了,也是无时无刻在担心自己的职业生涯,担心丢掉工作没有收入,担心身体机能下降,担心突...
python自动下载图片
近日闲来无事,总有一种无形的力量萦绕在朕身边,让朕精神涣散,昏昏欲睡。 可是,像朕这么有职业操守的社畜怎么能在上班期间睡瞌睡呢,我不禁陷入了沉思。。。。 突然旁边的IOS同事问:‘嘿,兄弟,我发现一个网站的图片很有意思啊,能不能帮我保存下来提升我的开发灵感?’ 作为一个坚强的社畜怎么能说自己不行呢,当时朕就不假思索的答应:‘oh, It’s simple. Wait for me for a ...
一名大专同学的四个问题
【前言】   收到一封来信,赶上各种事情拖了几日,利用今天要放下工作的时机,做个回复。   2020年到了,就以这一封信,作为开年标志吧。 【正文】   您好,我是一名现在有很多困惑的大二学生。有一些问题想要向您请教。   先说一下我的基本情况,高考失利,不想复读,来到广州一所大专读计算机应用技术专业。学校是偏艺术类的,计算机专业没有实验室更不用说工作室了。而且学校的学风也不好。但我很想在计算机领...
复习一周,京东+百度一面,不小心都拿了Offer
京东和百度一面都问了啥,面试官百般刁难,可惜我全会。
Java 14 都快来了,为什么还有这么多人固守Java 8?
从Java 9开始,Java版本的发布就让人眼花缭乱了。每隔6个月,都会冒出一个新版本出来,Java 10 , Java 11, Java 12, Java 13, 到2020年3月份,...
达摩院十大科技趋势发布:2020 非同小可!
【CSDN编者按】1月2日,阿里巴巴发布《达摩院2020十大科技趋势》,十大科技趋势分别是:人工智能从感知智能向认知智能演进;计算存储一体化突破AI算力瓶颈;工业互联网的超融合;机器间大规模协作成为可能;模块化降低芯片设计门槛;规模化生产级区块链应用将走入大众;量子计算进入攻坚期;新材料推动半导体器件革新;保护数据隐私的AI技术将加速落地;云成为IT技术创新的中心 。 新的画卷,正在徐徐展开。...
轻松搭建基于 SpringBoot + Vue 的 Web 商城应用
首先介绍下在本文出现的几个比较重要的概念: 函数计算(Function Compute): 函数计算是一个事件驱动的服务,通过函数计算,用户无需管理服务器等运行情况,只需编写代码并上传。函数计算准备计算资源,并以弹性伸缩的方式运行用户代码,而用户只需根据实际代码运行所消耗的资源进行付费。Fun: Fun 是一个用于支持 Serverless 应用部署的工具,能帮助您便捷地管理函数计算、API ...
Python+OpenCV实时图像处理
目录 1、导入库文件 2、设计GUI 3、调用摄像头 4、实时图像处理 4.1、阈值二值化 4.2、边缘检测 4.3、轮廓检测 4.4、高斯滤波 4.5、色彩转换 4.6、调节对比度 5、退出系统 初学OpenCV图像处理的小伙伴肯定对什么高斯函数、滤波处理、阈值二值化等特性非常头疼,这里给各位分享一个小项目,可通过摄像头实时动态查看各类图像处理的特点,也可对各位调参、测试...
2020年一线城市程序员工资大调查
人才需求 一线城市共发布岗位38115个,招聘120827人。 其中 beijing 22805 guangzhou 25081 shanghai 39614 shenzhen 33327 工资分布 2020年中国一线城市程序员的平均工资为16285元,工资中位数为14583元,其中95%的人的工资位于5000到20000元之间。 和往年数据比较: yea...
为什么猝死的都是程序员,基本上不见产品经理猝死呢?
相信大家时不时听到程序员猝死的消息,但是基本上听不到产品经理猝死的消息,这是为什么呢? 我们先百度搜一下:程序员猝死,出现将近700多万条搜索结果: 搜索一下:产品经理猝死,只有400万条的搜索结果,从搜索结果数量上来看,程序员猝死的搜索结果就比产品经理猝死的搜索结果高了一倍,而且从下图可以看到,首页里面的五条搜索结果,其实只有两条才是符合条件。 所以程序员猝死的概率真的比产品经理大,并不是错...
害怕面试被问HashMap?这一篇就搞定了!
声明:本文以jdk1.8为主! 搞定HashMap 作为一个Java从业者,面试的时候肯定会被问到过HashMap,因为对于HashMap来说,可以说是Java集合中的精髓了,如果你觉得自己对它掌握的还不够好,我想今天这篇文章会非常适合你,至少,看了今天这篇文章,以后不怕面试被问HashMap了 其实在我学习HashMap的过程中,我个人觉得HashMap还是挺复杂的,如果真的想把它搞得明明白...
毕业5年,我问遍了身边的大佬,总结了他们的学习方法
我问了身边10个大佬,总结了他们的学习方法,原来成功都是有迹可循的。
推荐10个堪称神器的学习网站
每天都会收到很多读者的私信,问我:“二哥,有什么推荐的学习网站吗?最近很浮躁,手头的一些网站都看烦了,想看看二哥这里有什么新鲜货。” 今天一早做了个恶梦,梦到被老板辞退了。虽然说在我们公司,只有我辞退老板的份,没有老板辞退我这一说,但是还是被吓得 4 点多都起来了。(主要是因为我掌握着公司所有的核心源码,哈哈哈) 既然 4 点多起来,就得好好利用起来。于是我就挑选了 10 个堪称神器的学习网站,推...
这些软件太强了,Windows必装!尤其程序员!
Windows可谓是大多数人的生产力工具,集娱乐办公于一体,虽然在程序员这个群体中都说苹果是信仰,但是大部分不都是从Windows过来的,而且现在依然有很多的程序员用Windows。 所以,今天我就把我私藏的Windows必装的软件分享给大家,如果有一个你没有用过甚至没有听过,那你就赚了????,这可都是提升你幸福感的高效率生产力工具哦! 走起!???? NO、1 ScreenToGif 屏幕,摄像头和白板...
阿里面试,面试官没想到一个ArrayList,我都能跟他扯半小时
我是真的没想到,面试官会这样问我ArrayList。
曾经优秀的人,怎么就突然不优秀了。
职场上有很多辛酸事,很多合伙人出局的故事,很多技术骨干被裁员的故事。说来模板都类似,曾经是名校毕业,曾经是优秀员工,曾经被领导表扬,曾经业绩突出,然而突然有一天,因为种种原因,被裁员了,...
大学四年因为知道了这32个网站,我成了别人眼中的大神!
依稀记得,毕业那天,我们导员发给我毕业证的时候对我说“你可是咱们系的风云人物啊”,哎呀,别提当时多开心啦????,嗯,我们导员是所有导员中最帅的一个,真的???? 不过,导员说的是实话,很多人都叫我大神的,为啥,因为我知道这32个网站啊,你说强不强????,这次是绝对的干货,看好啦,走起来! PS:每个网站都是学计算机混互联网必须知道的,真的牛杯,我就不过多介绍了,大家自行探索,觉得没用的,尽管留言吐槽吧???? 社...
良心推荐,我珍藏的一些Chrome插件
上次搬家的时候,发了一个朋友圈,附带的照片中不小心暴露了自己的 Chrome 浏览器插件之多,于是就有小伙伴评论说分享一下我觉得还不错的浏览器插件。 我下面就把我日常工作和学习中经常用到的一些 Chrome 浏览器插件分享给大家,随便一个都能提高你的“生活品质”和工作效率。 Markdown Here Markdown Here 可以让你更愉快的写邮件,由于支持 Markdown 直接转电子邮...
看完这篇HTTP,跟面试官扯皮就没问题了
我是一名程序员,我的主要编程语言是 Java,我更是一名 Web 开发人员,所以我必须要了解 HTTP,所以本篇文章就来带你从 HTTP 入门到进阶,看完让你有一种恍然大悟、醍醐灌顶的感觉。 最初在有网络之前,我们的电脑都是单机的,单机系统是孤立的,我还记得 05 年前那会儿家里有个电脑,想打电脑游戏还得两个人在一个电脑上玩儿,及其不方便。我就想为什么家里人不让上网,我的同学 xxx 家里有网,每...
史上最全的IDEA快捷键总结
现在Idea成了主流开发工具,这篇博客对其使用的快捷键做了总结,希望对大家的开发工作有所帮助。
阿里程序员写了一个新手都写不出的低级bug,被骂惨了。
这种新手都不会范的错,居然被一个工作好几年的小伙子写出来,差点被当场开除了。
谁是华为扫地僧?
是的,华为也有扫地僧!2020年2月11-12日,“养在深闺人不知”的华为2012实验室扫地僧们,将在华为开发者大会2020(Cloud)上,和大家见面。到时,你可以和扫地僧们,吃一个洋...
Idea 中最常用的10款插件(提高开发效率),一定要学会使用!
学习使用一些插件,可以提高开发效率。对于我们开发人员很有帮助。这篇博客介绍了开发中使用的插件。
AI 没让人类失业,搞 AI 的人先失业了
最近和几个 AI 领域的大佬闲聊 根据他们讲的消息和段子 改编出下面这个故事 如有雷同 都是巧合 1. 老王创业失败,被限制高消费 “这里写我跑路的消息实在太夸张了。” 王葱葱哼笑一下,把消息分享给群里。 阿杰也看了消息,笑了笑。在座几位也都笑了。 王葱葱是个有名的人物,21岁那年以全额奖学金进入 KMU 攻读人工智能博士,累计发表论文 40 余篇,个人技术博客更是成为深度学习领域内风向标。 ...
2020年,冯唐49岁:我给20、30岁IT职场年轻人的建议
点击“技术领导力”关注∆每天早上8:30推送 作者|Mr.K 编辑| Emma 来源|技术领导力(ID:jishulingdaoli) 前天的推文《冯唐:职场人35岁以后,方法论比经验重要》,收到了不少读者的反馈,觉得挺受启发。其实,冯唐写了不少关于职场方面的文章,都挺不错的。可惜大家只记住了“春风十里不如你”、“如何避免成为油腻腻的中年人”等不那么正经的文章。 本文整理了冯...
作为一名大学生,如何在B站上快乐的学习?
B站是个宝,谁用谁知道???? 作为一名大学生,你必须掌握的一项能力就是自学能力,很多看起来很牛X的人,你可以了解下,人家私底下一定是花大量的时间自学的,你可能会说,我也想学习啊,可是嘞,该学习啥嘞,不怕告诉你,互联网时代,最不缺的就是学习资源,最宝贵的是啥? 你可能会说是时间,不,不是时间,而是你的注意力,懂了吧! 那么,你说学习资源多,我咋不知道,那今天我就告诉你一个你必须知道的学习的地方,人称...
木兰编程语言,当事人最新回复来了
同行12年,不知Python是木兰,当事人回应来了
那些年,我们信了课本里的那些鬼话
教材永远都是有错误的,从小学到大学,我们不断的学习了很多错误知识。 斑羚飞渡 在我们学习的很多小学课文里,有很多是错误文章,或者说是假课文。像《斑羚飞渡》: 随着镰刀头羊的那声吼叫,整个斑羚群迅速分成两拨,老年斑羚为一拨,年轻斑羚为一拨。 就在这时,我看见,从那拨老斑羚里走出一只公斑羚来。公斑羚朝那拨年轻斑羚示意性地咩了一声,一只半大的斑羚应声走了出来。一老一少走到伤心崖,后退了几步,突...
一个程序在计算机中是如何运行的?超级干货!!!
强烈声明:本文很干,请自备茶水!???? 开门见山,咱不说废话! 你有没有想过,你写的程序,是如何在计算机中运行的吗?比如我们搞Java的,肯定写过这段代码 public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); } ...
那个在阿里养猪的工程师,5年了……
简介: 在阿里,走过1825天,没有趴下,依旧斗志满满,被称为“五年陈”。他们会被授予一枚戒指,过程就叫做“授戒仪式”。今天,咱们听听阿里的那些“五年陈”们的故事。 下一个五年,猪圈见! 我就是那个在养猪场里敲代码的工程师,一年多前我和20位工程师去了四川的猪场,出发前总架构师慷慨激昂的说:同学们,中国的养猪产业将因为我们而改变。但到了猪场,发现根本不是那么回事:要个WIFI,没有;...
为什么程序猿都不愿意去外包?
分享外包的组织架构,盈利模式,亲身经历,以及根据一些外包朋友的反馈,写了这篇文章 ,希望对正在找工作的老铁有所帮助
立即提问