IOS实行室第一次招新题目学习劳绩（均使用C++进行实现） ...

目录
一、关于蛇形矩阵
1.界说：
2.输入：
3.输出与释放：
二、有序单循环链表的插入
1.链表结构的构建：
2.输入：
 3.输出：
 4.释放：
5.目录：
 6.主函数：
*一些学到的新知识：
1.delete和free的区别：
2. nullptr和NULL的区别：
 三、类计划题目
1.基类和继承类
2. 基类的建立：
3.派生类的建立：
四、结语

---

一、关于蛇形矩阵

1.界说：

矩阵的输入输出一般使用二维数组，由于其列数和行数由控制台输入，所以要界说的是一个动态二维数组，如下所示：

1. int rows , cols;
2. cin >> rows >> cols;
4. //定义：
5. int **arr = new int *[rows];
6. for(int i = 0 ; i < rows ; i++)
7. {
8.     arr[i] = new int [cols];
9. }

复制代码

2.输入：

有了界说，下一步就是要思量怎样输入，通过观察蛇形矩阵的特点，思量边界条件和方向切换的情况，可以通过以下的方式进行输入：

1. int rowStart = 0 , rowEnd = rows - 1;
2. int colStart = 0 , colEnd = cols - 1;
3. int num = 1;
5. while (rowStart <= rowEnd && colStart <= colEnd)
6. {
7.     //行（从左到右输入）：从 colStart 列到 colEnd 列
8.     for (int i = colStart; i <= colEnd; i++)
9.     {
10.         arr[rowStart][i] = num;
11.         num = num + 1;
12.     }
13.     rowStart = rowStart + 1;//（输入完一行，使得开始行数加一）
15.     //列（从上往下输入）：从 rowStart 行到 rowEnd 列
16.     for (int i = rowStart; i <= rowEnd; i++)
17.     {
18.         arr[i][colEnd] = num;
19.         num = num + 1;
20.     }
21.     colEnd = colEnd - 1;//（输入完一行，使得终止列数减一）
23.     //行（从右到左输入）：从 colEnd 列到 colStart 列
24.     for (int i = colEnd; i >= colStart; i--)
25.     {
26.         arr[rowEnd][i] = num;
27.         num = num + 1;
28.     }
29.     rowEnd = rowEnd - 1;//（输入完一行，使得终止行数减一）
31.     //列（从下往上输入）：从 rowEnd 行到 rowStart 列
32.     for (int i = rowEnd; i >= rowStart; i--)
33.     {
34.         arr[i][colStart] = num;
35.         num = num + 1;
36.     }
37.     colStart = colStart + 1;//（输入完一行，使得开始列数加一）
38. }

复制代码

3.输出与释放：

接下来就是很通例的输出和内存的释放：

1. //输出
2. for(int i = 0 ; i < rows ; i++)
3. {
4.     for(int j = 0 ; j < cols ; j++)
5.     {
6.         cout << setw(3) << arr[i][j];//setw()用于控制输出格式
7.     }
8.     cout << endl;
9. }
11. //释放内存：
12. for(int i = 0 ; i < rows ; i++)
13. {
14.     delete [] arr[i];
15. }
16. delete [] arr;
17. arr = NULL;

复制代码

二、有序单循环链表的插入

关于链表，本次学习重要通过链表底子知识详解（非常详细简单易懂）-CSDN博客一文，下面是一些简单的感悟和代码誊写的思绪：
1.链表结构的构建：

（链表由一个个节点构成，每个节点一般接纳结构体的形式构造）
链表节点分为两个域
      数据域：存放各种现实的数据
      指针域：存放下一节点的首地点

1. typedef struct Node
2. {
3.     //数据域
4.     int data;
5.     //指针域
6.     struct Node* next;
7. }node;

复制代码

2.输入：

