循环队列与链表

其他 2018-09-26 15:35:57 阅读次数: 0 
#include<iostream>
#include<cstring>

#pragma once  
//循环队列
class CircleQueue
{
public:
    CircleQueue(int size = 20);    //构造函数
    ~CircleQueue();   //析构函数
    CircleQueue(const CircleQueue &src);  //自定义构造函数（避免浅拷贝）
    void operator=(const CircleQueue &src); //自定义赋值函数（避免浅拷贝）
    void addQue(int val);  //入队
    void delQue();  //出队
    int front();  //返回队头元素
    int back();  //返回队尾元素
    bool empty();  //判断队空
    bool full(); //判断队满
    void print();//打印函数
private:
    int *_pQue;
    int _size;
    int _front;
    int _rear;
    void resize()
    {
        int *_pMQue = new int[_size * 2];
        if (_size<_rear)
        {
            memcpy(_pMQue, _pQue + _front, sizeof(int)*(_size - _front));
            memcpy(_pMQue + (_size - _front), _pQue, sizeof(int)*(_rear - _size));
            _rear = _rear - _front;
            _front = 0;
        }
        else
        {
            memcpy(_pMQue, _pQue, sizeof(int)*(_rear));
        }

        _size *= 2;
        delete[]_pQue;
        _pQue = _pMQue;
    }
};
1
实现方法CircleQueueFun.cpp
#include "CircleQueue.h"
#include<iostream>

using namespace std;
CircleQueue::CircleQueue(int size)
{
    _pQue = new int[size];
    _size = size;
    _front = 0;
    _rear = 0;
}

CircleQueue::~CircleQueue()
{
    delete[]_pQue;
    _pQue = NULL;
}
CircleQueue::CircleQueue(const CircleQueue &src)
{
    _pQue = new int[src._size];
    if (src._size<src._rear)  //表示循环队列中有循环发生
    {
        memcpy(_pQue, src._pQue + src._front, sizeof(int)*(src._size - src._front));   //先拷贝目前队列中处于非循环位置上元素  
        memcpy(_pQue + (src._size - src._front), src._pQue, sizeof(int)*(src._rear - src._size));//拷贝目前队列中处于循环位置上的元素  
        _size = src._size;
        _front = 0;
        _rear = src._rear - src._front;
    }
    else
    {
        memcpy(_pQue, src._pQue, sizeof(int)*(src._rear));
        _size = src._size;
        _front = src._front;
        _rear = src._rear;
    }
}

void CircleQueue::operator=(const CircleQueue &src)
{
    if (this == &src)
    {
        return;
    }
    delete[]_pQue;
    _pQue = new int[src._size];
    if (src._size<src._rear)
    {
        memcpy(_pQue, src._pQue + src._front, sizeof(int)*(src._size - src._front));
        memcpy(_pQue + (src._size - src._front), src._pQue, sizeof(int)*(src._rear - src._size));
        _size = src._size;
        _front = 0;
        _rear = src._rear - src._front;
    }
    else
    {
        memcpy(_pQue, src._pQue, sizeof(int)*(src._rear));
        _size = src._size;
        _front = src._front;
        _rear = src._rear;
    }
}

void CircleQueue::addQue(int val)
{
    if (full())
    {
        resize();
    }
    _pQue[(_rear) % _size] = val;
    _rear++;

}

void CircleQueue::delQue()
{
    if (empty())
    {
        return;
    }
    _front++;
}

int CircleQueue::front()
{
    return _pQue[_front];
}

int CircleQueue::back()
{
    return _pQue[_rear];
}
bool CircleQueue::empty()
{
    return (_rear - _front) == 0;
}

bool CircleQueue::full()
{
    return (_rear - _front) == _size;
}
void CircleQueue::print()
{
    for (int i = _front; i <_rear; i++)
    {
        if (i >= _size)
        {
            cout << _pQue[i%_size] << "\t";
        }
        else
        {
            cout << _pQue[i] << "\t";
        }

        if ((i - _front + 1) % 5 == 0)
            cout << endl;
    }
    cout << endl;
}
测试函数
/*
** 题目：实现循环队列
**注意点:扩容，拷贝队列时需要注意两种特殊情况的发生
*/


#include<iostream>
#include<cstring>
#include "CircleQueue.h"
#include <stdlib.h>
#include <time.h>  

using namespace std;

int main()
{
    cout << "循环队列基本操作" << endl;
    CircleQueue circlequeue(5);     //构造函数
    srand((unsigned)time(NULL));
    for (int i = 0; i < 5; i++)
    {
        circlequeue.addQue(rand());    //入队函数
    }
    circlequeue.print();  //打印函数


    for (int i = 0; i < 2; i++)
    {
        circlequeue.delQue();    //入队函数
    }
    circlequeue.print();  //打印函数


    for (int i = 0; i < 5; i++)
    {
        circlequeue.addQue(rand()); //入队函数
    }
    circlequeue.print();

    cout << "调用自定义拷贝构造函数" << endl;

    CircleQueue circlequeueTwo(circlequeue);
    circlequeueTwo.print();


    cout << "调用自定义赋值函数" << endl;
    CircleQueue circlequeueThree(5);
    circlequeueThree = circlequeue;
    circlequeueThree.print();
    for (int i = 0; i < 5; i++)
    {
        circlequeueThree.addQue(rand()); //入队函数
    }
    circlequeueThree.print();
    return 0;
}

