shujujiegou

by admin on 2020年1月20日

如果你得了
100分:
恭喜,你完全掌握了,或许你是这方面的专家,我得拜你为师,我想你一定精通编译方法?
80分左右: 
你已经把C语言指针掌握的差不多了,不过还得努力,要有点成绩不容易.
60分左右:  你会使用基本指针,但是你不完全理解指针的实质
低于60分:  你或许是个初学者,指针使你认为C语言简直是折磨人

                  

嵌入式软件笔试

第一题:
main()
{
  char *p,*q;
  char str[]=”Hello,Worldn”;
  q = p = str;
  p++;
  printf(q);
  printf(p);
}
运行结果是什么?Hello,World
               ello,World
第二题:
void fun(char* str1, char* str2)
{
  static char buffer[21];
  strncpy(buffer, str1, 10);
  strncat(buffer, str2, 10);
  *str1 = *str2;
  str1 = buffer;
}
main()
{
   char *str1=”ABCn”;
   char *str2=”BCDn”;
   fun(str1, str2);
   printf(str1);
   printf(str2);
}
程序运行结果是__________________

 

 

第三题:
main()
{
short ar[11]={1,2,3,4,5,6,7,8,9,0,11};
short* par=&ar[1];
int i;
for(i=0; i<10; i++)
{
printf(“%-5hd%-5hd%-5hd”, ar[i], par[i],*(ar+i));
}
}
程序运行结果是__________________

数据结构实训报告

Chapter1 语法类

第四题:
main()
{
  short *p, *q;
  short ar[10]={0};
  p = q = ar; 
  p++;
  printf(“%5d”, p-q);
  printf(“%5d”, (char*)p – (char*)q);
  printf(“%5d”, sizeof(ar)/sizeof(*ar));
}
假设sizeof(short)==2
程序运行结果是__________________

 

1 .volatile作用?应用场合举3例

第五题:
int sub(int a, int b)
{
  return a-b;
}

 

volatile修饰的变量表示这个变量可能会被意想不到的改变,对该变量的操作将不作优化,用到该变量时都从这个变量的原始地址读取,而不是用保存在寄存器里的备份。

main()
{
   typedef int (*SUB)(int, int);
   SUB psub=sub;
   /* psub++; */
   printf(“%d”, psub(10,(10,5)));
}

 

Volatile常用在:

程序运行结果是__________________,
如果将中间注释掉的语句加上, 编译为什么会报错?

 

1). 硬件寄存器(如:状态寄存器)。

第六题:
main()
{
  char* pstrar[3];
澳门新葡亰网址下载,  int i;
  for(i=1; i<3; i++)
  {
     pstrar[i]=”             “;
  }
  strcpy(pstrar[1], “你好”);
  /* strcpy(pstrar[0], “世界”); */
  printf(pstrar[2]);
}
假设编译器设置字符串常量为可读写,则程序结果是_____________
为什么说注释掉的程序语句是不正确的?

 

2).
中断程序中会访问到的非自动变量(Non-automatic variables)。

第七题:
main()
{
  char *p1,*p2;
  {
    char* pchar;
    char charar[] = “你好,世界”;
    pchar = “Hello,World!”;
    p1 = pchar;
    p2 = charar;
  }
  printf(p1);
  printf(p2);
}
说出此程序的错误之处?

 

3). 多线程应用中几个任务共享的变量

第八题:
main()
{
  int i;
  char **p;
  int msg[16]={0x40, 0x41, -1, 0x00, 0x01, -1, 0x12, -1, 0x20, 0x27,
0x41, 0x35, -1, 0x51, 0x12, 0x04};
  char* strar[]={“bejing”, “shanghai”, “guangzhou”, “guangdong”,
“Tokyo”, “American”};
  char* (*pstrar)[6];
 
  pstrar = &strar;
  p = strar;

 

 

  for(i=0;  i<16; i++)
  {
      if(msg[i] == -1)
       {
          putchar(‘ ‘);
          continue;
       }
       else if(msg[i]&0xF0 == 0x40)
       {
         putchar(p[msg[i]>>4][msg[i]&0x0F]);
         continue;
       }
       else if(msg[i]&0xF0 == 0x30)
       {
         putchar(*(strar[msg[i]>>4]+(msg[i]&0x0F)));
         continue;
       }
       else
       {
         putchar(*((*pstrar)[msg[i]>>4]+(msg[i]&0x0F)));
       }
   }
}
此题有故弄玄虚之处,但如理解指针,不难解出.
请问此题的运行结果是____________________

 

 

