投稿
  1. 首页
  2. 软件运维

程序设计C＋＋题

项目经理职责 • 2023-5-26 • 软件运维 • 阅读 10

程序设计C＋＋题,第1张

class queue包含7个方法：

1.queue()不带任何早袭参数的构造函数，构造一个空队列

2.queue(const queue &a)拷贝构造函数，构造一个与a相同的队列

3.int EnQueue(int a)将元素a入队，成功返回a值，失败返回-1

4.int DeQueue()将首元素出对，成功返回则睁凳首元素值，失败返回-1

5.int IsEmpty()检查队列是否为空，若空返回1，非空返回0

6.int Clear()清空队列中所有元素，返回1

7.int GetLength() 返回队列长度，孙旅若队列空则返回0

代码：

struct NODE

{

int element

NODE *behind

}

class queue

{

protected:

int count

NODE *top,*bottom

public:

queue()

{top=bottom=NULLcount=0}

queue(const queue &)

int EnQueue(int)

int DeQueue()

int IsEmpty()

int Clear()

int GetLength()

}

queue::queue(const queue &a)

{

top=bottom=NULL

count=0

if(a.count!=0)

{

NODE *temp=a.top

while(temp)

{

(*this).EnQueue(temp->element)

temp=temp-

>behind

}

}

}

int queue::EnQueue(int a)

{

if(top==NULL)

{

top=bottom=new(NODE)

if(!top)return -1

top->behind=NULL

top->element=a

count++

}

else

{

bottom->behind=new

(NODE)

if(!bottom->behind)

return -1

bottom=bottom->behind

bottom->element=a

bottom->behind=NULL

count++

}

return a

}

int queue::DeQueue()

{

if(top==NULL)

return -1

else

{

NODE *temp=top

int result=temp->element

top=temp->behind

delete (temp)

count--

if(count==0)bottom=NULL

return result

}

}

int queue::IsEmpty()

{

if(count==0)return 1

elsereturn 0

}

int queue::Clear()

{

while(top!=bottom)

{

NODE *temp=top

top=temp->behind

delete temp

}

delete top

top=bottom=NULL

count=0

return 1

}

int queue::GetLength()

{

return count

}

这个程序是实现将一个二叉树安装左序优先的顺序存放在一个顺序数组中

void level(const tree *tp){ //tp指针明斗给定一个二叉树根节点

Node *queue[8]//保存各节点指针的顺序数组, 程序中默认节点数小于8

int front,rear//当前处理节点位置和当前保存节点位置

front=rear=0//当前queue中没有待处理节点

queue[rear++]=*tp//根节点指针存放到queue[0]位置

while(front<rear){ //如果数组中仍有待处理节点则继续循环,结束循环:二叉树节点均处理完毕穗槐州

printf("%c",queue[front]->data)//输出正在处理的节点数据猜蔽内容

if(queue[front]->lchild ) //如果当前节点有左侧子节点

queue[rear++]=queue[front]->lchild//将有效左侧子节点存入数组

if(queue[front]->rchild ) //如果当前节点有右侧子节点

queue[rear++]=queue[front]->rchild//将这个有效的右侧子节点存入数组

front++//处理下一个待处理节点(肯定是前面节点的子节点,左侧子节点存放在前)

}

}

FIFO的方法用下边的Queue改写一下。

//////////////旁则/////// Queue.h //////////////////////////////

#ifndef QUEUE_H

#define QUEUE_H

namespace MyLibrary

