排序&约瑟夫环&单链表逆置&字符串四则运算

题目1：对一个数组，将数组中的偶数从大到小排序，奇数从小到大排序，奇数和偶数交叉着放且输出数组第一位放奇数，若奇数和偶数不等长，则把剩下的直接放到数组中。

#include <iostream>

using namespace std;
//奇数从小到大排序,使用插入排序方法
void OddSort(int odd[],int oNum)
{
int temp;
for(int i=0;i<oNum;i++)
{
int j;
temp=odd[i];
for(j=i;j>0;j--)
{
if(odd[j-1]>temp)
{
odd[j]=odd[j-1];
}
else
break;
}
odd[j]=temp;
}
}

//偶数从大到小排序，使用冒泡法
void EvenSort(int even[],int eNum)
{
int temp;
for(int i=eNum-1;i>0;i--)
{
for(int j=0;j<i;j++)
{
if(even[j]<even[j+1])
{
temp=even[j];
even[j]=even[j+1];
even[j+1]=temp;
}
}
}
}

void func(int arr[],int output[],const int n)
{
int odd
,even
;
int ocount=0,ecount=0;
//对奇数偶数进行分类
for(int i=0;i<n;i++)
{
if(arr[i]%2)    //奇数
{
odd[ocount++]=arr[i];
}
else
{
even[ecount++]=arr[i];
}
}

OddSort(odd,ocount);
EvenSort(even,ecount);
int oi=0,ei=0;          //分别表示奇数和偶数下标

//奇数偶数分别插入到output中
for(int i=0;i<n;)    //i表示output下标
{
if(oi<ocount&&!(i%2))
{
output[i++]=odd[oi++];
}
else
{
output[i++]=even[ei++];
}

if(ei<ecount&&(i%2))
{
output[i++]=even[ei++];
}
else
{
output[i++]=odd[oi++];
}
}
}

int main()
{
const int n=15;
int input
={0,4,5,6,8,3,2,7,9,12,15,0,0,22,24};
int output
;
func(input,output,n);
for(int i=0;i<n;i++)
{
cout<<output[i]<<' ';
}
return 0;
}

运行结果：



题目2：约瑟夫环。

输入一个由随机数组成的数列（数列中每个数均是大于0的整数，长度已知），和初始计数器m。从数列首位置开始技术，计数到m后，将该数列该位置数值替换计数值m，并将数列中该位置数值出列，然后从下一个位置重新开始技术，知道数列所有数值出列为止。如果计数到达数列尾端，则返回数列首位置继续计数。最后输出数值出列的顺序。

#include <iostream>
#include <math.h>
using namespace std;

void Josephus(int input[],int output[],const int n)
{
int m=3;
int sum=0;
int index=0;    //数列下标
int flag
;    //置0表示对应的下标在input中的数值没有出列,置1表示出列
for(int i=0;i<n;i++)
flag[i]=0;
while (sum<n)
{
index=(index+m-1)%n;
if(!flag[index])
{
output[sum++]=input[index];
input[index]=m;
flag[index]=1;
index++;
}
}
}

int main()
{
const int n=10;
int input
,output
;
for(int i=0;i<n;i++)
input[i]=i+1;
Josephus(input,output,n);
for(int i=0;i<n;i++)
cout<<output[i]<<' ';
return 0;
}

总结：计数器m的数值有可能和Input[ ]中的数值相同，容易引发错误，所以建立一个标志数组flag[ ]来统计哪些位置Index的数值已经出列，依次来进行If判断。

题目3：单链表转置（无表头的单链表）

//单链表逆序
#include <iostream>
using namespace std;

class Node
{
private:
int data;
Node *link;
public:
Node(int x)
{
data=x;
link=NULL;
}
friend class SingleList;
};

class SingleList
{
private:
Node *first;
int n;
public:
SingleList()    //初始化不带表头的单链表
{
first=NULL;
n=0;
}
~SingleList()
{
Node *p;
while(first)
{
p=first;
first=first->link;
delete p;
}
}
bool SInsert(int i,int x)
{
if(i<0||i>n)
{
cout<<"SInsert:out of bounds"<<endl;
return false;
}
Node *q=new Node(x);
if(0==i)   //在表头插入节点
{
q->link=first;
first=q;
n++;
return true;
}
Node *p=first;
int j=1;
while(j<i&&p->link)
{
p=p->link;
}
q->link=p->link;
p->link=q;
n++;
return true;
}
void SPrint()
{
Node *p=first;
while(p)
{
cout<<p->data<<' ';
p=p->link;
}
cout<<endl;
}
bool SConvert()
{
Node *p=NULL,*q;    //p=NULL是关键点

while(first)
{
q=first->link;
first->link=p;
p=first;
first=q;
}
first=p;
if(first)
return true;
else
return false;
}
};
int main()
{
SingleList s1;
for(int i=0;i<10;i++)
{
s1.SInsert(0,i);
}
cout<<"before convert:\n";
s1.SPrint();
cout<<endl;
cout<<"after convert:\n";
s1.SConvert();
s1.SPrint();
return 0;
}

核心代码：

Node *p=NULL,*q;

while(first)

{

q=first->link;

first->link=p;

p=first;

first=q;

}

first=p;

运行结果：



题目4：字符串四则运算

//字符串四则运算
#include <iostream>
#include <string.h>
#include <cctype>
using namespace std;
int stoi(const char *input);
void FAO(const char *input,int &result,const int n)  //FAO:four arithmetic operation
{
const char *p=input;
char *left,*right;
left=new char
;
right=new char
;
int lIndex=0,rIndex=0;
char charactor;
bool flag=true;

//将做操作数，右操作数，操作符分离
while(*p)
{
if(isalnum(*p)&&flag)
{
left[lIndex++]=*p++;
}
else if(isspace(*p))
{
p++;
}
else if(isalnum(*p)&&!flag)
{
right[rIndex++]=*p++;
}
else if(*p=='+'||*p=='-'||*p=='*'||*p=='/')
{
charactor=*p++;
flag=false;
}
else
{
cout<<"error input"<<endl;
break;
}
}
left[lIndex]='\0';
right[rIndex]='\0';

//左操作数和右操作数由char转化为int
int lNum=stoi(left);
int rNum=stoi(right);
switch(charactor)
{
case '+':
result=lNum+rNum;
break;
case '-':
result=lNum-rNum;
break;
case '*':
result=lNum*rNum;
break;
case '/':
if(rNum)
result=lNum/rNum;
else
cout<<"operator \'/\':fault"<<endl;
break;
default:
cout<<"operator error"<<endl;
}
}
//字符串转化为int
int stoi(const char *input)
{
const char *p=input;
int num=0;
while(*p)
{
num=num*10+(*p-'0');
p++;
}
return num;
}

int main()
{
int result=0;
const char *input="22+21";
const int n=strlen(input);
FAO(input,result,n);
cout<<input<<"=";
cout<<result<<endl;
return 0;
}

运行结果：



【欢迎读者交流批评指正~】