2021.4.27学习笔记

约瑟夫环问题

约瑟夫问题是个著名的问题：N个人围成一圈，第一个人从1开始报数，报M的将被杀掉，下一个人接着从1开始报。如此反复，最后剩下一个，求最后的胜利者。
有13个人，报3的人出局，最后存活谁

#include <iostream>
using namespace std;

template <class T>
class Queue
{
    public:
        Queue()
        {
            len = 0;
            size = 30;
            dp = new T[size];
            start = 0;
            end = -1;
        }
        void push(T dat);
        T pop();
        void travel();
        int getlength();
        void changearray();
        ~Queue();
    private:
        int len;
        T *dp;
        int size;
        int start;
        int end;
};

template <class T>
void Queue<T>::push(T dat)
{
    if(len == size)
    {
        printf("queue full!\n");
        return;
    }
    end++;
    end = end % size;
    dp[end] = dat;
    len++;
}

template <class T>
T Queue<T>::pop()
{
    if(len == 0)
    {
        printf("queue empty!\n");
        exit(1);
    }
    T temp = dp[start++];
    start = start % size;
    len--;
    return temp;
}

template <class T>
void Queue<T>::travel()
{
    int length = len;
    cout<<"======================="<<endl;
    printf("size-%d\n",len);
    while(length != 0)
    {
        printf("%d ",dp[start++]);
        start = start % size;
        length--;
    }
    printf("\n======================\n");

}

template <class T>
void Queue<T>::changearray()
{
    T* tp = dp;
	size = size * 2;
	dp = new T[size];
	for (int i = 0; i < len; i++)
	{
		*(dp + i) = *(tp + i);
	}
}

template<class T>
int Queue<T>::getlength()
{
    return len;
}

template <class T>
Queue<T>::~Queue()
{
    delete []dp;
}

int main()
{
    Queue<int> queue;
    for(int i = 0;i < 13; i++)
    {
        queue.push(i+1);
    }
    //queue.travel();

    int count = 0;
    while(queue.getlength() != 1)
    {
        count++;
        int temp = queue.pop();
        if(count %3 == 0)
        {
            cout<<temp<<" is killed!"<<endl;
        }
        else
        {
            queue.push(temp);
        }
    }
    cout<<queue.pop()<<" is alive!"<<endl;

    return 0;
}

异常处理

格式

try{
//有可能出现异常的语句
}

catch{
处理异常的语句
}

throw

本质：

log日志

exception

异常处理的好处：在抛出异常之后，会将之前创建的类的对象进行释放
称之为栈的解旋

catch（exception &e)
{
}

logic_error:逻辑错误
runtime_error:运行时错误
bad_allloc:错误的内存分配

length_error:最大长度错误
out_of_range:超出有效范围
invalid_argument:参数不合适