指针练习作业

1. 比较大小——指针
   小明在学校学习了整数，知道了什么是整数的大小。老师出了一个问题，请小明完成比较整数大小的作业。

输入：
n
2*n（n<100)个整数保存在两个数组中

输出：
比较对应数组元素，将较小值保存在a数组中，较大值存入数组b中，然后输出

 
#include <stdio.h>  
  
void swap(int *, int *);  
int input(int *, int );  
int output(int *, int );  
int main()  
{  
// 分别将输入2*n（n<100)个整数保存在两个数组中，比较对应  
// 数组元素，将较小值保存在a数组中，较大值存入数组b中   
    int n, k, a[100], b[100];  
    scanf("%d", &n);  
    input(a, n);  
    input(b, n);  
    for ( k=0; k<n; k++ )  
    {   if( a[k] > b[k] )   
            swap(&a[k], &b[k]);   
    }  
    output(a, n);  
    output(b, n);   
    return 0;  
}  
int input(int *arr1, int n )  
{  
    int i;  
    for(i=0; i<n; i++)  
    {  
        scanf("%d", (arr1+i));  
    }  
      
}  
void swap(int *a, int *b)  
{  
    int c;  
    c = *a;  
    *a = *b;  
    *b = c;  
      
}  
int output(int *arr2, int n)  
{  
    int i;  
    for(i=0; i<n; i++)  
    {  
        printf("%d,", *(arr2+i));  
    }  
    printf("\n");  
}

2. 整数排序——指针
小明在学校学习了整数，知道了什么是整数的大小。老师出了一个问题，请小明按照指定的要求对整数进行排序。

输入：
n
flag
n（n<100)个整数

输出：
对输入的 n 个整数进行排序，如果 flag=0 则按升序排序，如果 flag=1 按降序排序。

 
#include <stdio.h>  
void sort(int *, int, int);  
int input(int *, int );  
int output(int *, int );  
int main()  
{  
// 输入n（n<100)个整数，按照指定的方式（升序或降序）进行排序  
    int n, flag, a[100];  
    scanf("%d%d", &n, &flag);  
    input(a, n);  
    sort(a, n, flag); // flag=0：升序，flag=1：降序  
    output(a, n);  
    return 0;  
}  
  
int input(int *arr1, int n )  
{  
    int i;  
    for(i=0; i<n; i++)  
    {  
        scanf("%d", (arr1+i));  
    }  
      
}  
void sort(int *arr1, int len, int flag)  
{  
    int i,j,m,b[100];  
  
    for(j=1;j<=len-1;j++)  
{  
     for(i=0;i<len-1;i++)  
{  
      if(arr1[i]<arr1[i+1])  
{        m =  arr1[i];  
         arr1[i] = arr1[i+1];  
         arr1[i+1] = m;  
}  
}  
}  
    if(flag == 0)  
    {  
        for(i=len-1;i>=0;i--)  
        {  
             b[len-i-1] =arr1[i] ;  
        }  
        for(i=0;i<len;i++)  
        {  
            arr1[i] = b[i];  
        }  
    }  
}  
int output(int *arr2, int flag)  
{  
    int i;  
  
    for(i=0; i<flag; i++)  
    {  
        printf("%d,", *(arr2+i));  
    }  
    printf("\n");  
}  

3. 字符替换
背景：
字符串的替换功能是目前各种编辑软件中必备的功能之一。下面我们也来实现一下这个替换功能。

输入：

输入3行：第1行为源串 s（长度<=100）；第2行位被替换串 t（长度<=10）；第3行为替换串 str（长度<=10）

输出：

替换后的字符串（长度<=100）。

