apriori算法c++实现_经典数据结构与算法（四）：Python/C/C ++实现队列类型双端队列数据结构...

前期文章点击这里：

 经典数据结构与算法(一)：Python/C/C ++实现堆栈和队列   

    双端队列或双端队列是一种队列，其中可以从前面或后面执行元素的插入和删除。因此，它不遵循FIFO规则(先进先出)。

双端队列的表示

---

双端队列的类型

• 输入限制
  双端队列在此双端队列中，输入仅在一端限制，但允许在两端删除。

• 输出限制
  双端队列在此双端队列中，输出限制在一个端部，但允许在两端插入。

---

双端队列操作

下面是双端队列的循环数组实现。在圆形数组中，如果数组已满，我们将从头开始。

但是在线性数组实现中，如果数组已满，则无法插入更多元素。在下面的每个操作中，如果阵列已满，则会引发“溢出消息”。

在执行以下操作之前，请执行以下步骤：

1. 取得大小的数组(双端队列)。

2. 在第一个位置设置两个指针，然后设置front = -1和rear = 0。

初始化数组和双端队列的指针

1.在前面插入

此操作在前面添加了一个元素。

1. 检查前面的位置。

   

   检查前部位置

2. 如果为front < 1，则重新初始化front = n-1(最后一个索引)。

   

   从前移到最后

3. 否则，减少面前加1。

4. 添加新密钥5进入array[front]。

   

   在前面插入元素

2.在后面插入

此操作在后部增加了一个元素。

1. 检查阵列是否已满。

   

   检查双端队列是否已满

2. 如果双端队列已满，请重新初始化rear = 0。

3. 否则，增加后加1。

   

   增加后方

4. 添加新密钥5进入array[rear]。

   

   在后面插入元素

3.从前面删除

该操作从前面删除一个元素。

1. 检查双端队列是否为空。

   

   检查双端队列是否为空

2. 如果双端队列为空(即front = -1)，则无法执行删除(下溢条件)。

3. 如果双端队列只有一个元素(即front = rear)，请设置front = -1和rear = -1。

4. 否则面前在末尾(即front = n - 1)，将其设置到最前面front = 0。

5. 其他，front = front + 1。

   

   增加前线

4.从后方删除

此操作从背面删除一个元素。

1. 检查双端队列是否为空。

   

   检查双端队列是否为空

2. 如果双端队列为空(即front = -1)，则无法执行删除(下溢条件)。

3. 如果双端队列只有一个元素(即front = rear)，请设置front = -1和rear = -1，否则请执行以下步骤。

   如果后位于最前面(即rear = 0)，设置为最前面rear = n - 1。

   其他，rear = rear - 1。

   

5.检查为空

此操作检查双端队列是否为空。如果为front = -1，则双端队列为空。

6.检查满

此操作检查双端队列是否已满。如果front = 0和rear = n - 1OR front = rear + 1，双端队列已满。

---

Python，C和C ++的双端队列实施

Python：

