2.2作业

1、写一个宏，可以将一个int型整数的二进制位的奇数位和偶数位交换

2、递归实现字符串逆置

 void func (char *src)
{
	if (strlen(src) == 0)
	{
		return;
	} 
	else
	{ 
		func(&src[1]);
		printf("%c", src[0]);
	}
}
int main(int argc, const char *argv[])
{ 
	char *s = "abcdefg";
	func(s);
	printf("\n");
	return 0;
}

3、下面程序的输出是（D）

Void main( )

{

Unsigned char ucNum;

For (ucNum = 0; ucNum < 500; ucNum++){

......

}

Printf(“%d”, ucNum);
}

499 B. 500 C. 501 D. 无输出

无输出，ucNum是一个无符号字符类型，取值范围是0~255，一直在执行循环

4、子网掩码255.255.192.0对于一个网络来说，网络容量是多大（）

A．192

B．254

C．192*254

D．64*254

1100 0000 0000 0000 2^6*(2^8-2) 减去网关和广播地址

5、在bash shell中，假设str=abc,请写出以下的输出的结果：

（1）echo “$str”

（2）echo ’$str’

（3）echo “’$str’”

1） abc

2）$str

3） 'abc'

1、bash中的特殊符号

①$：使用变量的前导符

②“ ”：具有变量置换的功能

③‘ ’:两个“”中间为可以先执行的命令

2、shell字符串

字符串可以用单引号，也可以用双引号

单引号 str='this is $a'，即使存在变量a，这句话执行结果也还是this is $a,单引号里的任何字符都会原样输出，单引号字符串中的变量是无效的

双引号 str = "this is $a"，如果a变量值是world，那么这句话执行结果将是this is world，双引号的优点是可以有变量，双引号里可以出现准义

6、进程的写时拷贝

7、使用信号回收僵尸进程

1> 当子进程结束时，会向父进程发送一个SIGCHLD信号

2> 如果使用阻塞形式回收僵尸进程那么会造成可能因等待某个进程的退出导致其他子进程资源无法及时回收

3> 此时我们可以采用非阻塞的形式回收，如果单纯使用非阻塞形式回收，如果子进程没有退出，则该回收函数立即结束

4> 我们可以将信号与处理函数结合使用，捕获SIGCHLD信号，并在该信号处理函数中，以非阻塞的形式循环回收僵尸进程

8、链表逆置

Linklist rev_linklist(Linklist head)
{
    //1,判断长度是否小于等于1
    if(NULL ==head || NULL ==head->next)
    {
        return head;
    }
    //2,逆置
    Linklist p=head->next;
    head->next=NULL;
    while(p!=NULL)
    {
        Linklist t=p;
        p=p->next;
        t->next=head;
        head=t;
    }
    return head;
}

9、约瑟夫环

Linklist joseph(Linklist head,int n,int m)
{
    Linklist p=head;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m-2;j++)
        {
            p=p->next;
        }
        //删除p的后继节点
        Linklist del=p->next;
        printf("%-4d",del->data);
        p->next=del->next;
        free(del);
        del=NULL;
        p=p->next;
    }
    head=NULL;
    return NULL;

}

10、简单选择排序

int arr[]={12,34,23,4,665,23,6};
    int n=sizeof(arr)/sizeof(arr[0]);
    
    int min;
    for(int i=0;i<n-1;i++)//循环轮数，表示也是默认最值的下表
    {
        min=i;//默认第一个值的下表值最值下表
        for(int j=i+1;j<n;j++)//循环默认值的后面的所有下表
        {
            if(arr[min] <arr[j])
            {
                min=j;
            }
        }
        if(min!=i)
        {
            int t=arr[min];arr[min]=arr[i];arr[i]=t;
        }
    }

    for(int i=0;i<n;i++)
    {
        printf("%d ",arr[i]);
    }

11、快排

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//一次排序：确定基准值的位置，返回基准值的下表
int once_sort(int arr[],int low,int high)
{
    //确定基准值，默认low对应的值
    int key=arr[low];

    while(low<high)
    {    
        while(low<high && key <= arr[high])
            high--;
        //把high对应的值赋值给low
        arr[low]=arr[high];

        //掉换方向从loe开始比较
        while(low<high && key>=arr[low])
            low++;
        //把low对应的值赋值给high
        arr[high]=arr[low];
    }
    //把基准值存到low或high
    arr[low]=key;
    return low;
}

//快速排序
void quick_sort(int arr[],int low,int high)
{
    //如果low==high  有一个元素
    //如果low>high   没有元素
    //如果low<high   快速排序
    if(low>=high)
        return;

    //一次排序
    int mid=once_sort(arr,low,high);
    //递归左边
    quick_sort(arr,low,mid-1);
    //递归右边
    quick_sort(arr,mid+1,high);
}

int main(int argc, const char *argv[])
{
    int arr[]={12,43,654,234,76,45,87};
    int len=sizeof(arr)/sizeof(arr[0]);
    quick_sort(arr,0,len-1);

    for(int i=0;i<len;i++)
    {
        printf("%-4d",arr[i]);
    }
    return 0;
}

12、插入排序

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void insert_sort(int arr[],int len)
{
    int j;
    for(int i=1;i<len;i++)//循环无序区的下表
    {
        int t=arr[i];//保存无序区的第一个元素
        for(j=i-1;j>=0;j--)
        {
            if(t < arr[j])
            
                arr[j+1]=arr[j];
            else
                break;
        }
        //在j+1下表插入t
        arr[j+1]=t;
    }

}
int main(int argc, const char *argv[])
{
    int arr[]={12,34,546,34,76,34,7};
    int len=sizeof(arr)/sizeof(arr[0]);
    insert_sort(arr,len);
    for(int i=0;i<len;i++)
    {
        printf("%d\t",arr[i]);
    }
    return 0;
}

13、循环输入一维数组，交换最小值，和第二大值{不允许使用排序}

int arr[]={12,34,54,76,6,76,34,2};
                         
    int n=sizeof(arr)/sizeof(arr[0]);
    //计算最大值和最小值
    int first_max=arr[0],first_min=arr[0];
    int first_maxi=0,first_mini=0;
    for(int i=0;i<n;i++)
    {
        if(first_max<arr[i])
        {
            first_max=arr[i];
            first_maxi=i;
        }
        if(first_min>arr[i])
        {
            first_min=arr[i];
            first_mini=i;
        }
    }
    //计算第二大
    int second_max=first_min;
    int second_maxi=0;
    for(int i=0;i<n;i++)
    {
        if(i==first_maxi)
            continue;
        if(second_max<arr[i])
        {
            second_max=arr[i];
            second_maxi=i;
        }
    }
    arr[first_mini]=second_max;
    arr[second_maxi]=first_min;

    for(int i=0;i<n;i++)
    {
        printf("%d ",arr[i]);
    }

14、