注塑机本身的热量无法满足其成型过程中所需要的温度，而注塑机模温机能迅速提升模具的温度并可以按不同原料所需求的温度自由调节和保证模具温度稳定性，减少产品的不良率。
注塑机模温机是用来控制注塑机模具的温度，模温机将油或水加热至产品成型所需要的温度，送入模具回圈，迅速提高模具温度，以提高成型效率，缩短开型时间。利用热交换原理，机内之加热器及冷却器可精确调节水或热媒油之温度，并快速循环于模具在成型的时间内保持稳定的温度，以提高产品品质和效率。
模温机
注塑行业使用注塑机模温机有什么好处：
注塑机模温机好处一：提高产品品质。在塑胶行业中，塑胶有热胀冷缩的物理性质，产品在成型过程中常常会见到一些缩水，歪曲，气泡，银纹，变形，透明度不佳，表现不光滑，瑕疵等不良现象，造成这一不良现象的最主要原因就是产品在未成型前模具温度不稳定和成型过程中模具温度达不到产品成型的温度。所以注塑模温机在注塑行业是不可缺少的。注塑机模温机可调节模具温度的平衡模度，可以升温也可以降温。利用高热传性的导热媒体，以便在很短的时间内将模具内多余的热送走。在设定好热平衡温度后，能自动控制其温度在极小误差之内，且能维持定值。在设定好热平衡温度后，能自动控制其温度在极小误差之内，且能维持稳定值，以提高产品品质。
注塑机模温机好处二：提高塑胶产品的成型效率，模温机在塑胶产品的生产过程中对温度精准的控制，可以帮助塑胶产品快速成型，从而提高塑胶产品的成型效率。所有的塑料都会有热胀冷缩的物理现象，所以若模具温度不稳定或控制不准，产品将会出现夹水纹、缩水、扭曲、变形及表面光泽不良等现象，能促使模具保持适当的温度，大幅减少合模次数及降低成型品的不良率，确保了产品成型效率。 
注塑机模温机好处三：提高生产效率。注塑成型前，能自动控制模温，迅速加温到所需的温度并且始终保持恒温，减少挤出前模具预热所需时间。可持续工作而无需担忧模温过高等问题，在生产中途停机也不致于因模具温度下降低需等待升温，可以大大提高生产效率等诸多好处。
注塑机模温机好处四：在生产过程中可以降低能耗，节约能源。好的模温机设备在使用过程中能够很好的利于电能和资源，更加高效的节约其成本，降低能耗，提高效率。
如果模具没有加温，因流道小而长，塑料未填满模腔内，就硬化。就会造成充填不足，而模具控温还有好处是成品品质稳定，不易变形，产品精度高，表面光滑，有光泽等等。所以注塑行业都需要用模温机来控温。

循环队列 是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为 环形缓冲器。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
为什么使用循环队列？
这里我们先对 队列 的简单实现进行简单展示，队列应支持两种操作：入队 和 出队 。
class MyQueue {
    // store elements
    private List<Integer> data;         
    // a pointer to indicate the start position
    private int p_start;            
    public MyQueue() {
        data = new ArrayList<Integer>();
        p_start = 0;
    }
    /** Insert an element into the queue. Return true if the operation is successful. */
    public boolean enQueue(int x) {
        data.add(x);
        return true;
    };    
    /** Delete an element from the queue. Return true if the operation is successful. */
    public boolean deQueue() {
        if (isEmpty() == true) {
            return false;
        }
        p_start++;
        return true;
    }
    /** Get the front item from the queue. */
    public int Front() {
        return data.get(p_start);
    }
    /** Checks whether the queue is empty or not. */
    public boolean isEmpty() {
        return p_start >= data.size();
    }     
}

缺点
上面的实现很简单，但在某些情况下效率很低。 随着起始指针的移动，浪费了越来越多的空间。 当我们有空间限制时，这将是难以接受的。

