c语言设计你的循环队列实现,leetcode

8种机械键盘轴体对比

本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO(先进先出)原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：MyCircularQueue(k): 构造器，设置队列长度为 k 。

Front: 从队首获取元素。如果队列为空，返回 -1 。

Rear: 获取队尾元素。如果队列为空，返回 -1 。

enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。

deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。

isEmpty(): 检查循环队列是否为空。

isFull(): 检查循环队列是否已满。

示例：1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19MyCircularQueue circularQueue = new MycircularQueue(3);

circularQueue.enQueue(1); // 返回 true

circularQueue.enQueue(2); // 返回 true

circularQueue.enQueue(3); // 返回 true

circularQueue.enQueue(4); // 返回 false，队列已满

circularQueue.Rear(); // 返回 3

circularQueue.isFull(); // 返回 true

circularQueue.deQueue(); // 返回 true

circularQueue.enQueue(4); // 返回 true

circularQueue.Rear(); // 返回 4

提示：所有的值都在 0 至 1000 的范围内；

操作数将在 1 至 1000 的范围内；

请不要使用内置的队列库。

java 实现:1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69class{

private int[] data;

int head;

int tail;

int count;

/** Initialize your data structure here. Set the size of the queue to be k. */

public (int k){

data = new int[k];

head = 0;

tail = 0;

count = 0;

}

/** Insert an element into the circular queue. Return true if the operation is successful. */

public boolean enQueue(int value){

if (isFull()) {

return false;

} else {

data[tail] = value;

tail = ++tail % data.length;

++count;

return true;

}

}

/** Delete an element from the circular queue. Return true if the operation is successful. */

public boolean deQueue(){

if (isEmpty()) {

return false;

} else {

head = ++head % data.length;

--count;

return true;

}

}

/** Get the front item from the queue. */

public int Front(){

return isEmpty() ? -1 : data[head];

}

/** Get the last item from the queue. */

public int Rear(){

return isEmpty() ? -1 : data[(tail - 1 + data.length) % data.length];

}

/** Checks whether the circular queue is empty or not. */

public boolean isEmpty(){

return count == 0;

}

/** Checks whether the circular queue is full or not. */

public boolean isFull(){

return count == data.length;

}

}

/**

* Your MyCircularQueue object will be instantiated and called as such:

* MyCircularQueue obj = new MyCircularQueue(k);

* boolean param_1 = obj.enQueue(value);

* boolean param_2 = obj.deQueue();

* int param_3 = obj.Front();

* int param_4 = obj.Rear();

* boolean param_5 = obj.isEmpty();

* boolean param_6 = obj.isFull();

*/

C语言实现:1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84typedef struct {

int *data;

int head;

int tail;

int count;

int size;

} MyCircularQueue;

bool myCircularQueueIsEmpty(MyCircularQueue* obj);

bool myCircularQueueIsFull(MyCircularQueue* obj);

/** Initialize your data structure here. Set the size of the queue to be k. **/

MyCircularQueue* myCircularQueueCreate(int k){

MyCircularQueue* obj = (MyCircularQueue*)malloc(sizeof(MyCircularQueue));

obj->data = (int *)malloc(k*sizeof(int));

obj->head = 0;

obj->tail = 0;

obj->count = 0;

obj->size = k;

return obj;

}

/** Insert an element into the circular queue. Return true if the operation is successful. */

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value){

if (myCircularQueueIsFull(obj))

return false;

obj->data[obj->tail] = value;

obj->tail = (obj->tail + 1) % obj->size;

obj->count++;

return true;

}

/** Delete an element from the circular queue. Return true if the operation is successful. */

bool myCircularQueueDeQueue(MyCircularQueue* obj){

if (myCircularQueueIsEmpty(obj))

return false;

obj->head = (obj->head + 1) % obj->size;

obj->count--;

return true;

}

/** Get the front item from the queue. */

int myCircularQueueFront(MyCircularQueue* obj){

if (myCircularQueueIsEmpty(obj)) {

return -1;

}

return obj->data[obj->head];

}

/** Get the last item from the queue. */

int myCircularQueueRear(MyCircularQueue* obj){

if (myCircularQueueIsEmpty(obj)) {

return -1;

}

return obj->data[(obj->tail-1+obj->size)%obj->size];

}

/** Checks whether the circular queue is empty or not. */

bool myCircularQueueIsEmpty(MyCircularQueue* obj){

return obj->count == 0;

}

/** Checks whether the circular queue is full or not. */

bool myCircularQueueIsFull(MyCircularQueue* obj){

return obj->count == obj->size;

}

void myCircularQueueFree(MyCircularQueue* obj){

free(obj->data);

free(obj);

}

/**

* Your MyCircularQueue struct will be instantiated and called as such:

* struct MyCircularQueue* obj = myCircularQueueCreate(k);

* bool param_1 = myCircularQueueEnQueue(obj, value);

* bool param_2 = myCircularQueueDeQueue(obj);

* int param_3 = myCircularQueueFront(obj);

* int param_4 = myCircularQueueRear(obj);

* bool param_5 = myCircularQueueIsEmpty(obj);

* bool param_6 = myCircularQueueIsFull(obj);

* myCircularQueueFree(obj);

*/

总结:

挺熟悉的一道数据结构的题目，之前学的时候是有用Java实现过的所以做起来很清楚，不过转换成C语言就开始踩到一些奇奇怪怪的语法坑，大多还是对指针、malloc以及C编译器报错并不熟悉导致的。

关于isEmpty和isFull方法其实也可以不引入count变量，而是通过直接比较head和tail的大小关系来进行判定。这两种方法都实现过了然而好像差别并没有很大，遂保留了这种更为直观的写法。