#include<iostream>
using namespace std;
template<class T>
class sq_Queue
{
	private:
		int mm;
		int front;
		int rear;
		int s;
		T*q;
	public:
		sq_Queue(int);
		void prt_sq_Queue();
		int flag_sq_Queue();
		void ins_sq_Queue(T);
		T del_sq_Queue();
 } ;

template<class T>
 sq_Queue<T>::sq_Queue(int m)
 {
 	mm=m;
 	front = mm;
 	rear = mm;
 	s = 0;
 	return;
 }
 
 template<class T>
 void sq_Queue<T>::prt_sq_Queue()
 {
 	int i;
 	cout<<"front="<<front<<endl;
 	cout<<"rear="<<rear<<endl;
 	if(s==0) 
	 {
	 	cout<<"队列空！"<<endl;
	 	return;
	 }
	 i=front;
	 do{
	 	i+=1;
	 	if(i==mm+1) i=1;
	 	cout<<q[i-1]<<endl;
	 }while(i!=rear);
	 return;
 }
 
 template<class T>
 int sq_Queue<T>::flag_sq_Queue()
 {
 	if((s==1)&&rear==front) return -1;
 	if(s==0) return 0;
 	return 1;
 }
 
 template<class T>
 void sq_Queue<T>::ins_sq_Queue(T x)
 {
 	if((s==1)&&rear==front) 
	 {
 		cout<<"Queue_Overflow"<<endl;
 		return;
	 }
	 rear+=1;
	 if(rear=mm+1) rear=1;
	 q[rear-1]=x;
 	 s=1;
 	 return;
 }
 
 template<class T>
 T sq_Queue<T>::del_sq_Queue()
 {
 	T y;
 	if(s==0)
 	{
 		cout<<"Queue_Underflow"<<endl;
 		return 0;
	 }
	 front+=1;
	 if(front==mm+1) front=1;
	 y=q[front-1];
	 if(front==rear) s=0;
	 return y;
 }
 

#include<iostream>
using namespace std;
template<class T>
struct node{
	T d;
	node*next;
};
template<class T>
class linked_List
{
	private:
		node<T>*head; //定义头指针 
	public:
		linked_List();//初始化表
		void prt_linked_List();//扫描输出链表的元素 
		void ins_linked_List(T,T);//在包含元素x的结点前插入新元素b 
		int del_linked_List(T);
};

template<class T>
linked_List<T>::linked_List()
{
	head=NULL;return;  //建立空链表 
}

template<class T>
void linked_List<T>::prt_linked_List()
 {
 	node<T>*p;
 	p=head;
 	if(p==NULL){cout<<"空链表"<<endl;return;}
 	do{
 		cout<<p->d<<endl;
 		p=p->next;
	 }while(p!=NULL);
	 return;
	 }
	 
template<class T>
void linked_List<T>::ins_linked_List(T x,T b)
{
	node<T>*p,*q;
	p=new node<T>;
	p->d=b;
	if(head==NULL)
	{
		head=p;
		p->next=NULL;
		return;
	}
	if(head->d==x)
	{
		p->next=head;
		head=p;
		return;
	}
	q=head;
	while((q->next!=NULL)&&(((q->next)->d)!=x))
	q=q->next;
	p->next=q->next;
	q->next=p;
	return ; 
}
 
template<class T>
int linked_List<T>::del_linked_List(T x)
{
	node<T>*p,*q;
	if(head==NULL) return 0;
	if((head->d)==x)
	{
		p=head->next;
		delete head;
		head=p;
		return 1;
	}
	q=head;
	while((q->next!=NULL)&&(((q->next)->d)!=x))
	q=q->next;
	if(q->next==NULL)return 0;
	p=q->next;
	q->next=p->next;
	delete p;
	return 1;
}

猜你喜欢

转载自blog.csdn.net/qq_41879767/article/details/82765445
今日推荐
周排行
Leetcode简单题61~80
解决zookeeper磁盘IO高的问题
多线程相关方法详解
Maven-setting.xml文件详解
Maven 项目的 classpath 理解
渊亭科技大数据笔试题
配置JVM内存分配
计算机网络个人学习笔记 （三）网络层 ：第三部分 连载
js中两个等号(==)和三个等号(===)的区别
用C程序自动打开电脑上的程序
每日归档
更多
2024-09-18(0)
2024-09-17(0)
2024-09-16(0)
2024-09-15(0)
2024-09-14(0)
2024-09-13(0)
2024-09-12(0)
2024-09-11(0)
2024-09-10(0)
2024-09-09(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022