目录
一、蛇形矩阵（C++）
输入两个整数 n 和 m，输出一个 n 行 m 列的矩阵，将数字1到n × m 按照回字蛇形填充至矩阵中。
具体矩阵形式可参考样例。
输入格式
输入共一行，包含两个整数 n 和 m 。
输出格式
输出满足要求的矩阵。
矩阵占 n 行，每行包含 m 个空格隔开的整数。
数据范围
1 ≤ n , m ≤ 100
输入样例及输出样例：
代码：
#include <iostream>
using namespace std;
const int N = 110;
int main()
{
int n, m;//设置行列,假设n=4,m=5
cin >> n >> m;
int Q[N][N];
int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};//(x,y):(0,1)向右；(1,0)向下；(0,-1)向左；(-1,0)向上
int x = 0, y = 0, d = 1;
int a,b;
for(int i = 1 ; i <= n*m; i++)
{
Q[x][y] = i;
a = x + dx[d];//0 0 0 0 0
b = y + dy[d];//1 2 3 4 5
/*检查移动是否合法：
*如果新的位置a或b超出了矩阵的边界，或者新的位置已经被填充过（Q[a][b]不为0），则需要进行方向的调整。
*d = (d+1) % 4; 将方向顺时针旋转90度。
*然后再次尝试移动到新的方向。
*/
if(a < 0||a >= n||b < 0||b >= m||Q[a][b])
{
d = (d+1) % 4;//2
a = x + dx[d];//1
b = y + dy[d];//4
}
x = a;//0 0 0 0 1
y = b;//1 2 3 4 4
}
for(int i = 0; i < n; i++)
{
for(int j = 0; j < m ; j++)
{
printf("%4d",Q[i][j]);
}
cout << endl;
}
return 0;
}思路分析：
对于这一题，我们可以将它看成一个二维数组，建立一个坐标系x-y，设置一系列方向向量(x,y):(0,1)向右；(1,0)向下；(0,-1)向左；(-1,0)向上，并将他们分别写成一维数组dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1}来表示坐标的改变。
假设要顺时针遍历点（x0,y0）周围的四个点（x0，y0+1)、(x0+1,y0)、(x0,y0-1)、(x0-1,y0)，我们可以用一个for循环来进行，方法如下：
for(int i=0;i<4;i++)
{
x1 = x0 + dx[i];
y1 = y0 + dy[i];
}
//dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1}对于这道题，顺时针进行旋转填数，那么第一个方向就是向右，然后依次是下，左，上。那么就要从dx[1]和dy[1]开始进行循环，代码如下：
for(int i = 1 ; i <= n*m; i++)
{
Q[x][y] = i;
a = x + dx[d];
b = y + dy[d];
if(a < 0||a >= n||b < 0||b >= m||Q[a][b])
{
d = (d+1) % 4;
a = x + dx[d];
b = y + dy[d];
}
x = a;
y = b;
}
如果新的位置a或b超出了矩阵的边界，或者新的位置已经被填充过（Q[a][b]不为0），则需要进行方向的调整。d = (d+1) % 4; 将方向顺时针旋转90度。然后再次尝试移动到新的方向。
最后再用一个for循环打印出这个二维数组即可。
二、有序单循环链表的插入
链表的定义
一种线性表数据结构。它使用一组任意的存储单元，来存储一组具有相同类型的地址，但是链表一般是内嵌到数据结构中，而数据结构的类型可以是不同的。
了解链表的定义后，我们就可以着手于这道题的解决了，这里我将会提供两种解法，一种为在插入链表时就进行排序，也就是让新插入的数据找到自己应该呆到的位置，最后对链表进行打印输出；另一种则为将数据一个接一个的接在一起，用冒泡排序的方法对链表进行排序，然后在依次打印输出。
typedef struct Node
{
int data;
struct Node *next;//struct自定义
}*ListNode;//ListNode是struct Node *的简写
// 创建链表的头结点
//接受一个整型参数data，然后分配一个新的Node结构体，将其数据设置为data，
//并将其next指针设置为NULL。最后，它返回这个新创建的节点的指针。
ListNode createNode(int data)
{
ListNode newNode = new Node;
newNode->data = data;
newNode->next = NULL;
return newNode;
}首先，使用struct声明一个结构体Node，结构体使用typedef为结构体声明别名；然后， 创建链表的头结点，接受一个整型参数data，然后分配一个新的Node结构体，将其数据设置为data，并将其next指针设置为NULL。最后，它返回这个新创建的节点的指针。两种方法的这两步收获相同的。不同点在于第一种的addlist函数是直接有序插入的，即在插入过程中就完成了排序工作，最后，用showlist函数打印输出；第二种方法的关键点在于一个排序函数sortlist，这个排序函数用冒泡排序的方法进行排序，它的addlist函数就是依次在链表末端添加，其余的与第一种相同。
第一种方法代码如下：
添加整数部分代码：
void addList(ListNode &head)
{
int data;
cout << "请输入要插入的整数：";
cin >> data;
ListNode newNode = createNode(data);
if (head == NULL || head->data >= newNode->data)
{
newNode->next = head;
head = newNode;
}
else
{
ListNode current = head;
while (current->next != NULL && current->next->data < newNode->data)
{
current = current->next;
}
newNode->next = current->next;
current->next = newNode;
}
}
这种方法的关键在于addList()函数，通过比较新插入的数据与头节点的数据的大小，如果新的数据小于头节点的，那么它将取代头节点成为新的头节点；如果大于头节点它将遍历链表，找到合适的位置插入新节点，以保持链表的有序性。
第二种方法如下：
添加整数部分代码：
void addList(ListNode &head)
{
int data;
cout << "请输入要插入的整数：";
cin >> data;
ListNode newNode = createNode(data);
if (head == NULL)
{
head = newNode;
}
else
{
ListNode temp=head;
while(temp->next!=NULL)
{
temp=temp->next;
}
temp->next=newNode;
}
}这种添加方法就是在head为空的前提下，依次添加，首个添加的数字取代head，后面的添加的数字的方法用了一个循环查找为NULL的节点插入新的数字。就此也就完成了在链表末尾插入数字的工作。
排序部分代码：
void sortList(ListNode head)
{
ListNode p = head;
ListNode j = NULL;
for(;p->next!=NULL;p=p->next)
{
ListNode p1 = head;
for(;p1->next!=j;p1=p1->next)
{
if(p1->data>p1->next->data)
{
int temp = p1->data;
p1->data=p1->next->data;
p1->next->data=temp;
}
}
j=p1;
}
}首先，定义一个指针p，初始化为链表的头节点；然后，再定义一个指针j，用来标记已经排序的排序好的部分的尾部；接着，就用两个for循环进行排序，第一个循环控制整个排序过程，直到p指向最后一个节点，第二个循环则用于交换数据，当第二个循环结束，使j = p1，将j向前移动一位，即表示已经排好序的部分向前移动一个节点；每次第一个循环结束后，链表的尾部都会多一个已经排序好的节点，直到整个链表都被排序。
打印输出部分两种方法一致，代码如下：
void showList(ListNode head)
{
ListNode current = head;
while (current != NULL)
{
cout << current->data << " ";
current = current->next;
}
cout << endl;
}三、类设计题目
对于类的设计问题，我们首先要了解class类：
定义
类是一种用户自定义的数据结构。并且该类型的数据具有一定的行为能力, 也就是类中说描述的方法。通常来说, 一个类的定义包含两部分的内容, 一是该类的属性, 另一部分是它所拥有的方法。
访问限制
public与private为属性/方法限制的关键字, private 表示该部分内容是私密的, 不能被外部所访问或调用, 只能被本类内部访问; 而 public 表示公开的属性和方法, 外界可以直接访问或者调用。一般来说类的属性成员都应设置为private, public只留给那些被外界用来调用的函数接口, 但这并非是强制规定, 可以根据需要进行调整;这一部分也是struct 与class的区别，struct 的访问的是public。
数据抽象和封装
抽象是通过特定的实例抽取共同特征以后形成概念的过程。一个对象是现实世界中一个实体的抽象，一个类是一组对象的抽象。
封装是将相关的概念组成一个单元，然后通过一个名称来引用它。面向对象封装是将数据和基于数据的操作封装成一个整体对象，对数据的访问或修改只能通过对象对外提供的接口进行。
构造函数和析构函数
构造函数：是一个特殊的与类同名的成员函数，用于给数据成员设置适当的初始值。
析构函数：是在编译器要销毁一个对象前，析构函数会自动被调用，做一些销毁前的善后工作，例如释放分配空间。
其他函数
set函数，get函数，打印函数，工具函数。这些函数可根据自己的需要进行添加。
下面以一个设计为例（存取钱问题及年息问题）
首先我们设计两个数据类型class Account、class SavingsAccount，第一个用于进行存取钱工作，第二个进行设置存款年限以及年利率。代码分别如下：
class Account
{
public:
//构造函数
Account();
Account(double balance);
//析构函数
~Account();
//set函数
void setBalance(double i_balance);
//get函数
double getBalance() const;
//工具函数
void credit(double amount);//存款
void debit(double amount);//取款
private:
double balance;
};class SavingsAccount
{
public:
SavingsAccount();
SavingsAccount(double rate,int year);
~SavingsAccount();
void setRate(double r);
void setYears(int y);
void setSavingsAccount(double r,int y);
double getRate() const;
int getYears() const;
double calculate(double balance);//计算最终总余额
private:
double rate;
int years;
};
136
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