让我们考虑一种情况，即我们只能分配一个最大长度为 5 的数组。当我们只添加少于 5 个元素时，我们的解决方案很有效。 例如，如果我们只调用入队函数四次后还想要将元素 10 入队，那么我们可以成功。
但是我们不能接受更多的入队请求，这是合理的，因为现在队列已经满了。但是如果我们将一个元素出队呢？

实际上，在这种情况下，我们应该能够再接受一个元素。
循环队列 的需求迫在眉睫。
设计思想
这里直接复制了 liweiwei1419 精彩的 题解 ：
1、定义循环变量 front 和 rear 。一直保持这个定义，到底是先赋值还是先移动指针就很容易想清楚了。
front：指向队列头部第 1 个有效数据的位置；

rear：指向队列尾部（即最后 1 个有效数据）的下一个位置，即下一个从队尾入队元素的位置。
（说明：这个定义是依据“动态数组”的定义模仿而来。）
2、为了避免“队列为空”和“队列为满”的判别条件冲突，我们有意浪费了一个位置。
浪费一个位置是指：循环数组中任何时刻一定至少有一个位置不存放有效元素。
判别队列为空的条件是：front == rear;
判别队列为满的条件是：(rear + 1) % capacity == front;。可以这样理解，当 rear 循环到数组的前面，要从后面追上 front，还差一格的时候，判定队列为满。
3、因为有循环的出现，要特别注意处理数组下标可能越界的情况。指针后移的时候，索引 + 1，并且要注意取模。
例题
本文的写作目的就是为了 再次手写一边算法练手。
622.设计循环队列

难度：Medium

参考上述设计思路，很容易编写代码，需要注意的是取模代码的编写相对容易出问题。
实现代码：
class MyCircularQueue {

    private int front;
    private int tail;
    private int capacity;
    private int[] arr;

    public MyCircularQueue(int k) {
        this.capacity = k + 1;
        this.arr = new int[capacity];

        this.front = 0;
        this.tail = 0;
    }

    public boolean enQueue(int value) {
        if (isFull()) return false;

        arr[tail] = value;
        tail = (tail + 1) % capacity;
        return true;
    }

    public boolean deQueue() {
        if (isEmpty()) return false;

        front = (front + 1) % capacity;
        return true;
    }

    public int Front() {
        if (isEmpty()) return -1;
        return arr[front];
    }

    public int Rear() {
        if (isEmpty()) return -1;
        return arr[(tail - 1 + capacity) % capacity];
    }

    public boolean isEmpty() {
        return front == tail;
    }

    public boolean isFull() {
        return (tail + 1) % capacity == front;
    }
}

641. 设计循环双端队列

难度：Medium

和上题基本相似，除了多几个取模运算，几乎没什么变化。
class MyCircularDeque {

    private int front;
    private int tail;
    private int capacity;
    private int[] arr;

    public MyCircularDeque(int k) {
        this.capacity = k + 1;
        this.arr = new int[capacity];

        this.front = 0;
        this.tail = 0;
    }

    public boolean insertFront(int value) {
        if (isFull()) return false;

        front = (front - 1 + capacity) % capacity;
        arr[front] = value;
        return true;
    }

    public boolean insertLast(int value) {
        if (isFull()) return false;

        arr[tail] = value;
        tail = (tail + 1) % capacity;
        return true;
    }

    public boolean deleteFront() {
        if (isEmpty()) return false;

        front = (front + 1) % capacity;
        return true;
    }

    public boolean deleteLast() {
        if (isEmpty()) return false;

        tail = (tail - 1 + capacity) % capacity;
        return true;
    }

    public int getFront() {
        if (isEmpty()) return -1;
        return arr[front];
    }

    public int getRear() {
        if (isEmpty()) return -1;
        return arr[(tail - 1 + capacity) % capacity];
    }

    public boolean isEmpty() {
        return front == tail;
    }

    public boolean isFull() {
        return (tail + 1) % capacity == front;
    }
}

