title |
k阶斐波那契数列(严3.32) |
time_limit |
3000MS |
memory_limit |
10000KB |
description |
试利用循环队列编写k阶斐波那契数列中前n+1项 (f(0),f(1),…,f(n))的程序,要求满足:f(n)<=max而f(n+1)>max,其中max为某个约定的常数。(注意:本题所用循环队列的容量仅为k,则在程序执行结束时,留在循环队列中的元素应是所求k阶斐波那契序列中的最后k项 f(n-k+1),…,f(n))。 |
input |
输入常数max,阶数k,用空格隔开。 |
output |
输出k阶斐波那契数列中的最后k项f(n-k+1),…,f(n)。 |
sample_input |
14 2 |
sample_output |
8 13 |
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100
using namespace std;
typedef struct {
int *data;
int first, last, k;
}Quene, *PQuene;
void dequene(PQuene p)
{
p->first = (p->first + 1) % (p->k);
}
void enquene(PQuene p, int x)
{
int k = p->k;
p->data[p->last] = x;
p->last = (p->last + 1) % k;
}
void show(PQuene p)
{
int i = p->first, k = p->k;
printf("%d ", p->data[i]);
i = (i + 1) % k;
while (i != p->last) {
printf("%d ", p->data[i]);
i = (i + 1) % k;
}
cout << endl;
}
int main()
{
PQuene p;
int m, k, i, tem;
p = (PQuene)malloc(sizeof(Quene));
p->first = p->last = 0;
p->data = (int *)malloc(sizeof(int)*MAXSIZE);
scanf("%d%d", &m, &p->k);
k = p->k;
for (i = 0; i<k; i++) {
if (i<k - 2)p->data[i] = 0;
else p->data[i] = 1;
}
//show(p);
while (1) {
tem = p->data[p->first];
for (i = (p->first + 1) % k; i != p->last; i = (1 + i) % k) {
tem += p->data[i];
}
if (tem<m) {
dequene(p);
enquene(p, tem);
}
else break;
}
show(p);
//cout << "Hello world!" << endl;
return 0;
}
title |
循环右移(耿5.2) |
time_limit |
3000MS |
memory_limit |
10000KB |
description |
编写程序,将一维数组A(下标从1开始)中的元素循环右移k位,要求只用一个元素大小的附加存储。 |
input |
第一行输入一维数组A的长度n和循环位移位数k(0<n<100;0<k<100),用空格分开。 第二行输入n个元素。 |
output |
输出循环右移k位后的一维数组。 |
sample_input |
6 3 1 2 3 4 5 6 |
sample_output |
4 5 6 1 2 3 |
#include <iostream>
#include <stdio.h>
using namespace std;
int main()
{
int n, a[100], k, i, j, bgn;
scanf("%d%d", &n, &k);
for (i = 0; i<n; i++) {
scanf("%d", &a[i]);
}
k = k % n;
bgn = n - 1; //bgn记录开始循环右移的角标
for (i = 1; i <= k + 1; i++) //循环右移k次
{
for (j = 0; j < n; j++) {
a[(bgn - j + 1 + n + 1) % (n + 1)] = a[(bgn - j + n + 1) % (n + 1)]; //因为这里有减法操作,所以区域可能会出现负数,所以加上n+1
}
bgn = (bgn + 1 + n + 1) % (n + 1);
}
//把辅助存储位去除
for (i = 1; i <= k; i++) { //左移k次
a[(k + i) % (n + 1)] = a[(k + i + 1) % (n + 1)];
}
for (i = 0; i<n; i++) {
printf("%d ", a[i]);
}
//cout << "Hello world!" << endl;
return 0;
}
title |
以三元组表为存储结构实现矩阵相加(耿5.7) |
time_limit |
3000MS |
memory_limit |
10000KB |
description |
假设稀疏矩阵A和B均以三元组表作为存储结构。试编写矩阵相加的程序,另设三元组表C存放结果矩阵。矩阵大小为m行n列(0<m,n<100) |
input |
第一行输入t1,t2(0<t1,t2<100) ,t1和t2分别是矩阵A和B中非零元素的个数,后面t1+t2行分别输入A和B中的元素,用三元组表示。 |
output |
输出三元组表C。 |
sample_input |
3 3 1 2 3 3 2 1 3 4 2 1 1 4 3 2 5 3 4 1 |
sample_output |
1 1 4 1 2 3 3 2 6 3 4 3 |
#include<cstdio>
#include<cstdlib>
typedef int ElemType;
#define MaxSize 10000
#define Maxcow 1000
typedef struct {
int i, j;
ElemType e;
}Triple;
typedef struct {
Triple data[MaxSize];
int rpos[Maxcow];
int mu, nu, tu;
}RLSMaxtrix;
void init_triple(RLSMaxtrix *M,RLSMaxtrix *N)
{
int num[100], cow, i, j;
scanf_s("%d%d", &M->tu, &N->tu);
for (i = 1; i <= M->tu; i++) {
scanf_s("%d%d%d", &M->data[i].i, &M->data[i].j, &M->data[i].e);
}
for (i = 1; i <= N->tu; i++) {
scanf_s("%d%d%d", &N->data[i].i, &N->data[i].j, &N->data[i].e);
}
for (i = 1; i <= M->tu; i++) {
++num[M->data[i].i];
}
M->rpos[1] = 1;
for (i = 2; i < M->mu; i++)
M->rpos[i] = M->rpos[i - 1] + num[i - 1];
for (i = 1; i <= N->tu; i++) {
++num[N->data[i].i];
}
N->rpos[1] = 1;
for (i = 2; i < N->mu; i++)
N->rpos[i] = N->rpos[i - 1] + num[i - 1];
}
void calculate_triple(RLSMaxtrix *M, RLSMaxtrix *N, RLSMaxtrix *Q)
{
int cow, i=1, j=1, k=1;
while (i <= M->tu&&j <= N->tu) {
if (M->data[i].i == N->data[j].i&&M->data[i].j == N->data[j].j) {
Q->data[k].j = M->data[i].j;
Q->data[k].i = M->data[i].i;
Q->data[k].e = M->data[i].e + N->data[j].e;
if (Q->data[k].e == 0)k--;//******************************结果为0
i++, j++, k++;
}
else if (M->data[i].i > N->data[j].i || (M->data[i].i == N->data[j].i&&M->data[i].j > N->data[j].j)) {
Q->data[k].j = N->data[j].j;
Q->data[k].i = N->data[j].i;
Q->data[k].e = N->data[j].e;
j++, k++;
}
else {
Q->data[k].j = M->data[i].j;
Q->data[k].i = M->data[i].i;
Q->data[k].e = M->data[i].e;
i++, k++;
}
}
while(i<=M->tu){
Q->data[k].j = M->data[i].j;
Q->data[k].i = M->data[i].i;
Q->data[k].e = M->data[i].e;
i++, k++;
}
while (j <= N->tu) {
Q->data[k].j = N->data[j].j;
Q->data[k].i = N->data[j].i;
Q->data[k].e = N->data[j].e;
j++, k++;
}
k--;
Q->tu = k;
}
void show_triple(RLSMaxtrix *Q)
{
int i;
for (i = 1; i <= Q->tu; i++) {
printf("%d %d %d\n", Q->data[i].i, Q->data[i].j, Q->data[i].e);
}
}
int main()
{
RLSMaxtrix *M, *N, *Q;
M = (RLSMaxtrix *)malloc(sizeof(RLSMaxtrix));
N = (RLSMaxtrix *)malloc(sizeof(RLSMaxtrix));
Q = (RLSMaxtrix *)malloc(sizeof(RLSMaxtrix));
M->mu = N->mu = Q->mu = M->nu = N->nu = Q->nu = 100;
init_triple(M, N);
calculate_triple(M, N, Q);
show_triple(Q);
return 0;
}
title |
以十字链表为存储结构实现矩阵相加(严5.27) |
time_limit |
3000MS |
memory_limit |
10000KB |
description |
以十字链表为存储结构,编写程序,将稀疏矩阵B加到稀疏矩阵A上。 |
input |
第一行输入四个正整数,分别为稀疏矩阵A和稀疏矩阵B的行数m、列数n、稀疏矩阵A的非零元素个数t1和稀疏矩阵B的非零元素个数t2。接下来的t1+t2行三元组表示,其中第一个元素表示非零元素所在的行值,第二个元素表示非零元素所在的列值,第三个元素表示非零元素的值。 |
output |
输出相加后的矩阵三元组。 |
sample_input |
3 4 3 2 1 1 1 1 3 1 2 2 2 1 2 1 2 2 3 |
sample_output |
1 1 1 1 2 1 1 3 1 2 2 5 |
#include<cstdio>
//#include<iostream>
#include<cstdlib>
//#include<Windows.h>
//#include<conio.h>
//using namespace std;
typedef int ElemType;
typedef struct OLNode {
int i, j;
ElemType e;
OLNode *right, *down;
}OLNode, *OLink;
typedef struct {
OLink *rhead, *chead;
int mu, nu, tu;
}CrossList;
void CreateSMatrix(CrossList *M)
{
OLink p, q;
int i;
M->rhead = (OLink*)malloc((M->mu + 1) * sizeof(OLink));
M->chead = (OLink*)malloc((M->nu + 1) * sizeof(OLink));
for (i = 0; i < M->mu + 1; i++)M->rhead[i] = NULL;
for (i = 0; i < M->nu + 1; i++)M->chead[i] = NULL;
//memset(M->rhead, NULL, M->mu + 1);
//memset(M->chead, NULL, M->nu + 1);
for (i = 0; i < M->tu; i++) {
p = (OLink)malloc(sizeof(OLNode));
scanf_s("%d%d%d", &p->i, &p->j, &p->e);
//M->rhead[0] = p;
//M->rhead[1] = p;
//cout << M->rhead[0] << M->rhead[1];
if (M->rhead[p->i] == NULL || M->rhead[p->i]->j > p->j)p->right = M->rhead[p->i], M->rhead[p->i] = p;
else {
for (q = M->rhead[p->i]; (q->right) && q->right->j > p->j; q = q->right);
p->right = q->right;
q->right = p;
}
if (M->chead[p->j] == NULL || M->chead[p->j]->i > p->i)p->down = M->chead[p->j], M->chead[p->j] = p;
else {
for (q = M->chead[p->j]; (q->down) && q->down->i > p->i; q = q->down);
p->down = q->down;
q->down = p;
}
}
}
void AddSMatrix(CrossList *M, CrossList *N)
{
int i, j;
OLink *hj, pm, pn, pre, p, q;
hj = (OLink *)malloc(sizeof(OLink)*(M->nu + 1));
for (i = 0; i <= M->nu; i++)hj[i] = M->chead[i];
for (i = 0; i <= M->mu; i++) {
pm = M->rhead[i], pn = N->rhead[i], pre = NULL;
for (; pn != NULL; /*pn = pn->right*/) {
p = (OLink)malloc(sizeof(OLNode));
*p = *pn;
if (pm == NULL || pm->j > p->j) {//行插入
if (pre == NULL)M->rhead[pn->i] = p;
else pre->right = p;
p->right = pm;
pre = p;
//完成列插入
if (hj[p->j] == NULL || hj[p->j]->i > p->i) {
p->down = hj[p->j]; hj[p->j] = p;
}
else {
for (q = hj[p->j]; q->down != NULL && q->down->i < p->i; q = q->down);
p->down = q->down;
q->down = p;
}
hj[p->j] = p;
pn = pn->right;
}
else if (pm->j < pn->j) {
pre = pm; pm = pm->right;
}
else {
pm->e += pn->e;
if (pm->e == 0) {
if (pre == NULL)M->rhead[p->i] = pm->right;
else { pre->right = pm->right; }
p = pm; //用于下面的删除
pm = pm->right;
if (M->chead[p->j] == p) {
M->chead[p->j] = hj[p->j] = p->down;
//pn = pn->right;
}
else {
for (q = hj[p->j]; q->down != NULL && q->down->i < p->i; q = q->down);
hj[p->j] = q;
hj[p->j]->down = p->down;
free(p);
}
}
pn = pn->right;
}
}
}
}
void printSMatrix(CrossList *M)
{
int i;
OLink p;
for (i = 0; i <= M->mu; i++) {
for (p = M->rhead[i]; p != NULL; p = p->right) {
printf("%d %d %d\n", p->i, p->j, p->e);
//if ((i != M->mu) || p->right != NULL)printf("\n");
}
}
}
int main()
{
CrossList *M, *N;
M = (CrossList *)malloc(sizeof(CrossList));
N = (CrossList *)malloc(sizeof(CrossList));
scanf_s("%d%d", &M->mu, &M->nu);
N->mu = M->mu, N->nu = M->nu;
scanf_s("%d%d", &M->tu, &N->tu);
CreateSMatrix(M);
CreateSMatrix(N);
AddSMatrix(M, N);
printSMatrix(M);
return 0;
}
title |
求广义表深度(严5.30) |
time_limit |
3000MS |
memory_limit |
10000KB |
description |
试按表头、表尾的分析方法编写求广义表的深度的递归程序。 |
input |
输入一串以‘(’开始,以‘(’结束的字符串,并且输入的左右括号必须匹配,如:(),(())…… |
output |
分别输出按表头、表尾分析方法求广义表深度的结果,每个结果占一行。 |
sample_input |
((a,b,(c,(d,e),f)),g) |
sample_output |
4 4 |
#include<iostream>
#include<string>
#include<cstdlib>
using namespace std;
typedef enum { ATOM, LIST } ElemTag;
typedef char AtomType;
typedef struct GLNode//GLNode是一个类型名
{
ElemTag tag;//标志域
union
{
AtomType atom;
struct { GLNode *hp, *tp; }ptr;
//ptr是列表,hp,tp分别指向该列表的表头和表尾
};
GLNode()
{
ptr.hp = ptr.tp = NULL;
}
}*List;//List是指向GLNode类型变量的指针类型
class GLists
{
public:
void GetGList(List&);//得到广义表
void CopyGList(List&, List&);//复制广义表
void ListTraverse(List);
int GListDepth(List&);//求广义表深度
private:
void CreatGList(List&, string&);//递归建立广义表
void sever(string&, string&);//存储广义表的字符串处理
};
void GLists::GetGList(List& l)
{
//cout<<"Please Input The Lists :"<<endl<<endl;
string str;
cin >> str;
CreatGList(l, str);
}
void GLists::CreatGList(List& l, string& s)//根据给定字符串s,从l递归创建广义表
{
List p, q;//广义表节点类型变量
string sub, hsub;//两个字符串
if (s == "()")//空表
l = NULL;//l置空
else//非空表
{
l = new GLNode;//建立节点
if (s.size() == 1)//原子类型
{
l->tag = ATOM;//标志域
l->atom = s[0];//原子
}//if
else//列表类型
{
l->tag = LIST;//标志域
p = l;
sub = s.substr(1, s.size() - 2);//脱去括号
do//根据得到的列表字符串建立新的广义表
{
sever(sub, hsub);//得到列表中“最小单位”hsub,然后把sub置成去掉最小单位的剩余字符串
CreatGList(p->ptr.hp, hsub);//递归建立广义表
q = p;//记录p
if (!sub.empty())//为下一个节点提前开辟节点空间
{
p = new GLNode;
p->tag = LIST;//更改标志域
q->ptr.tp = p;//连接节点
}
} while (!sub.empty());
}
}//else
}
void GLists::CopyGList(List& t, List& l)//复制广义表l->t
{
if (!l) t = NULL;//l是空表
else
{
t = new GLNode;//开辟节点
t->tag = l->tag;//标志域
if (l->tag == ATOM)//是原子节点
t->atom = l->atom;//复制原子
else//列表
{
CopyGList(t->ptr.hp, l->ptr.hp);//递归复制表头
CopyGList(t->ptr.tp, l->ptr.tp);//递归复制表尾
}
}
}
int GLists::GListDepth(List& l)//求广义表深度
{
int max = 0, dep;
List p = l;
if (l == NULL) return 1;//空表深度为1
if (l->tag == ATOM) return 0;//原子深度为零
//非空列表情况
for (; p; p = p->ptr.tp)//遍历列表
{
dep = GListDepth(p->ptr.hp);//递归求深度
if (dep>max)//更新max
max = dep;
}
return max + 1;//返回深度
}
void GLists::sever(string &str, string &hstr)//广义表字符串处理
{//将非空字符串分割成两部分hstr为第一个','之前的部分,str为之后的部分
int n = str.size(), i = 0, k = 0;
do
{
if (str[i] == '(') k++;
if (str[i] == ')') k--;
i++;
} while (i<n && (str[i] != ',' || k != 0));
if (i<n)
{
hstr = str.substr(0, i);
str = str.substr(i + 1, n - i - 1);
}
else
{
hstr = str;
str.erase(str.begin(), str.end());
}
}
void GLists::ListTraverse(List L)//广义表遍历
{
if (L->tag == ATOM)
{
cout << L->atom << ",";
}
else
{
cout << "(";
while (L != NULL)
{
ListTraverse(L->ptr.hp);
L = L->ptr.tp;
}
cout << ")";
}
}
int main()
{
GLists gl;
List l;
gl.GetGList(l);
cout << gl.GListDepth(l) << endl;
cout << gl.GListDepth(l) << endl;
//system("pause");
return 0;
}
title |
建立二叉树的二叉链表存储结构(严6.70) |
time_limit |
3000MS |
memory_limit |
10000KB |
description |
如果用大写字母标识二叉树结点,则一颗二叉树可以用符合下面语法图的字符序列表示。试编写递归程序,由这种形式的字符序列,建立相应的二叉树的二叉链表存储结构(附图见《严蔚敏:数据结构题集(C语言版)》第45页6.70)。 |
input |
输入如图所示的字符序列。 |
output |
建立相应二叉树的二成叉链表存储结构,并先序遍历输出。 |
sample_input |
A(B(#,D),C(E(#,F),#)) |
sample_output |
AB#DCE#F# |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <string.h>
using namespace std;
typedef char Elemtype;
typedef struct node {
Elemtype value;
struct node *lchild, *rchild;
}BitNode, *BiTree;
/*void process(char *s, char *s1)
{
int len, i, j;
len = strlen(s);
for (i = 0, j = 0; i<len; i++) {
if (s[i] == ',' || s[i] == '(')continue;
else s1[j++] = s[i];
}
s1[j] = '\0';
}*/
void createBitree(BiTree &T)
{
char c;
cin >> c;
if (c == '#') {
T = (BiTree)malloc(sizeof(BitNode));
T->lchild = T->rchild = NULL;
T->value = c;
}
else {
while (c == ',' || c == ')')cin >> c;
T = (BiTree)malloc(sizeof(BitNode));
T->value = c;
T->lchild = T->rchild = NULL;
cin >> c;
if (c == '(') {
createBitree(T->lchild);
createBitree(T->rchild);
}
}
}
void preordertraverse(BiTree T)
{
if (T) {
printf("%c", T->value);
preordertraverse(T->lchild);
preordertraverse(T->rchild);
}
}
int main()
{
BiTree T=NULL;
createBitree(T);
preordertraverse(T);
return 0;
}
title |
计算二叉树叶子结点数目(耿6.14) |
time_limit |
3000MS |
memory_limit |
10000KB |
description |
二叉树按照二叉链表方式存储,编写程序,计算二叉树中叶子结点的数目。 |
input |
按先序输入二叉树各结点,其中#表示取消建立子树结点。 |
output |
输出二叉树中叶子节点的数目。 |
sample_input |
ABD##EH###CF#I##G## |
sample_output |
4 |
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
int cnt = 0;
typedef struct node {
char data;
struct node *lchild, *rchild;
}BiTNode,*BiTree;
void creatBiTree(BiTree &T)
{
char c;
cin >> c;
if (c == '#')T = NULL;
else {
T = (BiTree)malloc(sizeof(BiTNode));
T->data = c;
creatBiTree(T->lchild);
creatBiTree(T->rchild);
}
}
void Traverse(BiTree T)
{
if (T) {
if (T->lchild == NULL && T->rchild == NULL)cnt++;
Traverse(T->lchild);
Traverse(T->rchild);
}
}
int main()
{
BiTree T=NULL;
creatBiTree(T);
Traverse(T);
cout << cnt << endl;
return 0;
}
title |
输出以二叉树表示的算术表达式(严6.51) |
time_limit |
3000MS |
memory_limit |
10000KB |
description |
编写程序,输出以二叉树表示的算术表达式,若该表达式中含有括号,则在输出时应添上。 |
input |
按先序输入一行字符,其中#表示取消建立子树结点,即所有叶子节点均为#。 |
output |
输出该二叉树所表示的算术表达式(若表达式中含有括号,则在输出时应添上)。 |
sample_input |
*+a(###b#)##c## |
sample_output |
(a+b)*c |
#include<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;
typedef struct node {
char data;
struct node *lchild, *rchild;
}BitNode, *BiTree;
void createBitree(BiTree &T)
{
char c;
cin >> c;
if (c != '#') {
T = (BiTree)malloc(sizeof(BitNode));
T->data = c;
T->lchild = T->rchild = NULL;
createBitree(T->lchild);
createBitree(T->rchild);
}
}
void inorderTraverse(BiTree T)
{
if (T) {
inorderTraverse(T->lchild);
cout << T->data;
inorderTraverse(T->rchild);
}
}
int main()
{
BiTree T = NULL;
createBitree(T);
inorderTraverse(T);
return 0;
}
title |
建立二叉树的二叉链表(严6.65) |
time_limit |
3000MS |
memory_limit |
10000KB |
description |
已知一棵二叉树的前序序列和中序序列分别存于两个一维数组中,试编写算法建立该二叉树的二叉链表。 |
input |
分两行分别输入一棵二叉树的前序序列和中序序列。 |
output |
输出该二叉树的后序序列。 |
sample_input |
ABDFGCEH BFDGACEH |
sample_output |
FGDBHECA |
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
using namespace std;
typedef char ElementType;
typedef struct node
{
ElementType data;
struct node * leftChild;
struct node * rightChild;
}BTNode;
//pre:存放先序序列 in:存放中序序列
BTNode *createBT(char *pre, char *in, int n)
{
BTNode *b;
char *p;
int k;
if (n <= 0)
return NULL;
b = (BTNode *)malloc(sizeof(BTNode));
b->data = *pre;
int j = 0;
for (p = in; p<in + n; p++)
{
if (*p == *pre)
break;
}
k = p - in; //确定根节点在中序序列(in)中的位置 编号为0,1,2,...,n-1 (类似于数组中的下标号,不是逻辑序号)
b->leftChild = createBT(pre + 1, in, k); //递归构造左子数
b->rightChild = createBT(pre + 1 + k, p + 1, n - k - 1); //递归构造右子树
return b;
}
void showBTInOrder(BTNode *b)
{
if (b != NULL)
{
showBTInOrder(b->leftChild);
showBTInOrder(b->rightChild);
printf("%c", b->data);
}
}
int main()
{
BTNode *b = NULL;
char pre[50];
char in[50];
cin >> pre;
cin >> in;
b = createBT(pre, in, 7);
showBTInOrder(b);
printf("\n");
return 0;
}