第九题:

 

2.
一个参数既可以是const还可以是volatile吗?解释为什么。

main()
{
   typedef char CA3[2][2][2];
   typedef CA3  *PCA3;
   typedef char CA2[2][2];
   typedef CA2* PCA2[2];
  
   CA3 ca3={‘A’, ‘’, ‘B’, ‘’, ‘C’, ‘’, ‘D’, ‘’};
   PCA3 pca3 = &ca3;
   PCA2 pca2={ca3, ca3+1};

 

是的。比如只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

   int i=0,j=0;

 

 

   for(i=0; i<2; i++)
   {
     printf(“n”);
     printf(“%sn”, (char*)pca3[0][i]);
     printf(“%sn”, (*(pca2+i))[0][1]);
     for(j=0; j<2; j++)
     {
      putchar(*(*(ca3+i)+j)[0]);
      putchar(‘ ‘);
     }
   }
}
求输出的结果是:_____________________

 

  1. 一个指针可以是volatile 吗?解释为什么。

第十题:

 

是的。
比如一个中断服务子程序修该一个指向一个buffer的指针时。

/*C++ 题*/

班 级:计算机应用

 

#include

姓 名: 

 

class Display
{
public:
  virtual int ShowIt(int num) {printf(“%dn”, num); return 0;}
  int ShowIt(double num) {printf(“%lfn”, num); return 0;}
};
 
class DisplayEx: public Display
{
  public:
  int ShowIt(int num) {printf(“It is Integer, value is %dn”, num);
return 0;}
  int ShowIt(const char* str) {printf(“%sn”, str); return 0;}
};

学 号:             

 

int main()
{
DisplayEx dpex;
Display *p_base=&dpex;

计算机系数据结构实训报告
学号:        姓名:   
实验日期:班级: 计算机应用技术 
课程名称: 计算机系数据结构实训批改教师:    主持教师:

6.
写一段用来判断内存存储方式是大端还是小段的代码。

p_base->ShowIt(168);
p_base->ShowIt(1.68);

第一题目:古典问题:有一对兔子,从出生后第3个月起每个月都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月的兔子总数为多少?
程序分析:兔子的规律为数列1,1,2,3,5,8,13,21….
#include<stdio.h>
void main()
{
long f1,f2;
int i,n,m;
f1=f2=1;
printf(“输入月数:n”);
scanf(“%d”,&n);
for(i=3;i<=n;i++)
{
    m=f2;
    f2+=f1;
    f1=m;
}
    printf(“%dn”,f2);
}
执行结果:

联合体union的存放顺序是所有成员都从低地址开始存放,利用该特性就可以轻松地获得了CPU对内存采用Little-endian还是Big-endian模式读写。代码如下:

dpex.ShowIt(“Hello,Worldn”);
dpex.ShowIt(1.69);
dpex.Display::ShowIt(1.69);
return 0;
}

第二题目:一个5位数,判断它是不是回文数。即12321是回文数,个位与万位相同,十位与千位相同。
#include “stdio.h”
#include “conio.h”
main( )
{
  long ge,shi,qian,wan,x;
  scanf(“%ld”,&x);
  wan=x/10000;
  qian=x%10000/1000;
  shi=x%100/10;
  ge=x%10;
  if(ge==wan&&shi==qian)
    printf(“this number is a 回文n”);
  else
    printf(“this number is not a 回文n”);
  getch();
}
执行结果:

int checkCPUendian()

请说出其运行结果___________________
详细叙述c++编译器实现这一过程的方法.