class Deque:    def __init__(self):        self.items = []    def isEmpty(self):        return self.items == []    def addRear(self, item):        self.items.append(item)    def addFront(self, item):        self.items.insert(0, item)    def removeFront(self):        return self.items.pop()    def removeRear(self):        return self.items.pop(0)    def size(self):        return len(self.items)d = Deque()print(d.isEmpty())d.addRear(8)d.addRear(5)d.addFront(7)d.addFront(10)print(d.size())print(d.isEmpty())d.addRear(11)print(d.removeRear())print(d.removeFront())d.addFront(55)d.addRear(45)print(d.items)class Deque {  static final int MAX = 100;  int arr[];  int front;  int rear;  int size;  public Deque(int size) {    arr = new int[MAX];    front = -1;    rear = 0;    this.size = size;  }  boolean isFull() {    return ((front == 0 && rear == size - 1) || front == rear + 1);  }  boolean isEmpty() {    return (front == -1);  }  void insertfront(int key) {    if (isFull()) {      System.out.println("Overflow");      return;    }    if (front == -1) {      front = 0;      rear = 0;    }    else if (front == 0)      front = size - 1;    else      front = front - 1;    arr[front] = key;  }  void insertrear(int key) {    if (isFull()) {      System.out.println(" Overflow ");      return;    }    if (front == -1) {      front = 0;      rear = 0;    }    else if (rear == size - 1)      rear = 0;    else      rear = rear + 1;    arr[rear] = key;  }  void deletefront() {    if (isEmpty()) {      System.out.println("Queue Underflow\n");      return;    }    if (front == rear) {      front = -1;      rear = -1;    } else if (front == size - 1)      front = 0;    else      front = front + 1;  }  void deleterear() {    if (isEmpty()) {      System.out.println(" Underflow");      return;    }    if (front == rear) {      front = -1;      rear = -1;    } else if (rear == 0)      rear = size - 1;    else      rear = rear - 1;  }  int getFront() {    if (isEmpty()) {      System.out.println(" Underflow");      return -1;    }    return arr[front];  }  int getRear() {    if (isEmpty() || rear < 0) {      System.out.println(" Underflow\n");      return -1;    }    return arr[rear];  }  public static void main(String[] args) {    Deque dq = new Deque(4);    System.out.println("Insert element at rear end : 12 ");    dq.insertrear(12);    System.out.println("insert element at rear end : 14 ");    dq.insertrear(14);    System.out.println("get rear element : " + dq.getRear());    dq.deleterear();    System.out.println("After delete rear element new rear become : " + dq.getRear());    System.out.println("inserting element at front end");    dq.insertfront(13);    System.out.println("get front element: " + dq.getFront());    dq.deletefront();    System.out.println("After delete front element new front become : " + +dq.getFront());  }}

C:

#include #define MAX 10void addFront(int *, int, int *, int *);void addRear(int *, int, int *, int *);int delFront(int *, int *, int *);int delRear(int *, int *, int *);void display(int *);int count(int *);int main() {  int arr[MAX];  int front, rear, i, n;  front = rear = -1;  for (i = 0; i < MAX; i++)    arr[i] = 0;  addRear(arr, 5, &front, &rear);  addFront(arr, 12, &front, &rear);  addRear(arr, 11, &front, &rear);  addFront(arr, 5, &front, &rear);  addRear(arr, 6, &front, &rear);  addFront(arr, 8, &front, &rear);  printf("\nElements in a deque: ");  display(arr);  i = delFront(arr, &front, &rear);  printf("\nremoved item: %d", i);  printf("\nElements in a deque after deletion: ");  display(arr);  addRear(arr, 16, &front, &rear);  addRear(arr, 7, &front, &rear);  printf("\nElements in a deque after addition: ");  display(arr);  i = delRear(arr, &front, &rear);  printf("\nremoved item: %d", i);  printf("\nElements in a deque after deletion: ");  display(arr);  n = count(arr);  printf("\nTotal number of elements in deque: %d", n);}void addFront(int *arr, int item, int *pfront, int *prear) {  int i, k, c;  if (*pfront == 0 && *prear == MAX - 1) {    printf("\nDeque is full.\n");    return;  }  if (*pfront == -1) {    *pfront = *prear = 0;    arr[*pfront] = item;    return;  }  if (*prear != MAX - 1) {    c = count(arr);    k = *prear + 1;    for (i = 1; i <= c; i++) {      arr[k] = arr[k - 1];      k--;    }    arr[k] = item;    *pfront = k;    (*prear)++;  } else {    (*pfront)--;    arr[*pfront] = item;  }}void addRear(int *arr, int item, int *pfront, int *prear) {  int i, k;  if (*pfront == 0 && *prear == MAX - 1) {    printf("\nDeque is full.\n");    return;  }  if (*pfront == -1) {    *prear = *pfront = 0;    arr[*prear] = item;    return;  }  if (*prear == MAX - 1) {    k = *pfront - 1;    for (i = *pfront - 1; i < *prear; i++) {      k = i;      if (k == MAX - 1)        arr[k] = 0;      else        arr[k] = arr[i + 1];    }    (*prear)--;    (*pfront)--;  }  (*prear)++;  arr[*prear] = item;}int delFront(int *arr, int *pfront, int *prear) {  int item;  if (*pfront == -1) {    printf("\nDeque is empty.\n");    return 0;  }  item = arr[*pfront];  arr[*pfront] = 0;  if (*pfront == *prear)    *pfront = *prear = -1;  else    (*pfront)++;  return item;}int delRear(int *arr, int *pfront, int *prear) {  int item;  if (*pfront == -1) {    printf("\nDeque is empty.\n");    return 0;  }  item = arr[*prear];  arr[*prear] = 0;  (*prear)--;  if (*prear == -1)    *pfront = -1;  return item;}void display(int *arr) {  int i;  printf("\n front:  ");  for (i = 0; i < MAX; i++)    printf("  %d", arr[i]);  printf("  :rear");}int count(int *arr) {  int c = 0, i;  for (i = 0; i < MAX; i++) {    if (arr[i] != 0)      c++;  }  return c;}

