c练习

一、编码实现某一变量某位清 0 或置 1。假如：给定一个整形变量 a，写两段代码，第一个 设置 a 的 bit3，第二个清 a 的 bit3，在以上两个操作中要保持其他位不变。

int set_one(int a, int n) 
{
    int temp = 1;
    temp = temp << (n - 1);
    return (a | temp); 
}

int empty_zero(int a, int n)
{
    int temp = 1;
    temp = temp << (n - 1);
    temp = ~temp;
    return (a & temp);
}

二、一个链表的结点结构 Typedef struct node { Int data; Struct node *next; }Node, *Head; (1) 已知链表的头结点 head,写一个函数把这个链表逆序（递归实现）。

（2）已知两个链表 head1 和 head2 各自有序，请把他们合并成一个链表依然有序。 递归实现：
非递归实现：
（3）如何判断一个单链表是否有环（注意不能用标志位，最多只能用两个额外指针）存在 返回 1，否则返回 0.
/***************************************************************

File Name: 3.c
Author:
Mail:
Created Time: Fri 01 Apr 2016 05:19:05 AM EDT
**************************************************************/

#include<stdio.h>
#include<stdlib.h>

typedef struct node
{
    int num;
    struct node *next;
}Node, *Head;

int headinsrt(Head *head, Head *p)
{
    (*p)->next = *head;
    *head = *p;
    return 0;
}


int middleinsert(Head *head, Head *p)
{
    Head tmp = *head;
    Head pre = *head;
    if(NULL == *head)
    {
        *head = *p;
        return 0;
    }
    while(NULL != tmp && (*p)->num > tmp->num)
    {
        pre = tmp;
        tmp = tmp->next;
    }
    if(tmp == *head)
    {
        (*p)->next = *head;
        *head = *p;
    }
    else
    {
        (*p)->next = tmp;
        pre->next = *p;
    }
    return 0;
}
int Create(Head *head)
{
    while(1)
    {
        Head p = (Head)malloc(sizeof(Node));
        if(NULL == p)
        {
            printf("malloc failed\n");
            return 1;
        }
        printf("please input num:\n");
        scanf("%d", &p->num);
        p->next = NULL;
//        headinsrt(head, &p);
        middleinsert(head, &p);
        if((p->num) <= 0)
        {
            return 0;
        }
    }

}
int Output(Head head)
{
    while(NULL != head)
    {
        printf("%d-->", head->num);
        head = head->next;
    }
    printf("\b\b\b   \n");
}

Head Merge(Head *head1, Head *head2)
{
    Head head = NULL;
    Head tmp = NULL;
    if(NULL == *head1)
    {
        return *head2;
    }
    if(NULL == *head2)
    {
        return *head1;
    }

    while(NULL != *head1 && NULL != *head2)
    {
        if((*head1)->num < (*head2)->num)
        {
            if(NULL == head)
            {
                head = *head1;
                tmp = *head1;
            }
            else
            {
                tmp->next = *head1;
                tmp = *head1;
            }    
            *head1 = (*head1)->next;
        }
        else
        {
            if(NULL == head)
            {
                head = *head2;
                tmp = *head2;
            }
            else
            {
                tmp->next = *head2;
                tmp = *head2;
            }
            *head2 = (*head2)->next;
        }
    }
    if(NULL == *head1)
    {
        tmp->next = *head2;
    }
    else
    {
        tmp->next = *head1;
    }
    return head;
}

Head Rmerge(Head head1, Head head2)
{
    Head head = NULL;
    if(NULL == head1)
    {
        return head2;
    }
    if(NULL == head2)
    {
        return head1;
    }
    if(head1->num < head2->num)
    {
        head = head1;
        head->next = Rmerge(head1->next, head2);
    }
    else
    {
        head = head2;
        head->next = Rmerge(head1, head2->next);
    }
    return head;
}

//3判断是否有环
int Judge(Head head)
{
    if(NULL == head)
    {
        printf("NULL\n");
        return 0;
    }
    Head last = head;
    Head fast = head;
    while(NULL != fast && NULL != fast->next)
    {
        last = last->next;
        fast = fast->next->next;
        if(fast == last)
        {
            return 1;
        }

    }
    return 0;
}

//1逆序
Head Reverse(Head head)
{
    if(NULL == head)
    {
        return NULL;
    }
    Head tmp = NULL;
    Head nhead = NULL;
    while(NULL != head)
    {
        tmp = head->next;
        head->next = nhead;
        nhead = head;
        head = tmp;
    }
    return nhead;
}

Head RRverse(Head head, Head nhead)
{
    Head tmp = head->next;
    head->next = nhead;
    nhead = head;
    head = tmp;
    return NULL == head ? nhead : RRverse(head, nhead); 
}
int main()
{
    Head head1 = NULL;
    Head head2 = NULL;
    Head nhead = NULL;
    Create(&head1);
    Output(head1);
    Create(&head2);
    Output(head2);

//   Head head = Merge(&head1, &head2);
    Head head =  Rmerge(head1,head2);
    Output(head);
    printf("%d\n", Judge(head));
    head = RRverse(head, nhead);
    Output(head);

    head = Reverse(head);
    Output(head);
    return 0;

}

三、有一组有序的 int 型数据，实现 int contain(int *values, int size, int key)接口用于判断该序 列中 key 是否存在，存在返回 1,否则返回 0。

/*************************************************************************
    > File Name: 2.c
    > Author: 
    > Mail: 
    > Created Time: Fri 01 Apr 2016 05:06:35 AM EDT
 ************************************************************************/

#include<stdio.h>

int contain(int *values, int size, int key)
{
    int head = 0;
    int tail = size - 1;
    int mid = 0;

    while(head <= tail) //=考点
    {
        mid = (head + tail) / 2;
        if(values[mid] == key)
        {
            printf("yes\n");
            return 1;
        }
        if(values[mid] > key)
        {
            head = mid + 1;
        }
    else
        {
            tail = mid - 1;
        }
    }
    return 0;
}

int main()
{
    int a[5] = {1, 3, 4, 6, 8};
    int key = 0;
    int size = 5;
    printf("input  key:\n");
    scanf("%d",&key);
    contain(a, size, key);
    return 0;
}

四、交换两个整型， 不用中间变量

//fun 1
a = a + b;
b = a - b;
a = a - b;

//fun2
a ^= b;
b ^= a;
a ^= b;