第三题目:两个线性表的合并,有线性表LA和线性表LB,合并为LC
#include “stdio.h”
#define maxsize 100
typedef int elemtype;
typedef struct
{
   elemtype num[maxsize];
   int length;
}List;
List LC(List LA,List LB)
{
 int j,x;
 List LC;
 LC.length=LA.length+LB.length;
 for(j=0;j<LA.length;j++)
 {
  LC.num[j]=LA.num[j];
        }
        for(j=0;j<LB.length;j++)
 {
  LC.num[j+LA.length]=LB.num[j];
        }
 return(LC);
}
List create(int n)     
{
  List L;elemtype e;
  int i;
  printf(“input element(初始数值):n”);
  for(i=0;i<n;i++)
   {
 scanf(“%d”,&e);
    L.num[i]=e;
   }
  L.length=n;
  return L;
 }
void ListTr(List L) 
{int i;
  if(L.length<=0)
   printf(“顺序表为空n”);
  else
   {
   printf(“当前顺序表中的元素为:n”);
    for(i=1;i<=L.length;i++)
 printf(“%dn”,L.num[i-1]);
   }
}
void main()
 {
  int n;
  List LA,LB;
  printf(“input the LA number(顺序表的长度):”);
  scanf(“%d”,&n);
  LA=create(n);
  printf(“input the LB number(顺序表的长度):”);
  scanf(“%d”,&n);
  LB=create(n);
  ListTr(LC(LA,LB));
 }
执行结果:
 
第四题目:新建一个单链表,要求实现单链表的就地逆置。
#include<stdio.h>
#include <stdlib.h>
typedef struct QLink
{
         int data;
         struct QLink *next;
}QLink;

{

main()
{
      
       QLink *head,*p,*q;
      int length,i;
      printf(“此程序是实现链表置逆的功能.n”);
      printf(“请输入链表的长度:”);
      scanf(“%d”,&length);
      while(length<=0)
      {
          printf(“输入错误,长度必须为自然数,请重新输入.n”);
          printf(“请输入链表的长度:”);
          scanf(“%d”,&length);
      }
      printf(“现在要输入各结点的值.n”);
      for(i=1;i<=length;i++)
      {
            p=(QLink *)malloc(sizeof(QLink));
            scanf(“%d”,&p->data);
            p->next=NULL;
            if(i==1) head=p;
            else
            {
                 q=head;
                 while(q->next!=NULL) q=q->next;
                 q->next=p;
            }
      }
      printf(“链表已建立,现在要将它输出.n”);
      p=head;
      for(i=1;i<=length;i++)
      {
            printf(“%d  “,p->data);
            p=p->next;
      }
      printf(“n”);
      printf(“现在要将其置逆.n”);
      printf(“置逆成功.现在要将新的链表输出.n”);
      p=head;
      while(head->next!=NULL)
      {
           q=p;
           p=head->next;
           head->next=p->next;
           p->next=q;
      }
      head=p;
      p=head;
      for(i=1;i<=length;i++)
      {
            printf(“%d  “,p->data);
            p=p->next;
      }
      system(“pause”);
}
执行结果:

union

   第五题:
键盘输入循环缓冲区算法。要求采用循环队列来实现。
说明:在操作系统中,循环队列经常用于实时应用程序。分时处理方法:用户键入的内容不能在屏幕上立刻显示出来,直到当前正在工作的那个进程结束为止。但在这个进程执行时,系统是在不断地检查键盘状态,如果检测到用户键入了一个新的字符,就立刻把它存到系统缓冲区中,然后继续运行原来的进程。
#include <conio.h>
#include <stdio.h>
int main( void )
{
      while( !_kbhit() )
      _cputs( “Hit me!! ” );
     printf( “nKey struck was ‘%c’n”, _getch() );
}
程序代码:
#define  TRUE 1
#define  FALSE 0
#define  QueueElementType char
#define MAXSIZE 50 
typedef struct
{
 QueueElementType  element[MAXSIZE]; 
 int front;   
int rear; }
SeqQueue;

{

void InitQueue(SeqQueue *Q)

 
 Q->front=Q->rear=0;
}
int EnterQueue(SeqQueue *Q, QueueElementType x)

 if((Q->rear+1)%MAXSIZE==Q->front)    return(FALSE);
 Q->element[Q->rear]=x;
 Q->rear=(Q->rear+1)%MAXSIZE;  /
 return(TRUE);  }

