数据结构--队列-泛型OC&C++混编-泛型编程

1
2
3
4

int addInt(int a, int b)
{
return a+b;
}

1
2
3
4

float addFloat(float a, float b)
{
return a+b;
}

1
2
3
4

template <typename T> struct Node{
T data;      //数据域
Node * next; //指针域
};

1

Node<int> node;

1
2
3
45

template <typename T>
struct Node{
T data;      //数据域
Node * next; //指针域
};

1
2
3
45
6

template <typename T>
int a = 0;  // 这里是错误的
struct Node{
T data;      //数据域
Node * next; //指针域
};

1
2
3
45
6
7
8
9
10
1112
13
14
15
16
17
18
19
20
2122
23
24
25
26
27
28
29
30
3132
33
34
35
36
37
38
39
40
4142
43
44
45
46
47
48
49
50
5152
53
54
55
56
57
58
59
60
6162
63
64
65
66
67
68
69
70
7172
73
74
75
76
77
78
79
80
8182
83
84
85
86
87
88
89
90
9192
93
94
95
96
97
98
99
100
101102
103
104
105
106
107
108
109
110
111112
113
114
115
116
117
118
119
120
121122
123
124
125
126
127
128
129
130
131132
133
134
135
136
137
138
139
140
141142

//
//  LinkListByArray.cpp
//  QueueByLinkList
//
//  Created by LO3G on 15/11/29.
//  Copyright © 2015年 LO3G. All rights reserved.
//

#include <iostream>

using namespace std;

template <typename T>
class LinkListByArray {
private:

// 指向队列首地址, 该地址永远指向连续内存空间的首地址而不会发生变化
T * arrayPtr;

// 队头下标, 注意类型是个整型
int head;

// 队尾下标
int tail;
int maxCnt;

public:
// 队列当前元素个数, 将这个属性设为共有, 是为了外界能直接访问队列个数.
// c++没有oc中"属性"概念, 所有成员变量的语义需要用方法来控制.
int count;

// 初始化
LinkListByArray(int cnt);

// 入队
void pushItem(T item);

// 出队
T popItem();

// 空队
bool isEmpty();
// 满队
bool isFull();

// peek队头元素
T peekHead();

// 打印队列
void display();
};

// 初始化
template <typename T>
LinkListByArray<T>::LinkListByArray(int cnt)
{
// 参数cnt表示想要创建队列的最大长度.
maxCnt = cnt;

// 按照类型T*个数的方式, 在堆区内为队列开辟空间.
arrayPtr = (T *)malloc(cnt*sizeof(T));

// 头和尾下标均指向数组的第一个位置.
head = 0;
tail = 0;

// 队列内元素个数在初始化时为0.
count = 0;
}

// 空队
template <typename T>
bool LinkListByArray<T>::isEmpty()
{
// 这里使用一个计数器记录队列元素个数
if (count == 0) {
cout << "空队" << endl;
return true;
}else
{
return false;
}
}
// 满队
template <typename T>
bool LinkListByArray<T>::isFull()
{
if (count == maxCnt) {
cout << "满队" << endl;
return true;
}else
{
return false;
}
}

// 入队
template <typename T>
void LinkListByArray<T>::pushItem(T item)
{
// 如果满队的情况, 不能入队了, 直接返回.
if (isFull()) {
return;
}
// 入队操作只在队列尾部
arrayPtr[tail] = item;

// 注意, 这里为tail增加时, 要对其取模, 保证它永远不会大过数组总长度.
tail = (tail + 1) % maxCnt;

// 入队成功, 将元素个数记录+1.
count++;
}

// 出队
template <typename T>
T LinkListByArray<T>::popItem()
{
// 如果空队, 则不能返回任何元素, 返回NULL作为标记, 外部需判断
if (isEmpty()) {
return NULL;
}

// 出队时, 声明一个临时变量做一次值拷贝
T tmp = arrayPtr[head];

// 之后将head向后移动一位, 注意, 这里也要对head取模, 保证其值不会大于数组总长度.
head = (head + 1) % maxCnt;
count--;

return tmp;
}

// 打印队列
template <typename T>
void LinkListByArray<T>::display()
{
for (int i = 0; i <= count - 1; i++) {
cout << arrayPtr[(head + i) % maxCnt] << ' ';
}
cout << endl;
}

1
2
3
45
6
7
8
9
10
1112
13
14
15
16
17
18
19
20
2122
23
24
25
26
27
28
29
30
3132
33
34
35
36
37
38
39
40

//
//  main.mm
//  QueueByLinkList
//
//  Created by LO3G on 15/11/27.
//  Copyright © 2015年 LO3G. All rights reserved.
//
#import <iostream>
#import "LinkListByArray.mm"

using namespace std;

int main(int argc, const char * argv[]) {

// 初始化一个4个元素个数的队列
// 注意<char>指明队列内元素类型为char型, 这里你可以写任何类型, 但是需入队时类型一致.
LinkListByArray<char> queueArray(4);

queueArray.pushItem('a');  // 入队一个元素'a'
queueArray.pushItem('b');
queueArray.pushItem('c');
queueArray.pushItem('d');

// 出队, 我们没有用变量接受, 出队的元素被我们弄丢了.
queueArray.popItem();

queueArray.pushItem('a');
queueArray.pushItem('b');
queueArray.pushItem('c');
queueArray.pushItem('d');

queueArray.popItem();
queueArray.pushItem('a');
queueArray.popItem();

// 打印队列内所有元素, 看看结果与我们预期的是否一致.
queueArray.display();

return 0;
}

