C++ 用指针计算堆栈问题的大O表示法

嗨，有人能帮我用大O表示法计算这段代码的算法复杂度吗？我不太理解使用大O，因为这段代码中有很多指针。我只知道一些密码。Like cout是O（1）。其余的我不明白。我只是个编程新手。请帮我数一数大o符号。谢谢

#include <iostream>
#include <string>
#include <stdlib.h>

using namespace std;

class Book {
    int year, page;
    unsigned long long int code;
    string language, name, title;
    Book *head, *next, *prev, *link;

public:
    Book (string & name, string & title, unsigned long long int code, string & language, int year, int page) {
        head = NULL;
        this->name = name;
        this->title = title;
        this->language = language;
        this->code = code;
        this->year = year;
        this->page = page;
    }

    ~Book (void) {
        delete head;
    }

    void display (void);
    void add (void);
    void dellete (void);
};

void Book::add(void) {
    string name, title, language;
    int year, page;
    unsigned long long int code;
    cout << "Add a book...";
    cout << endl << "Author\t\t:", cin >> name;
    cout << "Title\t\t:", cin >> title;
    cout << "ISBN(13 digits)\t:", cin >> code;
    cout << "Language\t:", cin >> language;
    cout << "Year\t\t:", cin >> year;
    cout << "Pages\t\t:", cin >> page;

    Book* p = new Book(name, title, code, language, year, page);
    p->next = head;
    head = p;
}

void Book::dellete(void) {
    string name, title, language;
    int year, page;
    unsigned long long int code;
    Book* p, *prev, *next;

    if(head==NULL) {
        cout << "There is no book in the stack\n";
    } else if(head->next==NULL) {
        p = head;
        head = NULL;
        free(p);
        cout << "All book has been taken. Now the stack is empty\n";
    } else{
        p = head;
        head = p->next;
        free(p);
        cout << "A book has been taken\n";
    }
}

void Book::display(void) {
    Book* p = head;
    cout << "Displaying book(s)...\n";
    while (p) {
        cout << "----------------------------- \n";
        cout << "Author\t\t:" << p->name << endl;
        cout << "Title\t\t:" << p->title << endl;
        cout << "ISBN\t\t:" << p->code << endl;
        cout << "Language\t:" << p->language << endl;
        cout << "Year\t\t:" << p->year << endl;
        cout << "Pages\t\t:" << p->page << endl;
        cout << endl;
        p = p->next;
    }
}

int main (int argc, char const** argv) {
    string blank = "";
    Book* B = new Book(blank, blank, 0, blank, 0, 0);
    int opt;
    for (;;) {
        cout << "----------------------------- \n";
        cout << "1) Add a book.\n";
        cout << "2) Show all books.\n";
        cout << "3) Take a book\n";
        cout << "4) Exit. \n";
        cout << "Don't use space but use underscore...\n\n";

        cout << "Options:", cin >> opt;
        switch (opt) {
            case 1:
                B->add();
                break;
            case 2:
                B->display();
                break;
            case 3:
                B->dellete();
                break;
            case 4:
                exit(0);
            default:
                continue;
        }
    }
    return 0;
}

#包括
#包括
#包括
使用名称空间std；
课堂用书{
国际年，第页；
无符号长整型码；
字符串语言、名称、标题；
Book*head、*next、*prev、*link；
公众：
书籍（字符串和名称、字符串和标题、无符号长整型代码、字符串和语言、整型年份、整型页面）{
head=NULL；
此->名称=名称；
这->标题=标题；
这->语言=语言；
此->代码=代码；
本->年=年；
此->页面=页面；
}
~Book（作废）{
删除标题；
}
作废显示（作废）；
无效添加（无效）；
无效删除（void）；
};
作废账簿：：添加（作废）{
字符串名称、标题、语言；
国际年，第页；
无符号长整型码；
标题；
cout>编码；
cout>语言；
年份；
cout>page；
Book*p=新书（名称、标题、代码、语言、年份、页码）；
p->next=头部；
水头=p；
}
作废帐簿：：删除（作废）{
字符串名称、标题、语言；
国际年，第页；
无符号长整型码；
账簿*p、*prev、*next；
if（head==NULL）{
cout next==NULL）{
p=水头；
head=NULL；
自由基（p）；
下一步；
自由基（p）；
coutO表示法根据问题的大小对算法的复杂程度进行分类（以运行时或内存使用的方式）。因此O（1）表示无论问题有多大，算法的复杂度不会增加，无论恒定成本有多大

让我们来看看您的一些程序部分

删除

这具有O（1）的运行时复杂性，因为无论书堆有多大，删除书堆顶部的操作量都几乎相同。唯一的区别是0、1和2本书之间的差异，但如果将书堆增加到无穷大，操作量不会增加，这才是重要的

添加

这里很难测量。因为这种方法一次只添加一本书，所以它是O（1），因为无论已经有多少本书（这是唯一可变的大小），您都需要相同数量的操作。如果您允许一次添加多本书，那将更有趣

显示

所以display会打印出堆栈上的所有书籍。如果书籍数量增加，操作数量也会增加。现在的问题是以何种方式？在这种情况下，书籍数量翻倍会使指令数量翻倍。这是一种线性增长，因此复杂性类为O（n）


查看循环计数可能会有所帮助。问题大小上的一个循环通常意味着O（n）。如果有两个嵌套循环（问题大小上的），则通常有O（n²），依此类推

对于你的问题，你的主要函数中的无止境循环是什么，这取决于你定义的问题大小，我不知道在这里度量它是否有意义

如果将用户操作的总数定义为问题大小，则会变得复杂。如果我们放出显示部分，只允许添加和删除，则为O（n），因为所有操作都是恒定的（因为添加和删除是O（1），而其他操作是独立的指令，如cout），它们根据问题大小n在循环中发生（用户操作的数量）。如果你考虑到显示，它就不是那么简单了，因为显示的复杂性是O（m）（m=书的数量）这在很大程度上取决于之前给出的实际用户输入。我不知道那里的复杂性是什么。
它的哪一部分？一个程序没有定义的复杂性，一个算法有。@SamiKuhmonen在这一部分我最不理解的是
if（head==NULL）{cout next==NULL）{p=head；head=NULL；free（p）；cout next；free（p）；cout（；）的
是O（n）吗？因为它永远不会结束，直到我们退出程序（；；）的
如何
除非我们退出程序，否则每次都会重复，大O是什么？它在我的答案的最后一段。这取决于你定义的问题大小。所以我们必须定义堆栈的数量是多少？@birdfreeyahooNo你必须定义问题的大小。例如，当你试图确定排序算法的O时problem size是您要排序的列表的大小。因为有了这个O，您希望看到当您更改问题大小时，算法的成本如何变化。您希望O函数的问题大小是多少？您必须对它有一些用处。再次感谢@birdfreeahoo@birdfreeahoo您的回答非常有用