unsigned int a;

int DeleteQueue(SeqQueue *Q, QueueElementType *x)
{
 if(Q->front==Q->rear)
  return(FALSE);
 *x=Q->element[Q->front];
 Q->front=(Q->front+1)%MAXSIZE; 
 return(TRUE); 
}
int GetHead(SeqQueue *Q, QueueElementType *x)
{
 
 if(Q->front==Q->rear)
  return(FALSE);
 *x=Q->element[Q->front];
 return(TRUE); 
}
int IsEmpty(SeqQueue *Q)
{
 if(Q->front==Q->rear)
  return(TRUE);
 else
  return(FALSE); 
}
#include “stdio.h”
#include “conio.h”
void main()
{
 char ch1,ch2;
 SeqQueue  Q;
 int f;
 InitQueue (&Q);
 while(TRUE)
 {
  while(TRUE)
  {
   printf(“A”);

unsigned char b;

   if(kbhit())
   {
    ch1=getch();
    if(ch1==’;’||ch1==’.’)
     break;
    f= EnterQueue(&Q,ch1);
    if(f==FALSE)
    {
     printf(“full”);
     break;
    }
   }
  }
  while (!IsEmpty(&Q))
  {
   DeleteQueue(&Q,&ch2);
   putchar(ch2);
  }
  getch();
  if(ch1==’.’) break;
 }
}
执行结果:

}c;

第六题:
数制转换:十进制数转化为二进制数。要求采用堆栈来实现。
#include <malloc.h>
#include<stdio.h>
#define MAXSIZE 32
#define OVERFLOW -1
#define ERROR -2
#define DATATYPE int
typedef enum{FALSE, TRUE} BOOL;
typedef struct
{
      DATATYPE * data;
      int top;
}STACK;
void initStack(STACK * ps)
{
     ps->data = (DATATYPE *)malloc(MAXSIZE*sizeof(DATATYPE));
     ps->top =-1;
}
BOOL empty(STACK * ps)
{
     if (ps->top == -1)
     {
          printf(“nstack empty.07”);
          return TRUE;
     }
     return FALSE;
}
BOOL full(STACK * ps)
{
     if (ps->top == MAXSIZE -1)
     {
          printf(“stack full.07n”);
          return TRUE;
     }
     return FALSE;
}
void push(STACK * ps, DATATYPE element)
{
     if (!full(ps))
     {
         ps->data[++ps->top] = element;
     }
}
DATATYPE pop(STACK *ps)
{
     if (empty(ps))
     {
          return OVERFLOW;
     }
     return ps->data[ps->top–];
}
DATATYPE getTop(STACK * ps)
{
     if (!empty(ps))
        return ps->data[ps->top];
     return ERROR;
}
void clearStack(STACK * ps)
{
     ps->top = -1;
}
void destroy(STACK * ps)
{
     free(ps);
}
#include <stdio.h>
#include <stdlib.h>
 int main()
{
     STACK stack;
     int num;
     int temp;
 initStack(&stack);
printf(“please input a number:”);
     scanf(“%d”, &num);
while(num)
     {
          push(&stack, num%2);
          num = num/2;
     }
     while(!empty(&stack))
     {
           printf(“%d”, pop(&stack));
     }
     return 0;
}
程序结果:

c.a = 1;

