准备-上机考试-华为

1、选秀节目打分

这里注意两点：

    if(NULL==score||NULL==judge_type||0==n)
    {
        return 0;
    }

第二个地方，

sum=(int)(zhuanjia/zhuanjia_num*0.6+dazhong/dazhong_num*0.4);

这里题目中如果强调了平均分取整数，就应该注意小数所放的位置。

 2、左右护法排序

这题刚开始看觉得简单，但是到实际编写的时候完全没思路。

其实我好笨笨阿，这个既然已经知道他的参数，那么完全不用担心是不是越界之类。

这里用的冒泡排序，也把快排复习一下。

if (1==n%2)  //奇数
 {  
  int mid=n/2;  
  int k=0;  
  output[mid]=sort_input[k++];  
  for(int j=1;j<=n/2;j++)  
  {  
   output[mid-j]=sort_input[k++];  
   output[mid+j]=sort_input[k++];  
  }  
    
 }   
 else  
 {  
  int mid=n/2;  
  int k=0;  
  output[mid]=sort_input[k++];  
  for(int j=1;j<n/2;j++)  
  {  
   output[mid-j]=sort_input[k++];  
   output[mid+j]=sort_input[k++];  
  }  
  output[0]=sort_input[k++];     
 }  

这里注意它是以排序后的数组来排列的，以中心为开始向两边扩散。我写的程序：

void sort(int input[], int n, int output[])
{
    int i,j;
    int *temp=new int[n];
    int t;
    for(i=0;i<n;i++)
    {
        for(j=i+1;j<n;j++)
        {
            if(input[i]<input[j])
            {
                t=input[i];
                input[i]=input[j];
                input[j]=t;
            }
        
        }
    }


    if(n%2==0)//ou 
    {
        j=1;
        output[n/2]=input[0];
        for(i=1;i<n/2;i++)
        {
            output[n/2-i]=input[j++];
            output[n/2+i]=input[j++];
        }
        output[0]=input[j];
    }
    else //ji
    {
        j=1;
        output[n/2]=input[0];
        for(i=1;i<=n/2;i++)
        {
            output[n/2-i]=input[j++];
            output[n/2+i]=input[j++];
        }
        /*
        output[0]=input[j++];
        output[n-1]=input[j];
    */
    }

}  

这里注释里的内容是我先写的，后来改了也可以，不改也可以，主要注意几点：

1、n/2+n/2不等于n，因为整数的取整（当N是奇数的时候）。

2、delete ... 是很好的习惯；

3、 注意Input里面的那个标示的加减不要和外面的弄混。

int *sort_input=new int[n];  
 for(int i=0;i<n;i++)  
 {  
  sort_input[i]=input[i];  
 }  

 3、操作系统任务调度

 这一提说起来比较简单，我写的代码：

void scheduler(int task[],int n,int system_task[],int user_task[])
{
    int *system_value=new int[n];
    int *user_value=new int [n];
    int * system_num=new int[n];
    int * user_num=new int[n];
    int temp;

    int i,j=0,k=0,m;
    for(i=0;i<n;i++)
    {
        if(task[i]>255||task[i]<0)
            ;

        else if(task[i]<50)
        {
            system_value[j]=task[i];
            system_num[j++]=i;

        }
        else 
        {
            user_value[k]=task[i];
            user_num[k++]=i;
        }
    }

    for(i=0;i<j;i++)
    {
        for(m=i+1;m<j;m++)
        {
            if(system_value[m]<system_value[i])
            {
                temp=system_value[m];
                system_value[m]=system_value[i];
                system_value[i]=temp;
                temp=system_num[m];
                system_num[m]=system_num[i];
                system_num[i]=temp;            
            }
        }

    }

    for(i=0;i<k;i++)
    {
        for(m=i+1;m<k;m++)
        {
            if(user_value[m]<user_value[i])
            {
                temp=user_value[m];
                user_value[m]=user_value[i];
                user_value[i]=temp;
                temp=user_num[m];
                user_num[m]=user_num[i];
                user_num[i]=temp;
            }
        }

    }
    for(i=0;i<j;i++)
    {
        system_task[i]=system_num[i];
    }
    system_task[i]=-1;

    for(i=0;i<k;i++)
    {
        user_task[i]=user_num[i];
    }
    user_task[i]=-1;

}

