- 栈
class ArrayStack
{
private:
int *data;
int num;
int len;
public:
ArrayStack(int n)
{
data = new int[n];
num = 0;
len = n;
}
bool push(int item)
{
if(num == len)
{
return false;
}
else{
data[num] = item;
num++;
return true;
}
}
int pop()
{
if(num == 0)
{
return -1;
}
else
{
int item = data[num-1];
num--;
return item;
}
}
}
- 队列
class ArrayQueue
{
private:
int *data;
int head;
int tail;
int len;
public:
ArrayQueue(int n)
{
data = new int[n];
head = 0;
tail = 0;
len = n;
}
bool enqueue(int item)
{
if(tail == len && head == 0)
{
cout << "queue is full" << endl;
return false;
}
else
{
if(tail == len && head != 0)
{
int num = tail - head;
for(int i = 0 ; i < num ; i++)
{
data[i] = data[len - num + i];
}
}
data[tail] = item;
tail++;
return true;
}
}
int dequeue()
{
if(head == tail)
{
cout << "queue is empty" << endl;
return -1;
}
else
{
int item = data[head];
head++;
return item;
}
}
}
- 链式队列
struct linked_list
{
int data;
linked_list *next;
};
class ListQueue
{
private:
linked_list *head;
linked_list *tail;
int num;
public:
ListQueue()
{
head = new linked_list;
head->data = -1;
head->next = NULL;
tail = head;
num = 0;
}
bool enQueue(int item)
{
linked_list *node = new linked_list;
if(node)
{
node->data = item;
node->next = NULL;
tail->next = node;
tail = node;
num++;
return true;
}
else
{
return false;
}
}
int deQueue()
{
if(head == tail)
{
return -1;
}
else
{
if(head->next == tail)
{
tail = head;
}
int item = head->next->data;
num--;
linked_list *node = head->next;
head->next = node->next;
delete node;
return item;
}
}
}
4 . 循环队列
class CircularQueue
{
private:
int *data;
int head;
int tail;
int len;
public:
CircularQueue(int n)
{
data = new int[n];
head = 0;
tail = 0;
len = n;
}
bool enQueue(int item)
{
if((tail+1)%len == head)
{
return false;
}
else
{
data[tail] = item;
tail++;
if(tail == len)
{
tail = 0;
}
return true;
}
}
int deQueue()
{
if(head == tail)
{
return -1;
}
else
{
int item = data[head];
head++;
if(head == len)
{
head = 0;
}
return item;
}
}
void print()
{
cout << head << " " << tail << endl;
}
}