第七题:
括号匹配算法。要求采用堆栈来实现。
说明:表达式中包含三种括号:圆括号、方括号和花括号,它们可互相嵌套,如(
[ { } ] ( [ ] ) )或({ ( [ ] [ ( ) ])})等均为正确的格式,而{ [
] }) }或( [ ]
}均为不正确的格式。在检查算法中可设置一个栈,每读入一个括号,若是左括号,则直接入栈,等待相匹配的同类右括号;若读入是右括号,且与当前栈顶的左括号同类型,则二者匹配,将栈顶的左括号出栈,否则属于不合法的情况。另外,如果输入序列已读尽,而栈中仍有等待匹配的左括号,或者读入了一个右括号,而栈中已无等待匹配的左括号,均属不合法的情况。当输入序列和栈同时为空时,说明所有括号完全匹配。
#include <stdio.h>
#include <malloc.h>
#define OK 1
#define ERROR 0
#define maxsize 100
#define STACK_INC 10
typedef char Elem;
typedef struct{
  Elem *base;
  Elem *top;
  int size;
}SqStack;
typedef int Status;
Status CreatStack(SqStack &S)
{
  S.base=(Elem *)malloc(maxsize*sizeof(Elem));
  S.top=S.base;
  S.size=maxsize;
  return OK;
}
Status StackEmpty(SqStack S){
  if(S.top!=S.base) return ERROR;
  return OK;
}
Status Push(SqStack &S,Elem e){
  if(S.top-S.base>=S.size)
{
    S.base=(Elem *)realloc(S.base,(S.size+STACK_INC)*sizeof(Elem));
    S.top=S.base+S.size;
    S.size+=STACK_INC;
  }
  *S.top=e;
  S.top+=1;
  return OK;
}
Status Pop(SqStack &S,Elem &e){
  if(S.top==S.base) return ERROR;
  S.top-=1;
  e=*S.top;
  return OK;
}
Status Bracket(SqStack &S,char *str){
  int i=0,flag1=0,flag2;
  Elem e;
  while(str[i]!=’’){
    switch(str[i]){
      case ‘(‘:Push(S,'(‘);break;
      case ‘[‘:Push(S,'[‘);break;
      case ‘{‘:Push(S,'{‘);break;
      case ‘)’:{Pop(S,e);
                if(e!='(‘) flag1=1; break;}
      case ‘]’:{Pop(S,e);
                if(e!='[‘) flag1=1;break;} ‘
      case ‘}’:{Pop(S,e);
          if(e!='{‘) flag1=1;break;}
      default: break;
    }
    if(flag1) break;
    i++;
  }
  flag2=StackEmpty(S);
  if(!flag1 && flag2) printf(“括号匹配!n”);
  else printf(“括号不匹配!n”);
  return OK;
}
void main()
{
  char temp,flag=’y’;
  while(flag==’y’){
    char str[255];
    SqStack S;
    printf(“请输入字符串:”);
    scanf(“%s”,str);
    scanf(“%c”,&temp);
    CreatStack(S);
    Bracket(S,str);
    printf(“你想再试一次吗(按y继续): “);
    scanf(“%c”,&flag);
    printf(“n”);
  }
  printf(“程序结束.n”);
}
执行结果:

return (c.b = = 1);

个人体会::
    
我个人认为数据结构蛮复杂,编程时需要有太多的地方去注意,需要注意的细节很多,而且思路必须清晰,否则很容易出现错误。
  
通过编程可以看出:运用的队列、堆栈运算只能限定在特定的位置进行,而储存的数据类型是特定的数据类型,编程时要注意队列与堆栈的区别,考虑到它们元素的进出有很大的不同;另外,编程时要考虑最后的输出结果是否与要求一致,这就需要注意入队、入栈时的顺序问题。
编程时有很多错误,要看看头文件是否完整,以及符号是否是在英文输入状态下键入,然后具体问题具体对待。

}

/*return 1 : little-endian, return
0:big-endian*/

 

 

7.
定义一个返回值是指向函数的指针且有一个指向函数的指针作参数的函数。

通用形式如下:

typedef int (*P)( ); //
定义一个函数指针P类型

P function( int (*p)( ) ); //
定义一个函数返回值P类型,且定义一个指向函数的指针p作参数

 

 

  1. 下面的声明都是什么意思?

    1)const int a; 2)int const a; 3)const
    int *a; 4)int * const a; 5) int const * const a ;

    1,2一样a为只读整形变量;3
    指向一个只读整形变量的指针;4 指向整形的只读指针; 5
    指向只读整形的只读指针。

 

 

13.
C语言实现设置一绝对地址为0x1234的整型变量的值为0xaa55。

int *p;

p=(int *) 0x1234; //
把整型数0x1234强制转换(typecast)为一指针

*p=0xaa55;

 

 

  1. 找出下面一段ISR的问题。

    __interrupt double compute_area (double
    radius)

    {

    double area = PI * radius * radius;

printf(“nArea = %f”, area);

return area;

}

1)ISR不能传递参数。

2)ISR不能有返回值。

3)ISR应该短且有效率,在ISR中做浮点运算不明智。

 

 