这么写虽然是对的，但并不是很好。看得思路也不是很清楚，而且，如果是人为打分的话，代码的可读性是很差的。

这是一种思路，还有一种思路，是将原有的数据进行排序，排序时也记录了序号的变化，最后再进行while全部遍历一遍，该加的加进来。记得最后delete 指针型变量。

注意事项：写出层次。

4、删除子串

 哈哈，下面是我编写的代码：

int delete_sub_str(const char *str, const char *sub_str, char *result_str)
{
    int i,j=0,k,m=0;
    int num=0;
    for(i=0;i<strlen(str)/*sizeof(str)/sizeof(char)*/;i++)
    {
        
        j=0;
        k=i;
        while((str[k]!='\0')&&(str[k]==sub_str[j]))
        {
            k++;
            j++;
        }
        if(j==strlen(sub_str))
        {
            i=k;
            result_str[m++]=str[k];
            num++;
        }
        else{
            result_str[m++]=str[i];
        }        
    }
    return num;

}

 有一点很重要：str[k]!='\0'，因为很可能遇到要删除的内容是在要查阅的内容的最末尾。

还有，返回的这个result_str在最后最好还是加上'\0'比较好~~

5、高精度整数加法

 这个题目比较没思路，看了看答案，觉得它的应该比我好： 

1、首先，不用分的那么细，下面一句就挺好的：

 if (num1[0]=='-'&&num2[0]=='-'||(num1[0]!='-'&&num2[0]!='-'))   //作加法运算  

另外两种情况另议。

当是同符号的时候，要减去前面的符号位，进行运算，result的末尾也记得要加\0。对于数据当然是从后往前取，但是总会有一个先到达符号位，对于后到达的项，继续用while去循环。到最后加\0，reverse(result).

2、

这个题目确实比较难，每一步都必须考虑好

当两者异号的时候，首先做一个分类，把绝对值较大的放在Num1，另一个放在Num2,传入到sub(char *,char *,char* result)中.然后在这个里面，对借位进行处理，如果一直为'0'就一直往前借位。

最后加入负号和\0休止符，最后倒转。倒转的方法也不难，就是前后交换，用一个中间变量。OK~

不去记0的ASCII码也无所谓，因为按照'0'相减等等就可以了~

6、数组比较

好吧，这个题目最重要的是读懂题意，还是比较容易的。

7、约瑟夫问题

考察的主要是建立循环链表，注意在建立的过程中node =new Node; node->data=input_array[i];p->next=node;p=node; 而p初始化为Node *p=head; 而head则是Node *head=new Node; head->data=input_array[0];

struct Node  
{  
    int data;  
    Node *next;   
};  
void array_iterate(int len, int input_array[], int m, int output_array[])  
{  
    if (NULL==input_array||0==m||0==len)  
       ;  
    Node *node=new Node;  
    Node *head=new Node;  
    head->data=input_array[0];  
    Node *p=head;  
    int k=0;  
    for (int i=1;i<len;i++)  
    {  
        node=new Node;  
        node->data=input_array[i];  
        p->next=node;  
        p=node;  
    }  
    p->next=head;  
    p=head;  
    Node *q=new Node;  
    int count;  
    while (p->next!=p)  
    {  
        count=1;  
        while (count<m)  
        {  
            q=p;  
            p=p->next;  
            count++;  
        }  
        m=p->data;  
        output_array[k++]=m;  
        q->next=p->next;  
        p=q->next;  
    }  
    output_array[k]=p->data;  
}  

恩，到此为止吧。

华为的上机考试，已经考完了。链表的操作还是不是特别熟，要多加练习。