1
2
3
45
6
7
8
9
10
1112
13
14
15
16
17
18
19
20
2122
23
24
25
26
27
28
29
30
3132
33
34
35
36
37
38
39
40
4142
43
44
45
46
47
48
49
50
5152
53
54
55
56
57
58
59
60
6162
63
64
65
66
67
68
69
70
7172
73
74
75
76
77
78
79
80
8182
83
84
85
86
87
88
89
90
9192
93
94
95
96
97
98
99
100
101102
103
104
105
106
107
108
109
110
111112
113
114
115
116
117
118
119
120
121122
123
124
125
126
127
128
129
130
131132
133
134
135
136
137
138
139

//
//  LinkedQueue.cpp
//  QueueByLinkList
//
//  Created by LO3G on 15/11/26.
//  Copyright © 2015年 LO3G. All rights reserved.
//

#include <iostream>

using namespace std;
// 这个demo的队列与上图中略有不同, 该队列没有链表结构中的head节点.
// 所有的节点均为数据节点, head和tail作为两根成员指针, 一旦指向相同位置, 则将其置空, 表示当前空队.

// 定义数据节点.
template <typename T>
struct Node{
T data;      //数据域
Node * next; //指针域
};
// 队列管理类
template <typename T>
class LinkList{
Node<T> * head; // 队列的头
Node<T> * tail; // 队列的尾巴
public:
// 重写了默认初始化方法
LinkList(){head=NULL;tail=NULL;count=0;}
// 队列中元素的个数, 这个成员是可以被外界访问的, 但是不能被外界修改. c++中没有这个语义.
int count;
// 入队
void pushItem(T item);
// 出队
T popItem();
// 判断队列是否为空
bool isEmpty();
// 打印队列元素
void display();
// 根据一个数组填装队列. 这个方法并不是队列的基本算法, 是我随意加上的.
void packingByCAarray(T * start,T * end);
};

// 入队
template <typename T>
void LinkList<T>::pushItem(T item){
// 如果空列, 此时入队一个元素的话, head和tail均需要指向这个元素.
if (this->isEmpty()) {
// 让head指向一个新的节点
head = (Node<T> *)new(Node<T>);

// head指向的节点的数据域为需要入队的值.
head->data = item;

// head指向节点的next指针域指向空
head->next = NULL;

// tail和head指向同一片天空.
tail = head;
}else{
// 如果不为空的话, head和tail必将指向了不同的元素, 此时应该单独移动tail, 而不移动head.

// 新建一个节点
Node<T> * newNode = (Node<T> *)new(Node<T>);

// 让当前tail的next域 指向这个新的节点
tail->next = newNode;

// 新节点的数据域为入队的值
newNode->data = item;

// 将tail移动(指向)新的节点.
tail = tail->next;

// 将tail(newNode)的next域指向空.
tail->next = NULL;
}

// 入队之后, 队列元素个数+1.
count++;
}

// 出队
template <typename T>
T LinkList<T>::popItem(){
// 如果空队, 没有元素能出队了, 直接返回空.
if (this->isEmpty()) {
return NULL;
}
// 用临时变量对head的数据区做一次值拷贝.
T nodeData = head->data;

// 定义一根和head相同的指针, 这个指针的作用是: 当head移动到下一个位置时, 仍能找到上一个返回的元素, 将其释放掉.
Node<T> * nodep = head;

// head移动到下一个元素位置
head = head->next;

// 刚才定义的指针有作用了, 释放掉出队的元素空间.
delete nodep;

// 出队了, 元素个数应该减一.
count--;

// 返回值.
return nodeData;
}

// 判断队列是否为空
template <typename T>
bool LinkList<T>::isEmpty(){
// 根据记录的元素个数来判断是否为空对.
return count == 0 ? true : false;
}

// 打印队列元素
template <typename T>
void LinkList<T>::display(){
// 定义一根可以移动的指针, 这个指针根据节点的next一直向下找, 一直找到next为NULL为止.
Node<T> *iter = head;
while(iter != NULL){
// 打印iter指针指向元素的数据域
cout << iter->data << ' ';
// iter移动到下一个位置.
iter = iter->next;
}
cout<<endl;
}

// 使用另外一个数组来初始化队列
// 来来来, 请您自己来分析一下这个方法的原理~!~
template <typename T>
void LinkList<T>::packingByCAarray(T *start,T *end){
if(start==end)return;

while(start!=end){
this->pushItem(*start++);
}
}

1
2
3
45
6
7
8
9
10
1112
13
14
15
16
17
18
19
20
2122
23
24
25
26
27
28
29
30
3132
33
34
35
36
37
38

//
//  main.mm
//  QueueByLinkList
//
//  Created by LO3G on 15/11/27.
//  Copyright © 2015年 LO3G. All rights reserved.
//
#import <iostream>
#import "LinkList.mm"

using namespace std;

int main(int argc, const char * argv[]) {
LinkList<int> queue;

queue.pushItem('a');
queue.pushItem('b');
queue.pushItem('d');
queue.pushItem('e');
queue.pushItem('f');
queue.pushItem('g');
queue.pushItem('h');
queue.pushItem('i');
queue.pushItem('j');

queue.display();

cout << queue.popItem() << endl;
cout << queue.popItem() << endl;
cout << queue.popItem() << endl;
cout << queue.popItem() << endl;
cout << queue.popItem() << endl;
cout << queue.popItem() << endl;

queue.display();

return 0;
}