15 .下面的代码输出是什么?为什么?

void foo(void)

{

unsigned int a = 6;

int b = -20;

(a+b > 6) ? puts(“> 6”) : puts(“<=
6”);

}

输出 > 6,

原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。-20成了一个非常大的正数。
// 此题的输出确实是这样,但单纯输出a+b时结果又是-14 很怪异 迷惑~~!

 

 

 

  1. 评价下面的代码片断:

unsigned int zero = 0;

unsigned int compzero = 0xFFFF;

如果碰巧int型是16位则上述代码没有问题,否则上面的代码不正确。应写成:unsigned
int compzero = ~0;

 

 

17 . 下面代码执行后a,b,c的值各是多少?

int a = 5, b = 7, c;

c = a+++b; // c = (a++)+b

a = 6, b = 7, c = 12. // 吾已试,结果确如此

 

 

 

  1. Typedef和#define的区别

#define在预编译的时候处理作机械的字符替换。Typedef在编译的时候处理,并不是作简单的字符替换。而是如同定义变量一样声明一个类型。然后用它去定义这种类型的变量。比如下面的例子:

 

#define dPS struct s *

typedef struct s * tPS;

以上两句都是定义dPS 和 tPS
为一个指向结构s的指针。 typedef更好。比如:

dPS p1,p2;

tPS p3,p4;

第一句扩展为struct s * p1, p2;

这条代码定义p1为指向结构的指针,p2为一个实际的结构体。第二句定义p3
和p4 为指向结构体s的指针。

 

 

 

Chapter2 编程类

1.
在字符串中找出所有与给定字符相同字符的位置。

#include <stdio.h>

char s[6]=”hello”;

void search_char(char given)

{

int i=0,j=0;

while(s[i]!=’’){

if(s[i]==given){

printf(“location = %dn”, i);

j++;

}

i++;

}

if(j==0)

printf(“No %c foundn”,given);

}

int main(void)

{

search_char(‘o’);

return 0;

}

 

 

  1. 将一个字符串自身逆序.

#include <stdio.h>

#define LEN 12

int main(void)

{

int m,i;

char temp;

char s[LEN]=”hello tiger”;

m=(LEN-1)/2;

printf(“%sn”,s);

for(i=0;i<m;i++){

temp=s[i];

s[i]=s[LEN-2-i];

s[LEN-2-i]=temp;

}

printf(“%sn”,s);

return 0;

}

 

 

  1. 链表的基本操作及链表自身逆序。

/*—- chain operate from Data Structure
—*/

#include <malloc.h>

#include <stdio.h>

#include <stdlib.h>

typedef int DataType;

typedef struct Node

{

DataType data;

struct Node *next;

}SLNode;

 

//—- initiate

void ListInitiate(SLNode **head)

{

if( (*head=(SLNode
*)malloc(sizeof(SLNode)))==NULL ) exit(1);

else printf(“OKn”);

(*head)->next=NULL;

}

 

//—- length cal

int ListLength(SLNode *head)

{

SLNode *p=head;

int size=0;

while(p->next!=NULL){

p=p->next;

size++;

}

return size;

}

//—-insert a node

int ListInsert(SLNode *head,int i,DataType
x)

