C++练习题（求两个数的阶乘相减、链表问题）

一、阶乘相减问题

【问题】已知一块靶场大小为m*n（m行n列），每个点上都有一面旗子，我们的炮兵发射炮弹，炮弹一次只能炸掉一面旗子，每次炮弹的落点坐标都有记录，问你几炮过后，靶场还剩下几面旗子呢？

【输入】有若干行，第一行为两个整数m,n，以空格分隔，都是整数，且1<=m<=n<=100；

  接下来有若干行，每行有两个整数x,y，代表炮弹落点的坐标（行、列坐标，编号从0开始）。

（ctrl + z）EOF结束；

【输出】

一个整数，代表最后靶场上剩余的旗子数。

提示：炮弹可能打在同一个位置，也可能脱靶，但保证在100*100的范围内。

【问题解决】

这里提供两种方法供大家参考：

【第一种】

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

using namespace std;

int main()
{
	int m, n；//定义靶场的大小
    int x,y；//定义炮弹落点坐标
    int sum=0;//定义旗子的总数并初始化为0
	cin >> m >> n;//输入靶场的大小
	sum = m * n;//靶场是一个二维表，每个点都有一个旗子，利用这个计算旗子的总数
	int flag[101][101] = { 0 };//定义一个二维数组，代表炮弹落点，全部初始化为0

	while (cin >> x >> y ) {//利用while循环循环输入炮弹落点坐标
        //if语句的意思是，如果炮弹落在了靶场里面，那么相应的坐标点数值变为1
		if (x < m && y < n) {
			flag[x][y] = 1;
		}
	}
    //最后利用for循环计算靶场上还剩下的旗子数量，既从总和里去掉坐标数值为1的点
	for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            //判断坐标为[i][j]点的旗子是否被炮弹击中
            if(flag[i][j]==1){
                sum -= 1;
            }
        }
	}
    //输出结果
	cout << sum << endl;
}

第一种方法比较啰嗦，下面给出第二种方法

【第二种】

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

using namespace std;

int main()
{
	int m, n,x,y,sum;//首先，定义的变量和第一种的一样
	cin >> m >> n;//输入靶场的大小
	sum = m * n;//计算靶场所有旗子的数量
	int flag[101][101] = { 0 };//定义一个二维数组代表炮弹落点并全部初始化为0

	while (cin >> x >> y ) {
        /*这个if分支语句的意思是，如果炮弹落在靶场里并且旗子还未被击中（即落点坐标值仍为0）的话，旗子总数-1，落点坐标的值从0变成1，这样同时避免了炮弹重复落在同一个点的问题*/
		if (x < m && y < n&&flag[x][y]==0) {
			sum -= 1;
			flag[x][y] = 1;
		}
	}
	cout << sum << endl;//输出结果
}

以上是做这个题的两种方法

二、链表问题

【问题】

实现链表的输入（已实现）、输出和删除成员函数。输入时，根据endtag确定是否结束输入；删除时，根据下标（从0开始）。

注意，输入的顺序跟存放的顺序以及输出的顺序是相反的。

【问题解决】

完整代码如下：

#include "stdlib.h"
#include "iostream"

using namespace std ;

class List; //前视定义,否则友元无法定义
class LinkNode
{
 friend  List; //链表结点类的定义
 private://私有成员变量
   LinkNode *link;
   int data;
 public:
   LinkNode(const int & item, LinkNode *ptr = NULL){  data=item;link=ptr;}
   LinkNode (LinkNode *ptr = NULL)    {link=ptr;}
   ~LinkNode(){};//释放函数
};

class List
{//单链表类的定义
private:
    LinkNode *first; //指向首结点的指针
public:
    List () { first = new LinkNode ();}   // 带头结点
    ~List (){MakeEmpty();}         //析构函数
    void MakeEmpty ( );      //链表置空,已实现
    int Remove ( int i );
    void input(int  endTag);
    void output();
};
//清空链表
void List:: MakeEmpty ( )
 {
    LinkNode *q;
    while (  first->link != NULL )
	{q = first->link;
     first->link = q->link;
     delete q;
    }
};

void List :: input (int endTag){
	LinkNode  *newnode; int val;
	cin>>val;
	while(val!=endTag)
	{
		newnode=new LinkNode (val);
        newnode->link=first->link;
		first->link=newnode;
		cin>>val;
	}
}
void List::output(){
    LinkNode *q;
    q = first;
    while(q->link!=NULL){
     q = q->link;
     q->link = q->link;
     cout<<q->data<<" ";
    }
    cout<<endl;
}
int List::Remove(int index){
    LinkNode *q;
    int n = 0;
    q = first;
    while (q->link!=NULL){
        if(n!=index){
            q = q->link;
        }
        else{
            q->link = (q->link)->link;
        }
        n++;
    }
    return 1;
}
int main()
{
    List l;//定义链表对象
    l.input(0); //0为输入的结束数字
    l.output ();
    int index;
    cin>>index; //要删除的元素的下标，下标从0 开始
    l.Remove(index);
    l.output (); //删除后输出
    return 0;
}

这个问题的代码比较难理解，也很难在博客里讲解清楚，所以在这里就不给各位朋友详细讲解了，避免造成各位朋友的误解或者迷茫。这个代码可以直接运行，各位朋友将这段代码放在相应的IDE环境里编译运行即可。

简单说一下吧，其实链表实现的就是节点的转移，或者说是指针的转移，链表中的每个节点都必须拥有头指针和尾指针，头指针代表当前节点的地址或者头地址，而尾指针代表的是下一个节点的（头）地址，也就是说当前节点的尾指针其实是指向下一个节点的头指针的，二者其实是一个东西；每次移动一个节点，都必须将头指针和尾指针全部换成下一个节点的头指针和尾指针。如果能理解这些，这个问题就不难了。（PS：这是作者本人的理解，如果有不对的地方，欢迎各位朋友批评指正）