#include <stdio.h>    
#include <string.h>    
int main(int argc, char** argv) {    
    static char a[105],b[100],c[100];    
    int len1,i,j,k,len2,end = 1;    
    char * p;    
    gets(a);    
    gets(b);    
    gets(c);    
    len1 = strlen(a);    
    len2 = strlen(b);    
    for(i=0; i<len1; i++)    
    {    
        if(a[i]==b[0])    
        {    
            p = (a+i);    
             
            for(j=1;j<len2;j++)    
            {    
                if(*(p+j)==b[j])    
                {    
                  
                    end++;    
                }    
                else  
                {  
                  break;  
            }  
            }    
            if (end == len2)    
            {    
                printf("%s", c);    
                i = i+len2-1;    
                end = 1;  
            }    
            else    
            {    
                for(k=0;k<end;k++)    
                {    
                    printf("%c", *(p+k));    
                }    
                 i = i+end-1;   
                end = 1;  
                  
            }    
        }    
        else     
        {    
            printf("%c", a[i]);    
        }    
            
    }    
printf("\n");    
      return 0;    
}  

4. 逆波兰算术表达式
传统的算术表达式是由操作数（又叫运算对象或运算量）和运算符以及改变运算次序的圆括号连接而成的式子。 其运算规则如下：

(1) 先计算括号内，后计算括号外；   
(2) 在无括号或同层括号内，先进行乘除运算，后进行加减运算，即乘除运算的优先级高于加减运算的优先级；   
(3) 同一优先级运算，从左向右依次进行。 

在这种表达式的计算过程中，既要考虑括号的作用，又要考虑运算符的优先级，还要考虑运算符出现的先后次序。

波兰科学家卢卡谢维奇(Lukasiewicz)提出了算术表达式的另一种表示，即后缀表示，又称逆波兰式，其定义是把运算符放在两个运算对象的后面。在后缀表达式中，不存在括号，也不存在优先级的差别，计算过程完全按照运算符出现的先后次序进行，整个计算过程仅需一遍扫描便可完成。

例如：
3/5+6的逆波兰表达式为3 5 / 6 +
2*(3+4)的逆波兰表达式为2 3 4 + *

输入：
一个只包含加、减、乘、除和数字的逆波兰表达式

输出：
该表达式的值

说明：
题目中涉及的数据全部为整型。

#include<stdio.h>  
#include<math.h>  
int main()  
{  
    char c[100000];int n[100000]={0};int i,j=0,f,k;int ct=0;  
    gets(c);  
    for(i=0;c[i];i++)  
    {if(c[i]>='0'&&c[i]<='9')  
    {for(f=i+1;c[f]>='0'&&c[f]<='9';f++);  
     for(n[j]=0,k=f-1;k>=i;k--)  
     {n[j]=n[j]+(c[k]-'0')*pow(10,f-1-k);}//将说有数字取出放入数字数组中 ，主要是两位数以上的数字处理。   
     j++;i=f-1;}  
    else if(c[i]=='+')  
    {  
    ct=n[j-1]+n[j-2];  
    n[j-2]=ct;  
    j=j-1;              //计算之后再将参与计算的数字替换；   
    }  
    else if(c[i]=='-')  
    {  
    if(c[i+1]==' '||c[i+1]=='\0')  
    {  
    ct=n[j-2]-n[j-1];  
    n[j-2]=ct;  
    j=j-1;  
    }  
    else if(c[i+1]!='\0')  
    {  
        for(f=i+2;c[f]>='0'&&c[f]<='9';f++);  
     for(n[j]=0,k=f-1;k>=i+1;k--)  
     {  
     n[j]=(n[j]+(c[k]-'0')*pow(10,f-1-k))*(-1);  
     }  
     j++;  
     i=f-1;  
     }  
    }  
    else if(c[i]=='*')  
    {  
    ct=n[j-1]*n[j-2];  
    n[j-2]=ct;j=j-1;  
    }  
    else if(c[i]=='/')  
    {  
    ct=n[j-2]/n[j-1];  
    n[j-2]=ct;  
    j=j-1;   
    }    
    }  
  
    printf("%d\n",n[0]);  
 }