{

SLNode *p,*q;

int j;

p=head;

j=-1;

while( (p->next!=NULL) && (j<(i-1)) )
{

p=p->next;

j++;

}

if(j!=(i-1)) {

printf(“Position errorn”);

return 0;

}

if((q=(SLNode
*)malloc(sizeof(SLNode)))==NULL)

exit(1);

q->data=x;

q->next=p->next;

p->next=q;

return 1;

}

//—-delete a node

int ListDelete(SLNode *head,int i,DataType
*x)

{

SLNode *p,*s;

int j;

p=head;

j=-1;

while((p->next!=NULL) &&
(p->next->next!=NULL) && (j<i-1) ){

p=p->next;

j++;

}

if(j!=i-1){

printf(“Position errorn”);

return 0;

}

s=p->next;

*x=s->data;

p->next=p->next->next;

free(s);

return 1;

}

//—– data get

int ListGet(SLNode *head,int i,DataType
*x)

{

SLNode *p;

int j;

p=head;

j=-1;

while((p->next!=NULL)&&(j<i)) {

p=p->next;

j++;

}

if(j!=i) {

printf(“Position errorn”);

return 0;

}

*x=p->data;

return 1;

}

//—-Destroy a chain

void Destroy(SLNode **head)

{

SLNode *p,*p1;

p=*head;

while(p!=NULL) {

p1=p;

p=p->next;

free(p1);

}

*head=NULL;

}

 

//—–converse a chain

void converse(SLNode *head)

{

SLNode *p,*q;

p=head->next;

head->next=NULL;

while(p!=NULL) {

q=p;

p=p->next;

q->next=head->next;

head->next=q;

}

}

 

//—- composite operation

int main(void)

{

SLNode *head;

int i,x;

ListInitiate(&head);

for(i=0;i<10;i++) {

if(ListInsert(head,i,i)==0){

printf(“Errorn”);

return 1;

}

}

 

if(ListDelete(head,0,&x)==0) //
chain,position,data address

{

printf(“Errorn”);

return 1;

}

if(ListInsert(head,0,100)==0) {

printf(“Errorn”);

return 1;

}

converse(head);

for(i=0;i<ListLength(head);i++) {

if(ListGet(head,i,&x)==0) //
chain,position,data address

{

printf(“Errorn”);

return 1;

}

else printf(“%d “,x);

}

printf(“n”);

Destroy(&head);

return 0;

}

 

 

 

  1. 写一个二分查找算法。

#include <stdio.h>

#define size 10

int g[size]={0,1,2,3,4,5,6,7,8,9};

int search(int x)

{

int low=0;

int high=size-1;

int mid;

while(low<=high) {

mid=(low+high)/2;

if(g[mid]==x)

return mid;

else if(g[mid]<x)

low=mid+1;

else if(g[mid]>x)

high=mid-1;

}

return -1;

}

//—-

int main(void)

{

printf(“%dn”,search(7));

return 0;

}

 

 

5.
计算一个字节里(byte)里面有多少bit被置1.

#include <stdio.h>

int cal_bit(char a)

{

int i,j=0;

for(i=0;i<8;i++) {

if((a&0x01)==0x01)

j++;

a=a>>1;

}

return j;

}

//–

int main(void)

{

printf(“%dn”,cal_bit(255));

return 0;

}

 

 

  1. 字符串转换为整数,比如”1234″转换成1234.

#include <stdio.h>

char str[6]=”12345″;

int string_to_int(char s[])

{

int i;

int sum=0;

for(i=0;s[i]!=’’;i++)

sum=sum*10+s[i]-‘0’;

return sum;

}

//—–

int main(void)

{

printf(“%dn”,string_to_int(str));

return 0;

}

 

 

  1. 整数转换为字符串,比如1234转换成”1234″.

#include <stdio.h>

#include <math.h>

#define LEN 4

char str[]=” “;

char *int_to_string(int given)

{

int i;

int temp;

for(i=0;i<LEN;i++) {

temp=given/pow(10,LEN-1-i); // 从最高位开始

given=given%((int) pow(10,LEN-1-i)); //int
mustbe on both side of ‘%’

str[i]=temp+’0′;

}

return str;

}