C++

#include using namespace std;#define MAX 10class Deque {  int arr[MAX];  int front;  int rear;  int size;   public:  Deque(int size) {    front = -1;    rear = 0;    this->size = size;  }  void insertfront(int key);  void insertrear(int key);  void deletefront();  void deleterear();  bool isFull();  bool isEmpty();  int getFront();  int getRear();};bool Deque::isFull() {  return ((front == 0 && rear == size - 1) ||      front == rear + 1);}bool Deque::isEmpty() {  return (front == -1);}void Deque::insertfront(int key) {  if (isFull()) {    cout << "Overflow\n"       << endl;    return;  }  if (front == -1) {    front = 0;    rear = 0;  }  else if (front == 0)    front = size - 1;  else    front = front - 1;  arr[front] = key;}void Deque ::insertrear(int key) {  if (isFull()) {    cout << " Overflow\n " << endl;    return;  }  if (front == -1) {    front = 0;    rear = 0;  }  else if (rear == size - 1)    rear = 0;  else    rear = rear + 1;  arr[rear] = key;}void Deque ::deletefront() {  if (isEmpty()) {    cout << "Queue Underflow\n"       << endl;    return;  }  if (front == rear) {    front = -1;    rear = -1;  } else if (front == size - 1)    front = 0;  else    front = front + 1;}void Deque::deleterear() {  if (isEmpty()) {    cout << " Underflow\n"       << endl;    return;  }  if (front == rear) {    front = -1;    rear = -1;  } else if (rear == 0)    rear = size - 1;  else    rear = rear - 1;}int Deque::getFront() {  if (isEmpty()) {    cout << " Underflow\n"       << endl;    return -1;  }  return arr[front];}int Deque::getRear() {  if (isEmpty() || rear < 0) {    cout << " Underflow\n"       << endl;    return -1;  }  return arr[rear];}int main() {  Deque dq(4);  cout << "insert element at rear end \n";  dq.insertrear(5);  dq.insertrear(11);  cout << "rear element: "     << dq.getRear() << endl;  dq.deleterear();  cout << "after deletion of the rear element, the new rear element: " << dq.getRear() << endl;  cout << "insert element at front end \n";  dq.insertfront(8);  cout << "front element: " << dq.getFront() << endl;  dq.deletefront();  cout << "after deletion of front element new front element: " << dq.getFront() << endl;}

---

双端队列数据结构的应用

1. 在对软件的撤消操作中。

2. 在浏览器中存储历史记录。

3. 用于实现堆栈和队列。