{

#define MYLIBRARY_DEBUG

// MYLIBRARY_DEBUG 为测试而用

#ifdef MYLIBRARY_DEBUG

#include <iostream>

using std::ostream

#endif

/// type def

#ifndef FALSE

#define FALSE false

#endif

#ifndef TRUE

#define TRUE true

#endif

typedef size_t size_type

typedef bool BOOL

/// 声明

template <typename _Ty>class Queue

#ifdef MYLIBRARY_DEBUG

template <typename _Ty>

ostream &operator <<( ostream &, const Queue<_Ty>&)

#endif

///////////////枝启扮///////// class ////////////////猛灶////////////

template <typename _Ty>

class Queue

{

//友元声明

#ifdef MYLIBRARY_DEBUG

friend ostream &operator <<<>( ostream &, const Queue<_Ty>&)

#endif

private:

//嵌套类定义

class QueueItem

{

public:

QueueItem( _Ty data ):_prior(0),_next(0),_data(data){}

public:

QueueItem * _prior//前向指针

QueueItem * _next//后向指针

_Ty _data//数据

}

private:

//数据集

typename Queue<_Ty>::QueueItem * _head//头结点指针

typename Queue<_Ty>::QueueItem * _tail//尾结点指针

size_type _size//长度

static const _Ty _temp//只做空数据

public:

//构造析构集...

inline Queue():_head(0),_tail(0),_size(0){}

inline Queue( const Queue<_Ty>&)

inline ~Queue(){ while( !empty() )del()}

public:

//外部 *** 作接口集

inline const size_type size ( void ) const

inline const BOOL empty ( void ) const

inline const Queue &add ( const _Ty &)

inline const BOOL del ( void )

inline const BOOL del ( _Ty &)

inline const _Ty &get ( void )const

public:

//重载 *** 作符集

inline const Queue<_Ty>&operator = ( const Queue<_Ty>&)

inline const Queue<_Ty>&operator += ( const Queue<_Ty>&)

inline const Queue<_Ty>&operator += ( const _Ty &)

inline const Queue<_Ty>operator + ( const Queue<_Ty>&)

inline const Queue<_Ty>operator + ( const _Ty &)

inline const BOOL operator == ( const Queue<_Ty>&)const

inline const BOOL operator != ( const Queue<_Ty>&)const

}

template <typename _Ty>

inline const Queue<_Ty>

Queue<_Ty>::operator + ( const _Ty &value )

{

Queue<_Ty>temp = *this

return temp+=value

}

template <typename _Ty>

inline const Queue<_Ty>&

Queue<_Ty>::operator += ( const _Ty &value )

{

this->add( value )

return * this

}

template <typename _Ty>

inline const Queue<_Ty>

Queue<_Ty>::operator + ( const Queue<_Ty>&queue )

{

// q=q1+q2

if( queue.empty() )

{

return * this

}

else

{

Queue<_Ty>temp = *this

return temp += queue

}

}

template <typename _Ty>

inline const Queue<_Ty>&

Queue<_Ty>::operator += ( const Queue<_Ty>&queue )

{

if( ! queue.empty() )

{

for( const typename Queue<_Ty>::QueueItem * it = queue._head

it != queue._tail

it = it->_prior )

{

this->add( it->_data )

}

this->add( queue._tail->_data )

}

return * this

}

template <typename _Ty>

inline const BOOL

Queue<_Ty>::operator != ( const Queue<_Ty>&queue )const

{

if( queue.size() != this->size() )

{

return TRUE

}

else

{

const typename Queue<_Ty>::QueueItem * youit = queue._tail

const typename Queue<_Ty>::QueueItem * myit = this->_tail

for(myit != this->_headmyit=myit->_next,youit=youit->_next)

{

if( myit->_data != youit->_data )

{

return TRUE

}

}

return (queue._head->_data != this->_head->_data)?TRUE:FALSE

}

}

template <typename _Ty>

inline const BOOL

Queue<_Ty>::operator == ( const Queue<_Ty>&queue )const

{

if( queue.size() != this->size() )

{

return FALSE

}

else

{

const typename Queue<_Ty>::QueueItem * youit = queue._tail

const typename Queue<_Ty>::QueueItem * myit = this->_tail

for(myit != this->_headmyit=myit->_next,youit=youit->_next)

{

if( myit->_data != youit->_data )

{

return FALSE

}

}

return (queue._head->_data != this->_head->_data)?FALSE:TRUE

}

}

template <typename _Ty>

inline const Queue<_Ty>&

Queue<_Ty>::operator = ( const Queue<_Ty>&queue )

{

if( &queue == this )

{

return *this

}

else

{

while( ! this->empty() )

{

this->del()

}

for( const typename Queue<_Ty>::QueueItem * it = queue._head

it != queue._tail

it = it->_prior )

{

this->add( it->_data )

}

this->add( queue._tail->_data )

return * this

}

}

template <typename _Ty>

const _Ty Queue<_Ty>::_temp = _Ty()

template <typename _Ty>

inline const _Ty &

Queue<_Ty>::get( void )const

{

if( this->empty() )

return _temp//返回表的空数据

else

{

return this->_head->_data

}

}

template <typename _Ty>

inline const BOOL

Queue<_Ty>::del( void )

{

if( this->empty() )

return FALSE

else

{

const typename Queue<_Ty>::QueueItem * temp = _head

_head = _head->_prior

--_size

delete temp

return TRUE

}

}

template <typename _Ty>

inline const BOOL

Queue<_Ty>::del( _Ty &value )

{

if( this->empty() )

return FALSE

else

{

const typename Queue<_Ty>::QueueItem * temp = _head

value = temp->_data

_head = _head->_prior

--_size

delete temp

return TRUE

}

}

template <typename _Ty>

inline const size_type

Queue<_Ty>::size(void)const

{

return _size

}

template <typename _Ty>

inline const BOOL

Queue<_Ty>::empty( void )const

{

return (_size)?FALSE:TRUE

}

template <typename _Ty>

inline const Queue<_Ty>&

Queue<_Ty>::add( const _Ty &value )

{

typename Queue<_Ty>::QueueItem * temp =

new typename Queue<_Ty>::QueueItem( value )

if( empty() )

{

_head = _tail = temp

++_size

}

else

{

temp->_next = _tail

_tail->_prior = temp

_tail = temp

++_size

}

return *this

}

template <typename _Ty>

inline Queue<_Ty>::Queue( const Queue<_Ty>&queue )

:_head(0),_tail(0),_size(0)

{

if( this == &queue )

return

for( const typename Queue<_Ty>::QueueItem * iter = queue._head

iter != queue._tail

iter = iter->_prior )

{

this->add( iter->_data )

}

this->add( queue._tail->_data )

return

}

#ifdef MYLIBRARY_DEBUG

template <typename _Ty>

inline ostream &operator <<( ostream &os, const Queue<_Ty>&queue )

{

os<<"Queue("<<queue.size()<<"):\n"

os<<"head--->"

if( !queue.empty() )

{

for( const typename Queue<_Ty>::QueueItem * it = queue._head

it != queue._tail

it = it->_prior )

{

os<<it->_data<<" "

}

os<<queue._tail->_data

}

os<<"<---tail\n"

return os

}

#endif

}////////// end namespace MyLibrary

#endif

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/yw/12562013.html

赞 (0)
打赏 微信扫一扫 微信扫一扫 支付宝扫一扫 支付宝扫一扫
项目经理职责 项目经理职责 一级用户组
0 0
上一篇 2023-05-26
下一篇 2023-05-26

发表评论

登录后才能评论

评论列表（0条）

保存