1. //node **p_head：使用指向指针的指针
2. //原因：需要修改指向链表头部的指针。C++ 中的函数参数传递是值传递，
3. //     即函数内对参数的修改不会影响到外部的实际参数。
4. //     因此，如果想要在函数内修改外部的指针（比如修改链表头指针），就需要传入指针的指针，
5. //     这样在函数内修改指针的指向就可以影响到外部的实际指针。
7. //node *p_new：插入的新节点
8. //原因：由于只需要修改新节点本身的数据域和指针域，并不需要修改该节点在外部的指向，
9. //     所以直接传入指针即可
11. void link_insert_data(node **p_head , node *p_new)
12. {
13.     //定义两个指针pb和pf，用来遍历链表。
14.     node *pb,*pf;
15.     //将pb和pf初始化为指向链表头部的指针
16.     pb = pf = *p_head;
18.     //链表为空链表：
19.     if(*p_head == nullptr)
20.     {
21.         //新节点p_new作为链表的头节点
22.         *p_head = p_new;
23.         //将新节点的next指针置为nullptr，表示新节点是链表中的最后一个节点
24.         p_new->next = nullptr;
25.         return;
26.     }
28.     //链表非空链表：
29.     //查找新节点应该插入的位置
30.     while((p_new->data >= pb->data)  && (pb->next !=nullptr) )
31.     {
32.         pf = pb;
33.         pb = pb->next;//继续向后遍历
34.     }
36.     //找到一个节点的num比新来的节点num大，插在pb的前面
37.     if(p_new->data < pb->data)
38.     {
39.         //找到的节点是头节点，插在最前面
40.         if(pb == *p_head)
41.         {
42.             p_new->next = *p_head;
43.             *p_head = p_new;
44.         }
46.         //找到的节点不是头节点，将新节点插入到找到的节点(pf所指)之前。
47.         else
48.         {
49.             pf->next = p_new;
50.             p_new->next = pb;
51.         }
52.     }
54.     //没有找到比新节点数据（p_new->data）大的节点，则新节点应该插在链表的最后
55.     else
56.     {
57.         pb->next = p_new;
58.         p_new->next = nullptr;
59.     }
60. }

复制代码

1. //大概还可以写成：（是一些尝试过程中的产物）
2. //输入不太一样，但效果应该差不多
3. void insertInSortedCircularLinkedList(node *head, int value)
4. {
5.     node *p_new = new Node();
6.     p_new->data = value;
7.     p_new->next = nullptr;
9.     if (head == nullptr)
10.     {
11.         // 空链表情况
12.         head = p_new;
13.         p_new->next = p_new;  // 让新节点指向自身，构成循环
14.     }
15.     else if (value <= head->data)
16.     {
17.         // 新节点的值比头节点小或等于头节点的值，插入到头部
18.         p_new->next = head;
19.         node *last = head;
20.         while (last->next != head)
21.         {
22.             last = last->next;  // 找到最后一个节点
23.         }
24.         last->next = p_new;  // 更新尾节点的 next 指针
25.         head = p_new;  // 更新头节点
26.     }
27.     else
28.     {
29.         // 中间或尾部插入
30.         node *current = head;
31.         while (current->next != head && current->next->data < value)
32.         {
33.             current = current->next;
34.         }
35.         p_new->next = current->next;
36.         current->next = p_new;
37.     }
38. }
39. 或者：
40. node* insertInSortedCircularLinkedList(node *head, int value)
41. {
42.     node* newNode = new Node();
43.     //使用 new 运算符在堆内存中动态分配了一个 Node 类型的对象，并将返回的地址赋给指针 newNode
44.     newNode->data = value;
46.     if (head == nullptr)
47.     {
48.         newNode->next = newNode;
49.         return newNode;
50.     }
52.     node* pb = head ;
53.     node* pf = nullptr;
54.     do
55.     {
56.         pf = pb;
57.         pb = pb->next;
58.     }
59.     while (pb != head && newNode->next >= pb->data);
61.     if (pb == head)
62.     {
63.         newNode->next = head;
64.         pf->next = newNode;
65.         return newNode;
66.     }
68.     pf->next = newNode;
69.     newNode->next = pb;
71.     return head;
72. }

复制代码

 3.输出：

1. void link_print(node *head)
2. {
3.     if (head == nullptr)
4.     {
5.         cout << "链表为空" << endl;
6.         return;
7.     }
9.     node *p_mov;
10.     //定义新的指针保存链表的首地址，防止使用head改变原本链表
11.     p_mov = head;
12.     //当指针回到头结点时，表示已经遍历完整个循环链表
14.     //当指针保存最后一个结点的指针域为nullptr时，循环结束
15.     while(p_mov != nullptr)
16.     {
17.         //先打印当前指针保存结点的指针域
18.         cout << p_mov->data << " ";
20.         //指针后移，保存下一个结点的地址
21.         p_mov = p_mov->next;
22.     }
23.     cout << endl;
24. }

复制代码

1. //也可以写成do-while 循环的形式，效果一样
2. do
3. {
4.     //先打印当前指针保存结点的指针域
5.     cout << p_mov -> data << " ";
6.     //指针后移，保存下一个结点的地址
7.     p_mov = p_mov -> next;
8. } while(p_mov != head);

复制代码

 4.释放：

1. //加入之后会使退出变得非常卡顿，在此留疑
2. void freeCircularLinkedList(node* head)
3. {
4.     if (head == nullptr)
5.     {
6.         return;
7.     }
9.     //定义一个指针变量保存头结点的地址
10.     node* current = head;
11.     node* temp;
13.     do{
14.         temp = current;
15.         current = current -> next;
16.         delete temp;
17.     } while (current != head);
18. }

