精华内容
下载资源
问答
  • 数据结构中出现的cout是什么

    千次阅读 2017-04-04 00:03:59
    转载自cout百度百科 http://baike.baidu.com/item/cout?sefr=cr 由于以前学过C,所以这段代码的其它部分在我看来都还算“正常”,然而cout却很独特:既不是函数,似乎也不是C++特别规定出来的像if,for一类有特殊...
    转载自cout百度百科
    http://baike.baidu.com/item/cout?sefr=cr
    由于以前学过C,所以这段代码的其它部分在我看来都还算“正常”,然而cout却很独特:既不是函数,似乎也不是C++特别规定出来的像if,for一类有特殊语法的“语句”。由于只是初步介绍,所以那本书只是简单的说cout是C++中的“标准输入输出流”对象……这对于我而言实在是一个很深奥的术语。这还没完,之后又遇见了cin……因为不知底细,从此使用它们的时候都诚惶诚恐,几欲逃回C时代那简明的printf(),毕竟好歹我可以说:我在调用的是一个函数。那有着一长串<<、>>的玩意,究竟算怎么回事呢?我一直想把它们当作关键字,可偏偏不是,而且居然是用C++语言“做”出来的,呵!但printf()用多了就开始有人好心地批判我的程序“C语言痕迹过重”……
    后来随着学习的深入,总算大概明白了cout/cin/cerr/...的鬼把戏:那些东东不过是变着法儿“哄人”,其实说到底还是函数调用,不过这函数有些特殊,用的是运算符重载,确切地说(以下还是以cout为例)是重载了“<<”运算符。我们就让它现出函数的本来面目,请看HelloWorld!的等效版本:
    1
    2
    3
    4
    5
    6
    7
    8
    #include<iostream>
    using namespace std;
    int main()
    {
        cout.operator << ("Hello,World!");
        cout.operator << (endl);
        return 0;
    }
    编译运行,结果与经典版无二。上面程序应该更容易理解了:cout是一个ostream类的对象,它有一个成员运算符函数operator<<,每次调用的时候就会向输出设备(一般就是屏幕啦)输出东东。嗯,这里有一个问题:为什么函数operator<<能够接受不同类型的数据,如整型浮点型、字符串甚至指针,等等呢?
    我想你已经猜到了,没错,就是用运算符重载运算符函数与一般函数基本无异,可以任意重载。标准库的设计者们早已经为我们定制了iostream::operator<<对于各种C++基本数据类型的重载版本,这才使得我们这些初学者们一上来就享受到cout<<"Hello,World!"<<endl;
    cout.operator<<("Hello,World!").operator<<(endl);
    才算“强等效”。究竟可不可以这样写?向编译器确认一下……OK,NoProblem!
    还有为什么可以连续写多个呢?请见如下的定义:
    ostream& std::cout.operator<<();
    注意前面的ostream&表示返回对象的引用,也就是可以继续cout了
    对于cin,则是istream流类的对象,其重载了>>运算符,用法与cout大致相同
    那么cout<<endl;是什么呢?

    转载自:http://www.sjyhome.com/c++-cout-endl;.html

    我们在最初学习C++语言时就接触到"cout<<endl;"这样的语句。我们都知道endl表示换行的意思。我一直习惯这样使用,却并不是清楚其内部实现是怎么样的。今天看《C++ Standard Library, Sec.13.6.1》,才真正弄明白。

    首先,endl是一个操作符(Manipulators),但我们必须知道endl是一个什么类型的变量。endl是跟在”<<“运算符后面,故endl应该是一个参数。其实endl是一个函数名,它是一个"<<"运算符重载函数中的参数,参数类型为函数指针。下面我们看下内部函数实现。

    ostream& ostream::operator << ( ostream& (*op) (ostream&))
    {
    // call the function passed as parameter with this stream   as the argument
    return (*op) (*this);
    }
    
    std::ostream& std::endl (std::ostream& strm)
    {
        // write newline
        strm.put('\n');
        // flush the output buffer
        strm.flush();
        // return strm to allow chaining
        return strm;
    }

    可以看出,运算符重载函数中的函数参数为一个函数指针,其指向一个输入输出均为ostream类引用的函数。而endl正是这样一个函数。所以我们在运行"cout<<endl;"语句时,endl是一个函数参数,类型为函数指针。然后会执行”return (*endl) (*this);“语句,即执行endl函数。endl函数输出一个换行符,并刷新输出缓冲区。

    这样我们知道在标准库中endl是作为一个函数实现的,显然我们也可以直接调用这一函数。我们看下面的测试程序:

    #include<iostream>
    using namespace std;
    
    int main()
    {
        cout<<endl;
        endl(cout);
        return 0;
    }

    其输出为两个空行。”cout<<endl"中,endl是一个类型为函数指针的函数参数,通过运算符重载函数间接调用了endl函数。而“endl(cout)”中,endl是函数名,直接调用了endl函数。


    展开全文
  • 数据结构队列

    2012-04-07 22:36:15
    数据结果队列的源代码及实现。 cout请按照序号选择您所要操作的内容:";...// cout删除某个数据;"; cout置空顺序队列;"; cout求解杨辉三角;"; // cout搜索第I个元素的地址;"; // cout判别链表是否为空;";
  • 数据结构

    2019-05-11 20:45:13
    遍历二叉树 ㈠先序遍历的操作定义如下: 若二叉树为空,则空操作,否则 ①访问根结点 ②先序遍历左子树 ③先序遍历右子树 void preorder(tree bt) //先序遍历根结点为bt... cout << bt->data; ...

    遍历二叉树

    ㈠先序遍历的操作定义如下:

    若二叉树为空,则空操作,否则
        	①访问根结点
        	②先序遍历左子树
        	③先序遍历右子树
        	void preorder(tree bt)  //先序遍历根结点为bt的二叉树的递归算法
        	{
        	    if(bt)
        	   {
        	      cout << bt->data;
        	      preorder(bt->lchild);
        	      preorder(bt->rchild);
        	   }
        	}
    

    ㈡中序遍历的操作定义如下:

    若二叉树为空,则空操作,否则                           
    	①中序遍历左子树
     	②访问根结点
    	③中序遍历右子树
       void inorder(tree bt)  //中序遍历根结点为bt的二叉树的递归算法
       {
           if(bt)
           {
       	inorder(bt->lchild);
       	cout << bt->data;
       	inorder(bt->rchild);
           }
       }
    

    ㈢后序遍历的操作定义如下:

    若二叉树为空,则空操作,否则
    	①后序遍历左子树
    	②后序遍历右子树
    	③访问根结点
    	void postorder(tree bt)  //后序遍历根结点为bt的二叉树的递归算法
    	{
      	  if(bt)
    	    {
     	       postorder(bt->lchild);
      	      postorder(bt->rchild);
     	       cout << bt->data;
     	   }
    	}
    

    二叉树的其它重要操作

    1、建立一棵二叉树
    	void pre_crt(tree &bt) //按先序次序输入二叉树中结点的值,生成
    	{
    		char ch;
    		ch = getchar();  //二叉树的单链表存储结构,bt为指向根结点的指针,'$'表示空树 
    		if(ch != '$')
    		{
    			bt = new node;      //建根结点
    			bt->data = ch;
    			pre_crt(bt->lchild);  //建左子树
    			pre_crt(bt->rchild);  //建右子树
    		}
    		else bt = NULL;
    	}
    

    2、删除二叉树

    void dis(tree &bt)           //删除二叉树
    	{
    		if(bt)
    		{
    			dis(bt->lchild);     //删左子树
    			dis(bt->rchild);     //删右子树
    			delete bt;          //释放父结点
    		}
    	}
    

    3.插入一个结点到排序二叉树中

    void insert(tree &bt, int n)    //插入一个结点到排序二叉树中
    	{
    		if(bt)
    		{
    			if(n < bt->data) insert(bt->lchild, n);
    			else if(n > bt->data) insert(bt->rchild, n);
    		}
    		else
    		{
    			bt = new node;      //新开一个空间
    			bt->data = n;
    			bt->lchild = bt->rchild = NULL;
    		}
    	}	
    
    展开全文
  • 初级数据结构

    2021-01-22 13:56:42
    初级数据结构 顺序表 #include<iostream> using namespace std; #define MAX 100 typedef struct { int data[MAX];//顺序表元素 int length;//顺序表长度 }sqlist; int initlist(sqlist *l)//初始化顺序...

    初级数据结构

    顺序表

    #include<iostream>
    using namespace std;
    
    #define MAX 100
    
    typedef struct
    {
    	int data[MAX];//顺序表元素
    	int length;//顺序表长度
    }sqlist;
    
    
    int initlist(sqlist *l)//初始化顺序表
    {
    	memset(l->data, 0, sizeof(l));
    	l->length = 0;
    	cout << "初始化成功" << endl;
    	return 0;
    }
    
    int addlist(sqlist* l)//给顺序表添加数据
    {
    	if (l->length<0 || l->length>MAX)
    	{
    		cout << "顺序表出错" << endl;
    		return 0;
    	}
    	else
    	{
    		for (int i = 0; i < 10; i++)
    		{
    			cin >> l->data[i];
    			l->length++;
    		}
    		cout << "添加成功" << endl;
    	}
    }
    
    void lenlist(sqlist* l)//求顺序表长度
    {
    	if (l == NULL)
    	{
    		cout << "不存在该顺序表" << endl;
    	}
    	else
    	{
    		cout << "顺序表长度为:" << l->length << endl;;
    	}
    }
    
    int searchlist(sqlist *l)//查找元素
    {
    	int n;
    	cout << "请输入要查找的元素n:";
    	cin >> n;
    	if (l->length<0 || l->length>MAX)
    	{
    		cout<<"不存在该表"<<endl;
    		return 0;
    	}
    	else
    	{
    		for (int i = 0; i < MAX; i++)
    		{
    			if (l->data[i] == n)
    			{
    				cout<<"位置是"<<i+1<<endl;
    				return i;
    				break;
    			}
    		}
    	}
    }
    
    int insertlist(sqlist* l)//i位置插入num插入元素
    {
    	int num,i;
    	cout << "请输入要在i位置插入的元素num:";
    	cin >>i>>num;
    	if (l->length<0 || l->length>MAX)
    	{
    		cout << "不存在该顺序表" << endl;
    		return 0;
    	}
    	else
    	{
    		for (int j = l->length; j >=i; j--)
    		{
    			l->data[j] = l->data[j-1];
    		}
    		l->data[i-1] = num;
    		l->length++;
    		cout<<"插入成功"<<endl;
    	}
    }
    
    void dellist(sqlist* l)//删除元素
    {
    	int n;
    	cout << "请输入要删除的元素n:";
    	cin >> n;
    	if (l->length<0 || l->length>MAX)
    	{                                                                                                 
    		cout << "不存在该顺序表" << endl;
    	}
    	else
    	{
    		for (int i = 0; i < l->length; i++)
    		{
    			if (i == l->length)
    				cout<<"无此元素" << endl;
    			if(n==l->data[i])
    			{
    				for (int j = i+1; j < l->length; j++)
    				{
    					l->data[j-1] = l->data[j];
    				}
    				l->length--;
    				cout << "删除成功" << endl;
    			}
    		}
    	}
    }
    
    void printlist(sqlist *l)//打印函数
    {
    	if (l->length<0 || l->length>MAX)
    	{
    		cout << "不存在该顺序表" << endl;
    	}
    	else
    	{
    		for (int i = 0; i < l->length; i++)
    		{
    			cout << i+1 << "位置:" << l->data[i] << endl;
    		}
    	}
    }
    
    void memu()
    {
    	cout << "1.初始化顺序表  2.添加顺序表数据" << endl;
    	cout << "3.求顺序表长度  4.查找顺序表数据" << endl;
    	cout << "5.插入数据      6.删除顺序表数据" << endl;
    	cout << "            0.退出              " << endl;
    }
    
    int main()
    {
    	memu();
    	int choice;
    	sqlist l;
    	while (1)
    	{
    		cout << "请输入选择";
    		cin >> choice;
    		switch (choice)
    		{
    		case 1:
    			initlist(&l);
    			printlist(&l);
    			break;
    		case 2:
    			addlist(&l);
    			printlist(&l);
    			break;
    		case 3:
    			lenlist(&l);
    			printlist(&l);
    			break;
    		case 4:
    			searchlist(&l);
    			printlist(&l);
    			break;
    		case 5:
    			insertlist(&l);
    			printlist(&l);
    			break;
    		case 6:
    			dellist(&l);
    			printlist(&l);
    			break;
    		case 0:
    			exit(0);
    		}
    	}
    }
    

    链表

    #include<iostream>
    using namespace std;
    
    typedef struct node
    {
    	int data;//数据域
    	struct node* next;//指针域
    }node,*linklist;
    
    void initlist(linklist&l)//初始化单链表
    {
    	l = new node;
    	if (l->next == NULL)
    	{
    		cout<<"初始化失败"<<endl;
    	}
    	else
    	{
    		l->next = NULL;
    		cout<<"初始化成功"<<endl;
    	}
    }
    
    void headinsertlist(linklist l)//头插法
    {
    	cout<<"请输入十个数据:"<<endl;
    	for (int i = 0; i < 10; i++)
    	{
    		linklist p = new node;
    		p->next = NULL;
    		cin >> p->data;
    		p->next = l->next;
    		l->next = p;
    	}
    }
    
    void rearinsertlist(linklist l)//尾插法
    {
    	linklist rear = l;
    
    	cout << "请输入十个数据:" << endl;
    	for (int i = 0; i < 10; i++)
    	{
    		linklist p = new node;
    		p->next = NULL;
    		cin >> p->data;
    		rear->next=p;
    		rear=p;
    	}
    }
    
    void showlist(linklist l)//遍历
    {
    	linklist p = l->next;
    	while (p != NULL)
    	{
    		cout <<p->data << " ";
    		p = p->next;
    	}
    	cout<<"遍历完成"<<endl;
    	cout << endl;
    }
    
    void insertlist(linklist l)//插入
    {
    	linklist p = l;
    	int i, x,count=0;
    	cout<<"请输入要在第i结点插入的数字x"<<endl;
    	cin >> i >> x;
    	if (l == NULL)
    		cout<<"单链表未创建"<<endl;
    	else
    	{
    		while (p!=NULL && count < i - 1)
    		{
    			p = p->next;
    			count++;
    		}
    		linklist q = new node;
    		q->next = NULL;
    		q->data = x;
    		q->next = p->next;
    		p->next = q;
    	}
    }
    
    void dellist(linklist l)//删除某个结点
    {
    	linklist p = l;
    	linklist q = l;
    	int i,j=0;
    	cout<<"请输入要删除的第i个结点"<<endl;
    	cin >> i;
    	while (p!=NULL&&j<i-1)
    	{
    		p = p->next;
    		j++;
    	}
    	q = p->next;
    	p->next = q->next;		
    	delete q;
    }
    
    void DELlist(linklist l)//删除元素
    {
    	int x;
    	cout<<"请输入要删除的元素x"<<endl;
    	cin >> x;
    	linklist p = l->next;
    	linklist q = l;
    	while(p != NULL)
    	{
    		if (p->data == x)
    		{
    			q->next = p->next;
    			q = p;
    			p = p->next;
    			delete q;
    			linklist q=p;
    		}
    		q = p;
    		p = p->next; 
    	}
    	cout<<"删除完成"<<endl;
    }
    
    
    void sortlist(linklist l)//排序单链表元素
    {
    	linklist p,q;
    	int i, j;
    	for (p = l->next; p != NULL;p = p->next)
    	{
    		for (q = p->next; q != NULL; q = q->next)
    		{
    			if (p->data < q->data)
    			{
    				int t = p->data;
    				p->data = q->data;
    				q->data = t;
    			}
    		}
    	}
    }
    
    void clearlist(linklist &l)//销毁
    {
    	linklist p = l;
    	linklist q = l;
    	while (p!=NULL)
    	{
    		q=p;
    		p = p->next;
    		delete q;
    	}
    	cout<<"释放完成"<<endl;
    }
    
    void emptylist(linklist &l)//置空
    {
    	linklist p = l;
    	linklist q = l;
    	while (p != NULL)
    	{
    		q = p;
    		p = p->next;
    		delete q;
    	}
    	l->next = NULL;
    	cout << "置空完成" << endl;
    }
    
    void menu()
    {
    	cout<<"1.初始化   2.头插"<<endl;
    	cout<<"3.尾插     4.插入"<<endl;
    	cout<<"5.删除     6.显示"<<endl;
    	cout<<"7.销毁     8.置空"<<endl;
    	cout<<"9.排序     10.删除元素"<<endl;
    }
    
    int main()
    {
    	menu();
    	linklist l=NULL;
    	int choice;
    	while (1)
    	{
    		cout << "请输入您的选择:";
    		cin >> choice;
    		switch (choice)
    		{
    		case 1:
    			initlist(l);
    			break;
    		case 2:
    			headinsertlist(l);
    			showlist(l);
    			break;
    		case 3:
    			rearinsertlist(l);
    			showlist(l);
    			break;
    		case 4:
    			insertlist(l);
    			showlist(l);
    			break;
    		case 5:
    			dellist(l);
    			showlist(l);
    			break;
    		case 6:
    			showlist(l);
    			break;
    		case 7:
    			clearlist(l);
    			break;
    		case 8:
    			emptylist(l);
    			break;
    		case 9:
    			sortlist(l);
    			showlist(l);
    			break;
    		case 10:
    			DELlist(l);
    			showlist(l);
    			break;
    		}
    	}
    }
    

    顺序栈

    #include<iostream>
    using namespace std;
    
    #define MAX 100
    
    typedef struct stack
    {
    	int* top;//栈顶指针 指向最后一个元素上方
    	int* base;//栈底指针 指向第一个元素
    	int data;
    }stack;
    
    void initstack(stack& s)//初始化
    {
    	s.base = new int[MAX];//从内存中分配MAX个数组空间 让base指向这个空间
    	if (s.base == 0)
    		cout<<"存储分配失败"<<endl;
    	s.top = s.base;//栈顶指针指向栈底指针  此时没有元素
    	s.data = MAX;
    	cout<<"初始化成功 "<<endl;
    }
    
    void isempty(stack s)
    {
    	if (s.base == s.top)
    		cout <<"为空" <<endl;
    	else
    		cout<<"不为空"<<endl;
    }
    
    void isfull(stack s)
    {
    	if(s.top-s.base==MAX)
    		cout << "栈满" << endl;
    	else
    		cout << "栈未满" << endl;
    }
    
    void lenstack(stack s)
    {
    	cout <<"栈元素个数为:"<< s.top - s.base << endl;;//指针相减是两者之间的数量 也就是元素个数
    }
    
    void clearstack(stack &s)//清空顺序栈
    {
    	s.top = s.base;//让他俩指向一个地方就相当于没元素了
    	cout << "清空成功" << endl;
    }
    
    void destroystack(stack& s)//销毁  和清空区别就是啥都没了
    {
    	if (s.base)
    		s.data = 0;
    	s.base = s.top = NULL;
    	cout << "销毁成功" << endl;
    }
    
    void pushstack(stack &s)//进栈
    {
    	int x;
    	cout << "请输入要进栈的元素x:" << endl;
    	cin >> x;
    	if (s.top - s.base == MAX)
    		cout<<"栈已满"<<endl;
    	//*s.top++;  一步拆成两步
    	*s.top = x;
    	s.top++;
    	cout << "进栈成功" << endl;
    }
    
    void popstack(stack& s)//出栈
    {
    	int x;
    	if (s.base == s.top)
    		cout<<"栈空"<<endl;
    	s.top--;
    	x = *s.top;
    	cout << "出栈成功" << endl;
    }
    
    void showstack(stack s)
    {
    	while (s.top - s.base>0)
    	{
    		cout << *(--s.top) << endl;
    	}
    }
    
    void menu()
    {
    	cout << "1.初始化    2.是否空 " << endl;
    	cout << "3.是否满    4.元素个数 " << endl;
    	cout << "5.清空      6.销毁 " << endl;
    	cout << "7.进栈      8.出栈 " << endl;
    	cout << "9.显示栈元素       " << endl;
    }
    
    int main()
    {
    	stack s;
    	menu();
    	int choice;
    	while (1)
    	{
    		cout << "请输入您的选择:" << endl;
    		cin >> choice;
    		switch (choice)
    		{
    		case 1:
    			initstack(s);
    			break;
    		case 2:
    			isempty(s);
    			break;
    		case 3:
    			isfull(s);
    			break;
    		case 4:
    			lenstack(s);
    			break;
    		case 5:
    			clearstack(s);
    			showstack(s);
    			lenstack(s);
    			break;
    		case 6:
    			destroystack(s);
    			showstack(s);
    			lenstack(s);
    			break;
    		case 7:
    			pushstack(s);
    			showstack(s);
    			lenstack(s);
    			break;
    		case 8:
    			popstack(s);
    			showstack(s);
    			lenstack(s);
    			break;
    		case 9:
    			showstack(s);
    			break;
    		}
    	}
    }
    

    链栈

    #include<iostream>
    using namespace std;
    
    typedef struct stack
    {
    	int data;
    	struct stack* next;
    }stack, * linkstack;
    
    void initstack(linkstack& s)
    {
    	s = new stack;
    	if (!s)
    		cout<<"内存分配失败"<<endl;
    	s->next = NULL;
    	cout << "初始化成功" << endl;
    }
    
    void isempty(linkstack &s)
    {
    	if (s->next == NULL)
    		cout<<"链栈为空"<<endl;
    	else
    		cout << "链栈不为空" << endl;
    }
    
    void pushlinkstack(linkstack& s)
    {
    	int x;
    	cout << "请输入要入栈的数据x:" << endl;
    	cin >> x;
    	linkstack p = new stack;
    	if (!p)
    		cout<<"内存分配失败"<<endl;
    	p->data = x;
    	p->next = s;//s是栈顶
    	s = p;//栈顶指针上移
    	cout << "入栈成功" << endl;
    }
    
    void poplinkstack(linkstack& s)
    {
    	int x;
    	if(s->next==NULL)
    		cout << "栈为空 不能出栈" << endl;
    	else
    	{
    		x = s->data;//出栈后存储这个数据
    		linkstack p = s;//建立新结点方便删除这个结点
    		s = s->next;//让栈顶指针下移
    		delete p;//删除原本的栈顶指针
    		cout << "出栈成功" << endl;
    	}
    }
    
    void lenlinkstack(linkstack &s)
    {
    	int sum=0;
    	linkstack p = s->next;
    	while (p)
    	{
    		p = p->next;
    		sum++;
    	}
    	cout << "链栈元素个数为:" << sum << endl;;
    }
    
    void showlinkstack(linkstack &s)
    {
    	linkstack p = s;
    	while (p->next)
    	{
    		cout << p->data << endl;
    		p = p->next;
    	}
    }
    
    void clearlinkstack(linkstack& s)
    {
    	while (s->next != NULL)
    	{
    		poplinkstack(s);
    	}
    	cout<<"清空成功"<<endl;
    }
    
    void destroylinkstack(linkstack& s)
    {
    	while (s->next != NULL)
    	{
    		poplinkstack(s);
    	}
    	delete s;
    	s = NULL;
    	cout<<"销毁成功"<<endl;
    }
    
    void menu()
    {
    	cout << "1.初始化    2.栈是否空" << endl;
    	cout << "3.入栈      4.出栈" << endl;
    	cout << "5.显示元素  6.元素个数" << endl;
    	cout << "7.清空      8.销毁" << endl;
    }
    
    int main()
    {
    	menu();
    	linkstack s;
    	int choice;
    	while (1)
    	{
    		cout << "请输入您的选择:" << endl;
    		cin >> choice;
    		switch (choice)
    		{
    		case 1:
    			initstack(s);
    			break;
    		case 2:
    			isempty(s);
    			lenlinkstack(s);
    			break;
    		case 3:
    			pushlinkstack(s);
    			showlinkstack(s);
    			lenlinkstack(s);
    			break;
    		case 4:
    			poplinkstack(s);
    			showlinkstack(s);
    			lenlinkstack(s);
    			break;
    		case 5:
    			showlinkstack(s);
    			lenlinkstack(s);
    			break;
    		case 6:
    			lenlinkstack(s);
    			break;
    		case 7:
    			clearlinkstack(s);
    			break;
    		case 8:
    			destroylinkstack(s);
    			break;
    		}
    	}
    }
    

    顺序队列

    #include<iostream>
    using namespace std;
    
    #define MAX 100
    
    typedef struct queue
    {
    	int* base;
    	int front;//头下标
    	int rear;//尾下标
    }queue;
    
    
    void initqueue(queue& q)
    {
    	q.base = new int[MAX];
    	if (!q.base)
    		cout<<"内存分配失败"<<endl;
    	q.front = q.rear=0;
    	cout<<"初始化成功"<<endl;
    }
    
    void lenqueue(queue q)
    {
    	int len;
    	len = (q.rear - q.front + MAX) % MAX;
    	cout << "元素个数为:" << len << endl;
    }
    
    void pushqueue(queue &q)
    {
    	int x;
    	cout<<"请输入要入队的元素x:"<<endl;
    	cin >> x;
    	if ((q.rear + 1) % MAX == q.front)
    		cout<<"队列已满"<<endl;
    	q.base[q.rear] = x;
    	q.rear = (q.rear + 1) % MAX;
    	cout<<"入队成功"<<endl;
    }
    
    void popqueue(queue& q)
    {
    	int x;
    	if (q.front == q.rear)
    		cout<<"队列为空"<<endl;
    	x = q.base[q.front];
    	q.front = (q.front + 1) % MAX;
    	cout<<"出队成功"<<endl;
    }
    
    void gettopqueue(queue q)//获取队头元素和出队的区别就是  获取元素之后 队的元素还在里面 所以坐标位置不动  但是出队需要改变坐标位置
    {
    	int x;
    	if (q.front != q.rear)
    		x = q.base[q.front];
    	cout<<"获取队头元素成功"<<endl;
    }
    
    void showqueue(queue& q)
    {
    	if (q.front == q.rear)
    		cout<<"队列为空"<<endl;
    	else
    	{
    		int i = q.front;
    		while (i != q.rear)
    		{
    			cout << q.base[i] << endl;;
    			i = (i + 1) % MAX;
    		}
    	}
    }
    
    void menu()
    {
    	cout<<"1.初始化       2.元素个数"<<endl;
    	cout<<"3.入队         4.出队"<<endl;
    	cout<<"5.获取头元素   6.遍历队列  "<<endl;
    
    }
    
    
    
    int main()
    {
    	menu();
    	queue q;
    	int choice;
    	while (1)
    	{
    		cout<<"请输入您的选择:"<<endl;
    		cin >> choice;
    		switch (choice)
    		{
    		case 1:
    			initqueue(q);
    			break;
    		case 2:
    			lenqueue(q);
    			break;
    		case 3:
    			pushqueue(q);
    			showqueue(q);
    			lenqueue(q);
    			break;
    		case 4:
    			popqueue(q);
    			showqueue(q);
    			lenqueue(q);
    			break;
    		case 5:
    			gettopqueue(q);
    			break;
    		case 6:
    			showqueue(q);
    			break;
    		}
    	}
    }
    

    链队列

    #include<iostream>
    using namespace std;
    
    #define MAX 100
    
    typedef struct queue
    {
    	int data;
    	struct queue* next;
    }queue,*queueptr;
    
    typedef struct
    {
    	struct queue* front;//queueptr front
    	struct queue* rear;
    }linkqueue;
    
    void initqueue(linkqueue& q)
    {
    	q.front = q.rear = new queue;//指向同一块结点
    	if (!q.front)
    		cout<<"内存分配失败"<<endl;
    	q.front->next = NULL;
    	cout<<"初始化成功"<<endl;
    }
    
    void destroyqueue(linkqueue& q)
    {
    	while (q.front)
    	{
    		//q.front指向的是struct queue型
    		queueptr p = q.front->next;//新建一个结点指向头结点下一个
    		delete q.front;//删除头结点
    		q.front = p;//实现原先的头结点后移
    	}
    }
    
    void pushqueue(linkqueue& q)
    {
    	int x;
    	cout<<"请输入要入队的数据x:"<<endl;
    	cin >> x;
    	queueptr p=new queue;//新建一个结点
    	if (!p)
    		cout<<"分配结点失败"<<endl;
    	p->data = x;
    	p->next = NULL;//习惯
    	q.rear->next = p;//让rear指向插入的结点
    	q.rear = p;//rear指针后移
    	cout<<"入队成功"<<endl;
    }
    
    void popqueue(linkqueue& q)
    {
    
    	int x;
    	if (q.front == q.rear)
    		cout<<"队列为空"<<endl;
    	x = q.front->next->data;
    	queueptr p = q.front->next;//让一个指针指向要出队的结点
    	q.front->next = p->next;//让头结点指向出队结点的后面一个结点
    	if (q.rear == p)//最后一个元素出队 rear指向头结点
    		q.rear = q.front;
    	delete p;
    	cout<<"出队成功"<<endl;
    }
    
    void gettopqueue(linkqueue& q)
    {
    	int x;
    	if (q.front == q.rear)
    		cout << "队列为空" << endl;
    	x = q.front->next->data;
    	cout<<"队头元素为:"<<x<<endl;
    }
    
    void showqueue(linkqueue& q)
    {
    	if (q.front == q.rear)
    		cout<<"队列为空"<<endl;
    	queueptr p = q.front->next;
    	while (p)
    	{
    		cout << p->data;
    		p = p->next;
    	}
    	cout<<"遍历完成"<<endl;
    }
    
    void lenqueue(linkqueue& q)
    {
    	int sum = 0;
    	queueptr p = q.front->next;
    	while (p)
    	{
    		sum++;
    		p = p->next;
    	}
    	cout<<"队列元素个数为:"<<sum<<endl;
    }
    
    void clearqueue(linkqueue& q)
    {
    	queueptr p = q.front->next;
    	while (p)
    	{
    		q.front = p->next;
    		delete p;
    		p = q.front;
    	}
    	cout<<"清空成功"<<endl;
    	delete q.front;
    	cout<<"销毁成功"<<endl;
    }
    
    void menu()
    {
    	cout<<"1.初始化    2.入队"<<endl;
    	cout<<"3.出队      4.队头元素"<<endl;
    	cout<<"5.遍历      6.元素个数"<<endl;
    	cout<<"7.清空销毁            "<<endl;
    }
    
    int main()
    {
    	menu();
    	int choice;
    	linkqueue q;
    	while (1)
    	{
    		cout<<"请输入您的选择:"<<endl;
    		cin >> choice;
    		switch (choice)
    		{
    		case 1:
    			initqueue(q);
    			break;
    		case 2:
    			pushqueue(q);
    			break;
    		case 3:
    			popqueue(q);
    			break;
    		case 4:
    			gettopqueue(q);
    			break;
    		case 5:
    			showqueue(q);
    			break;
    		case 6:
    			lenqueue(q);
    			break;
    		case 7:
    			clearqueue(q);
    			break;
    		}
    	}
    }
    

    作者:吕文康
    学校:山东第一医科大学
    2020.1.22

    展开全文
  • 数据结构二叉树功能展示包括以完全前序序列创建二叉树"; cout以前序和中序序列创建二叉树"; cout前序遍历二叉树"; cout中序遍历二叉树"; cout后序遍历二叉树"; cout广度优先遍历二叉树"; cout求某结点的双亲";...
  • C++自定义数据结构

    2019-10-04 16:35:54
    C++自定义数据结构 #include <iostream> void selfDefinedDataStructure() { std::cout << "自定义数据结构:" << std::endl; // 自定义Sales_data数据类型 // struct + 类名 + 类体 // 类...

    C++自定义数据结构

    #include <iostream>
    
    void selfDefinedDataStructure() {
    	std::cout << "自定义数据结构:" << std::endl;
    
    	// 自定义Sales_data数据类型
    	// struct + 类名 + 类体
    	// 类体中定义类的“成员”,次数的“成员”只有数据成员(data member)
    	// 每个类的成员可以提供一个“类内初始值”(in-class initializer),不提供初始值的,默认初始化。
    	struct Sales_data
    	{
    		std::string bookNo;
    		unsigned units_sold = 0;
    		double revenue = 0.0;
    	};
    
    	Sales_data sale_data1, sale_data2;
    	double price = 0;
    	std::cout << "读书图书编号、销售量、单价" << std::endl;
    	
    	std::cin >> sale_data1.bookNo >> sale_data1.units_sold >> price;
    	sale_data1.revenue = sale_data1.units_sold * price;
    	std::cout << "sale_data1.revenue: " << sale_data1.revenue << std::endl;
    	
    	std::cin >> sale_data2.bookNo >> sale_data2.units_sold >> price;
    	sale_data2.revenue = sale_data2.units_sold * price;
    	std::cout << "sale_data2.revenue: " << sale_data2.revenue << std::endl;
    
    	if (sale_data1.bookNo == sale_data2.bookNo) {
    		unsigned totalCnt = sale_data1.units_sold + sale_data2.units_sold;
    		double totalRevenue = sale_data1.revenue + sale_data2.revenue;
    		// 输出图书编号、总销量、总销售额、平均价格
    		std::cout << sale_data1.bookNo << " " << totalCnt << " " << totalRevenue << " ";
    		if (totalCnt != 0) {
    			std::cout << totalRevenue / totalCnt << std::endl;
    		}
    		else {
    			std::cout << "(no sales)" << std::endl;
    		}
    	}
    	else {
    		std::cerr << "Data must refer to the same ISBN" << std::endl;
    	}
    }
    
    展开全文
  • 数据结构总结

    2014-08-24 22:02:17
    1.前缀转后缀 将数字直接输出 碰到字符进行比较 栈内的和刚得到的运算符比较 栈内的小,新运算符进栈case ...2.递归的数据结构 //Declaration typedef struct BinTreeNode { DataType data; struct B
  • C++数据结构笔记

    2021-04-20 16:51:44
    C++数据结构与算法1.顺序表 1.顺序表 #include <iostream> #include <cstring> using std::cout; using std::endl; template <typename Type> class Vector { private: int size, length; Type ...
  • 数据结构刷题

    2021-02-05 15:33:30
    1.输出数字要后面小数 #include cout<<fixed<<setprecision(2)<<a<<endl;//输出a,保留两位小数
  • 预备知识基础 已学过C 程序设计这门课程并掌握数据类型表达式基本控制结构顺序分支和循环数组指针函数以及输入输出等内容数据结构课程需要扩充的知识1 C++的不同的表示2自定义数据类型结构体枚举类型联合体3 复习...
  • 数据结构 查找

    2021-05-20 19:53:08
     cout<<"yes";  break;  }  p=p->next;  }  if(p->next=NULL)  cout<<"no";  } private:  struct Node...
  • 递归的概念;定义是递归的;...数据结构是递归的;在链表中寻找等于给定值的结点 并打印其数值 template <class Type> void Print ( ListNode<Type> *f ) { if ( f != NULL) if ( f data == x ) cout ; else Print
  • 机票系统 数据结构

    2013-07-02 13:48:40
    cout剩余票数小于订票数,是否需要列入候补名单?(1、是 2、否)"; cin>>n; Buyreplace(q,Ticket_Amount,n);//进入替补名单 } cout、返回菜单 2、继续"; cin>>i; } } } } void BuyTicket(Flight *q, int ...
  • 数据结构中我们经常要用到很多预定义的常量,如果每次自己输入,那就比较麻烦啦,在这里,给大家把常用的预定义常量分享出来,下次再用到,直接复制粘贴就好啦。 一、常用头文件 首先自然是常用头文件,因为作者是...
  • 初学数据结构

    2020-06-22 20:04:25
    #include using namespace std; typedef int Type; struct TestList{  Type element;  TestList* next; }; int main() ...cout<<“输入头结点一个值(int):”;  cin>>head-&
  • c++数据结构

    2020-04-18 16:04:12
    string类: 字符串拼接: string类型的字符串可以通过"+“进行拼接,同时char类和string类也可以通过”+"进行连接。 #include<iostream> using namespace std; ... cout<<x+y+z&l...
  • PTA数据结构题目

    万次阅读 多人点赞 2020-05-06 17:48:57
    程序填空题 5-1 打印“Hello World!”,占一行。 #include <... cout<<"Hello World!"<<endl; return 0; } 5-2 下列代码的功能是返回带头结点的单链表L的逆转链表。 List Reverse( Lis...
  • OpenCV——数据结构

    2020-10-03 09:56:41
    OpenCV数据结构自动管理内存 Mat类型复制拷贝操作只对信息头操作,只有clone()和copyTo是再开阔一片内存进行矩阵存储 Mat对象创建的七种方法 1、Mat()构造函数 Mat M(2,2,CV_8UC3,Scalar(0,0,255)); cout << ...
  • #include <iostream> using namespace std; int main() { int array[3] = {5, 8, 6};... cout << "i " << i << endl; for (int j = 0; j < 3 - i - 1; j++) { cout <
  • 数据结构

    2009-11-16 11:20:00
    0,算法对数据结构的要求1,hash2,heap : bin-heap, binomial-heap, fibonacci-heap,3,tree : 各种奇形怪状的树 有时间写,先充实下内容。 // a binary-heap implementation#include #include using std::cout...
  • 数据结构学习笔记

    2018-06-04 21:28:11
    这段时间开始复习数据结构,疯狂恶补相关知识,做了一些笔记。1、构造函数,是一种特殊的方法。主要用来在创建对象时初始化对象,即为对象成员变量赋初值,总与new运算符一起运用在创建对象的语句中。特别的事,一个...
  • 数据结构笔记

    2016-10-27 14:54:00
    链表 #include using namespace std; struct stNode { int data; stNode *next; }; void output(stNode *p,int n) { stNode *current = p->next; for (int i = 0;... cout data; current = curre
  • 第六章 模板与数据结构;void main){ int a,b,c; double x,y,z; char s1[20],s2[20],s3[20]; //读入数据 cout(a,b,c; cout(x,y,z; cout(s1,s2,s3; } 如何完成此要求;参数化程序设计;模板 数据类型参数化实现通用性;...
  • 数据结构类型

    2016-11-07 21:26:00
    点:Point类 Point、Point2i、Point_<int>等价 Point2f、Point_<float>等价 用法: ... cout<<"p="<<endl<<p<<";"<<endl; //三维点 Point3f...
  • 数据结构之排序

    2020-02-15 21:49:06
    #include<iostream> using namespace std; /*直接输出*/ void output(int a[]) { for(int i=0;i<... cout<<a[i]<<" "; } cout<<endl; } /*直接插入排序*/ void I...
  • int Creat(Sqlist &L, int a[], int n)//顺序表的创建 { int i; if (n ) { for (i = 0; i; i++) { L.data[i] = a[i]; L.length++; } return 1; } ... cout [i] ; } cout ; return 0; }
  • 数据结构–顺序表函数 数据结构线性表–顺序表常用函数 1、 创建有n个元素构成的线性表: Status CreatAscend(LinkList &L,int n) { int j; LinkList p,q,s; if(n<=0) return ERROR; InitList(L); ...
  • 操纵子(Manipulator) 也称操作符, 是一种功能和类 ios_base的成员函数相同, 但使用更方便的格式控制函数,程序员可以直接在输出流中插人操纵子控制程序的输出格式,既简化了程序的编写,又使程序的结构变得更清晰...
  • 数据结构 单链表程序

    2011-06-20 16:05:27
    cout请输入线性表中元素的个数!"; cin>>n; cout请输入线性表中每个元素!"; for(i=0;i;i++) {cout请输入第"个元素!"; cin>>r[i]; } LinkList<int> b(r,n); //根据数组创建单链表 cout单链表b为:"; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,190
精华内容 476
关键字:

数据结构cout

数据结构 订阅