//—–

int main(void)

{

printf(“%sn”,int_to_string(9876));

return 0;

}

 

 

8.
C语言实现插入排序算法(从大到小,从小到大).

#include<stdio.h>

#define LEN 5

int a[LEN]={7,4,8,4,5};

void insertion_sort(void)

{

int i,j,key;

for(j=1;j<LEN;j++){

printf(“%d,%d,%d,%d,%dn”,a[0],a[1],a[2],a[3],a[4]);

key=a[j];

i=j-1;

while( (i>=0) && (a[i]>key) ){ //
a[i]>key 从小到大; a[i]<key 从大到小

a[i+1]=a[i];

i–;

}

a[i+1]=key;

}

printf(“%d,%d,%d,%d,%dn”,a[0],a[1],a[2],a[3],a[4]);

}

 

//—–

int main(void)

{

insertion_sort();

return 0;

}

 

 

9.
C语言实现冒泡排序算法(从大到小,从小到大)

#include<stdio.h>

#define LEN 5

int a[LEN]={5,4,3,2,1};

void bubble_sort(void)

{

int i,j,flag=1;

int temp;

for(i=1;(i<LEN)&&(flag==1);i++){

flag=0;

for(j=0;j<LEN-i;j++) {

if( a[j]>a[j+1] ){ //
a[j]>a[j+1]从小到大;a[j]<a[j+1] 从大到小

flag=1;

temp=a[j];

a[j]=a[j+1];

a[j+1]=temp;

}

}

printf(“%d,%d,%d,%d,%dn”,a[0],a[1],a[2],a[3],a[4]);

}

}

//——–

int main(void)

{

bubble_sort();

return 0;

}

 

 

  1. 在一个字符串中找一个字符串

 

 

 

 

  1. 计算一个数的阶乘

递归实现:

int factorial(int n)

{

if (n == 0)

return 1;

else {

int recurse = factorial(n-1);

int result = n * recurse;

return result;

}

}

 

循环实现:

int factorial(int n)

{

int result = 1;

while (n > 0) {

result = result * n;

n = n – 1;

}

return result;

}

 

 

 

12.用嵌套循环求1-100的素数

#include <stdio.h>

int main(void)

{

int i, j;

for (i = 1; i <= 100; i++) {

for (j = 2; j < i; j++)

if (i % j == 0)

break;

if (j == i)

printf(“%dn”, i);

}

return 0;

}

 

 

 

 

 

 

 

  1. 打印菱形图案

void Damond(int L, char ch){ int n, j, k, i;
for(n=1;n<=L/2+1;n++)

{

for(j=0;j<L/2+1-n;j++)

printf(” “);

for(k=1;k<=2*n-1;k++)

printf(“%c”, ch);

printf(“n”);

}

 

for(i=L-n+1;i>=1;i–)

{

for(j=0;j<n-i-1;j++)

printf(” “);

for(k=1;k<=2*i-1;k++)

printf(“%c”, ch);

printf(“n”);

}

}

 

 

  1. 删除一个字符串中的指定字符。

#include <stdio.h>

void del_char(char *p, char ch)

{

char *pch;

while (*p != ‘’) {

if (*p == ch) {

for (pch = p; *pch != ‘’; pch++)

*pch = *(pch+1);

}

else

p++;

}

}

 

int main(void)

{

char ch;

char a[] = “hello world”;

scanf(“%c”, &ch);

 

del_char(a, ch);

printf(“%sn”, a);

}

 

 

 

  1. 统计一个字符串中子字符串的个数

#include <stdio.h>

#include <string.h>

int main(void)

{

int i, j, k;

int num = 0;

int len1, len2;

char str1[80], str2[10];

scanf(“%s”, str1);

scanf(“%s”, str2);

 

len1 = strlen(str1);

len2 = strlen(str2) – 1;

 

for (i = 0; i < len1 – len2; i++) {

for (j = 0, k = i; str2[j] == str1[k];
k++, j++)

{

if (j == len2)

num++;

}

}

printf(“%dn”, num);

}

 

 

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图