复制代码

5.目录：

1. void menu(node*& head)
2. {
3.     cout << "******  Data Structure  ******" << endl;
4.     cout << "1——有序插入单列表" << endl;
5.     cout << "2——查看单列表" << endl;
6.     cout << "     退出，请输入0" << endl;
7.     int sel;
8.     while(cin >> sel)
9.     {
10.         if(sel == 0)
11.         {
12.             //freeCircularLinkedList(head);
13.             cout << endl << "期待您的下次使用！" ;
14.             break;
15.         }
16.         switch(sel)
17.         {
18.         case 1:
19.         {
20.             node* p_new = new Node();//申请一个新节点
21.             cout << "请输入要插入的值："; //给新节点赋值
22.             cin >> p_new->data;
23.             p_new->next = nullptr;
25.             link_insert_data(&head,p_new);
26.             break;
27.         }
29.         case 2:
30.         {
31.             link_print(head);
32.             break;
33.         }
35.         default:
36.         {
37.             cout << endl;
38.             cout << "您输入数字有误，请重新输入：";
39.             break;
40.         }
42.         }
43.     }
44. }

复制代码

 6.主函数：

1. int main()
2. {
3.     node* head = nullptr;
4.     menu(head);
5.     return 0;
6. }

复制代码

*一些学到的新知识：

1.delete和free的区别：

   delete 和 free 是释放内存的两种方式，重要用于释放动态分配的内存，但在 C++ 和 C 语言中有一些区别：
  delete:
  delete 是 C++ 中的关键字，用于释放使用 new 运算符动态分配的单个对象或对象数组的内存。
delete 会调用对象的析构函数，然后释放内存空间。
使用 delete 释放指向对象的指针后，指针会主动设置为 nullptr。
不能用 delete 来释放使用 malloc() 或 calloc() 分配的内存。
  free:
  free 是 C 语言中的函数，用于释放动态分配的内存。
free 只是简单地释放内存，不会调用任何析构函数。
调用 free 后，指针并不会被主动置空，可能会导致野指针问题。
不能用 free 来释放使用 new 运算符分配的内存。
总的来说，如果在 C++ 中动态分配了内存，应该使用 delete 进行释放；在 C 语言中动态分配内存则应使用 free 进行释放。在 C++ 中，最好避免混合使用 new/delete 和 malloc/free，以避免因为差别的释放方式导致的问题。
  2. nullptr和NULL的区别：

   在C++中，nullptr 是 C++11 中引入的空指针常量，用于表示空指针。而 NULL 在较早的 C++ 尺度中就存在，通常被界说为宏或者整数 0，也用于表示空指针。
  区别：
  

• nullptr 是 C++11 引入的空指针常量，具有明白的空指针类型，可以隐式转换为任意指针类型，且不会与整数 0 肴杂。
  
• NULL 在较早的 C++尺度中就存在，通常被界说为宏或者整数 0，可能会与整数 0 肴杂，不具有明白的空指针类型。
  

  *最好使用nullptr 来表示空指针，因为它更加明白和安全，避免了与整数 0 的肴杂。
   三、类计划题目

1.基类和继承类

在写此题目之前，必要提前了解什么是基类和继承类，本次学习通过Th3.11：基类与派生类关系之详细再讨论_派生类是基类的子集-CSDN博客一文了解，在此仅简述其运用方法：
   class Dad {};
class Son : public Dad {};
  
  //C++中给出了final关键字，可以防止误用了不想当基类的类作为基类
  类型1
class Dad  final {//让不想做基类的Dad类声明为final的！
public:
/*...*/
};
class Son : public Dad {//错误！Dad不能用作基类
public:
/*...*/
};
类型2
class Dad {
public:
/*...*/
};
class Son final : public Dad {//让不想做基类的Son类声明为final的！
public:
/*...*/
};
class GrandSon:public Son{//错误！Son不能用作基类
public:
/*...*/
}
  多余不再赘述
2. 基类的建立：

1. #ifndef ACCOUNT_H
2. #define ACCOUNT_H
4. using namespace std;
6. class Account
7. {
8. private:
9.     double balance;
10. public:
11.     Account()
12.     {
14.     }
15.     Account(double Balance)
16.     {
17.         if (Balance >= 0)
18.         {
19.             balance = Balance;
20.         }
21.         else
22.         {
23.             balance = 0;
24.             cout << "\t\t该初始化余额是一个无效的值，已将账户余额定义为0" << endl;
25.         }
26.     }
28.     ~Account()
29.     {
31.     }
33.     void credit(double amount)
34.     {
35.         balance = balance + amount;
36.     }
38.     void debit(double amount)
39.     {
40.         if (amount > balance)
41.         {
42.             cout << endl << "\t\tDebit amount exceeded account Balance." << endl;
43.         }
44.         else
45.         {
46.             balance = balance - amount;
47.         }
48.     }
50.     double getBalance() const
51.     {
52.         return balance;
53.     }
54. };
55. #endif // ACCOUNT_H