参考 & 感谢
文章绝大部分内容节选自LeetCode：
https://leetcode-cn.com/problems/design-circular-queue
https://leetcode-cn.com/problems/design-circular-deque
感谢 liweiwei1419 提供的精彩的 题解 。
关于我
Hello，我是 却把清梅嗅 ，如果您觉得文章对您有价值，欢迎 ❤️，也欢迎关注我的 博客 或者 GitHub。
如果您觉得文章还差了那么点东西，也请通过关注督促我写出更好的文章——万一哪天我进步了呢？

我的Android学习体系
关于文章纠错
关于知识付费
关于《反思》系列

最近发现C++重要性，重新学习ing，发现好多都忘记了…还是要抓基础呢
一、为什么要用循环队列
循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。
循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。
具体来说，我们可以使用固定大小的数组和两个指针来指示起始位置和结束位置。 目的是重用我们之前提到的被浪费的存储。
让我们通过一个示例来查看循环队列的工作原理。 你应该注意我们入队或出队元素时使用的策略。
初始队列：head=tail=-1



第一步：插入5(没插入一个元素tail指向下一个位置，如果是插入的第一个元素head也需要指向第一个元素)



第二步：插入13



第三步：插入至队列满(tail在head前一个位置？ 表示方法: (tail+1)%length==head



第四步：出队(head指向下一个位置)





第五步：入队(这里体现了队列重复使用)



第六步：重复出队至队空

只有一个元素时：head==tail



队空：head=tail=-1



至此有没有找出我们用来检查队列是空还是满的策略呢？

这里提供一个公式：求队列长度：(tail+1-head+length)%length==head 记住这里tail和head都是从-1开始。
二、实现循环队列
实现应该支持如下操作：

MyCircularQueue(k): 构造器，设置队列长度为 k 。
Front: 从队首获取元素。如果队列为空，返回 -1 。
Rear: 获取队尾元素。如果队列为空，返回 -1 。
enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
isEmpty(): 检查循环队列是否为空。
isFull(): 检查循环队列是否已满。


样例：

MyCircularQueue circularQueue = new MycircularQueue(3); // 设置长度为 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

#include<iostream>
#include<stdio.h>
#include<vector>

using namespace std;

class MyCircularQueue{
    private:
        // the start position
        int head;
        // the end position
        int tail;
        int length;
        // store elements
        vector<int> data;

    public:
       MyCircularQueue(int len) {
           data.resize(len);
           length = len;
           head=-1;
           tail=-1;

        }
       // 入队列 tail 指针变化
       bool enQueue(int x){
            if(isFull()){
                return false;
            }
            if(isEmpty()){
                head=0;
            }
            tail = (tail+1)%length;
            data[tail]=x;
            return true;
       }
       // 出队 head 指针变化
       bool deQueue(){
            if(isEmpty()){
                return false;
            }
            if (head == tail) {
                head = -1;
                tail = -1;
                return true;
            }
            head = (head+1)%length;
            return true;
       }
       bool isEmpty(){
            return head==-1;
       }
       bool isFull(){
            return ((tail+1)%length)==head;
       }
       int Front(){
           if(isEmpty()){
                return -1;
           }
            return data[head];
       }
       int Rear(){
           if(isEmpty()){
                return -1;
           }
            return data[tail];
       }

};

int main()
{
    MyCircularQueue* obj = new MyCircularQueue(3);
    bool param_1 = obj->enQueue(1);
    bool param_2 = obj->enQueue(2);
    bool param_3 = obj->enQueue(3);
    bool param_4 = obj->enQueue(4);
    int param_5 = obj->Rear();
    bool param_6 = obj->isFull();
    bool param_7 = obj->deQueue();
    int param_8 = obj->enQueue(4);
    bool param_9 = obj->Rear();
    return 0;
}

有问题的地方欢迎指正！

程序调用自身称为递归，利用变量的原值推出新值称为迭代。
递归的优点大问题转化为小问题，可以减少代码量，同时代码精简，可读性好；
缺点就是递归调用浪费了空间，而且递归太深容易造成堆栈的溢出。
迭代的好处就是代码运行效率好，因为时间只因循环次数增加而增加，而且没有额外的空间开销；
缺点就是代码不如递归简洁
转载于:https://www.cnblogs.com/samsara-yx/p/7894726.html