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

题目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[n],even[n];
    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[n]={0,4,5,6,8,3,2,7,9,12,15,0,0,22,24};
    int output[n];
    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[n];    //置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[n],output[n];
    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[n];
    right=new char[n];
    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;
}

运行结果：

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