复制代码

3.派生类的建立：

1. #ifndef SAVINGSACCOUNT_H
2. #define SAVINGSACCOUNT_H
4. #include "Account.h"
5. using namespace std;
7. class SavingsAccount : public Account
8. {
9. private:
10.     double Rate;
11.     int Year;
13. public:
14.     SavingsAccount()
15.     {
17.     }
18.     SavingsAccount(double Balance , double rate , int year) :
19.                   Account(Balance) , Rate(rate) , Year(year){}
21.     ~SavingsAccount()
22.     {
24.     }
26.     double calculate()
27.     {
28.         double total = getBalance();
29.         for (int i = 1; i <= Year; i++)
30.         {
31.             double interest = total * Rate * 0.01;
32.             total = total + interest;
33.         }
34.         return total;
35.     }
36. };
37. #endif // SAVINGSACCOUNT_H

复制代码

4.主函数的建立：
（利用C++中的控制台界面来实现可视化菜单操纵（大概可以算是某种程度上的可视化））

1. #include <iostream>
3. #include "SavingsAccount.h"
4. using namespace std;
6. void menu(SavingsAccount &account)
7. {
8.     system("cls");
9.     cout << "\t\t************************************" << endl;
10.     cout << "\t\t当前余额为：" << account.getBalance() << endl;
11.     cout << "\t\t************************************" << endl;
12.     cout << "\t\t******  1.存款                ******" << endl;
13.     cout << "\t\t******  2.取款                ******" << endl;
14.     cout << "\t\t******  3.算存款之后的总余额  ******" << endl;
15.     cout << "\t\t******  0.退出                ******" << endl;
16.     cout << "\t\t************************************" << endl;
17.     cout << "\t\t请输入您的选择:";
18. }
19. int main()
20. {
21.     double Balance , amount;
22.     cout << "\t\t创建一个账户，并输入初始余额：";
23.     cin >> Balance;
24.     cout << endl;
26.     SavingsAccount account(Balance , 0 , 0);
28.     system("pause");//请按任意键继续
30.     menu(account);
31.     int sel;
33.     while(cin >> sel)
34.     {
35.         cout << endl;
37.         if(sel == 0)
38.         {
39.             cout << "\t\t期待您的下次使用！" ;
40.             exit(0);
41.             //exit(0)函数可以立即终止程序的执行，并返回给操作系统。
42.             //参数0表示正常退出，非零值表示异常退出
43.         }
44.         switch(sel)
45.         {
46.         case 1:
47.             cout << "\t\t请输入存款金额：";
48.             cin >> amount;
49.             account.credit(amount);
50.             cout << endl;
51.             system("pause");//请按任意键继续
52.             menu(account);
53.             break;
55.         case 2:
56.             cout << "\t\t请输入取款金额：";
57.             cin >> amount;
58.             account.debit(amount);
59.             cout << endl;
60.             system("pause");//请按任意键继续
61.             menu(account);
62.             break;
64.         case 3:
65.             double rate;
66.             int year;
67.             cout << "\t\t请输入存款年利率(单位：%)：";
68.             cin >> rate;
69.             cout << "\t\t请输入存款年份：";
70.             cin >> year;
71.             cout << endl;
72.             account = SavingsAccount(account.getBalance() , rate , year);
73.             cout << "\t\t账户经过" << year <<
74.                    "年（年利率为：" << rate << "）后，账户的总余额为：" <<
75.                    account.calculate() << endl;
76.             cout << endl;
77.             system("pause");//请按任意键继续
78.             menu(account);
79.             break;
81.         default:
82.             cout << "\t\t您输入数字有误，请重新输入：";
83.             break;
84.         }
85.     }
86.     return 0;
87. }

复制代码

*本来想实行一下改配景颜色，但是不太好看就没改，在此附上修改方式，参考c++可视化操纵（一）——控制台点击型菜单(windows.h)-CSDN博客一文
   #include <Windows.h>
  
  //配景白色
  HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(handle, BACKGROUND_RED | BACKGROUND_GREEN | BACKGROUND_BLUE | BACKGROUND_INTENSITY);
  
// 将文本颜色设置为淡蓝色
  HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(handle, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_INTENSITY);
  四、结语

本次学习到此竣事啦，虽然可能程序上另有很多的不敷（欢迎各位指正），还是感谢各位可以看我写到这里。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。