flag=0;
            }
            q=p;
            p=p->next;
        }   
    }

}
void LNodeFind_1(struct LNode *Head)//first one out
{
    struct LNode *p,*q,*r;
    p=q=Head;
    while(p->next!=NULL)
    {
        if(q->next->data<p->next->data)
            q=p;
        p=p->next;
    }
    if(q->next!=p)
    {
        r=q->next;
        q->next=r->next;
        p->next=r;
        p=r;
        p->next=NULL;
    }

}
void main()
{
    struct LNode *Head,*p;
    Head=CreateLinklist();
//    LNodeFind(Head);
    LNodeFind_1(Head);
    printf("\n移动后的结果为\n");
    p=Head->next;
    while(p)
    {
        printf("%-4d",p->data);
        p=p->next;
    }
    printf("\n");
}

简洁版本//好方法，多学习一下
void movemax(node *L)
{
    node *p = L->next, *pre = L, *max = p;
    while (p)
    {
        if (p->data>max->data)max = p;
        pre = p;
        p = p->next;
    }
    int temp = pre->data;
    pre->data = max->data;
    max->data = temp;//交换结点的数值就可以了，没必要交换结点
}
15、编写一个函数，把整数序列分成两个部分，使得左边部分都不大于右边部分，不需要排序。 （ 考察的是快速排序的部分）
#include <stdio.h>
void partition(int A[],int n)
{
    int pivot=A[0];
    int low=0,high=n-1;
    while(low!=high)
    {
        while(low<high&&A[high]>=pivot)
            --high;
            A[low]=A[high];
        while(low<high&&A[low]<=pivot)
            ++low;
            A[high]=A[low];
    }
    A[low]=pivot;
}
void main()
{
    int i,A[5]={10,1,9,7,8};
    partition(A,5);
    for(i=0;i<5;i++)
    printf("%-4d",A[i]);
    printf("\n");

}
16编写一个函数，删除链表中的最小值。（结点node由整型data和节点指针next构成）
void delmin(node *L)
{
    node *p=L->next, *pre=L;
    node *min=p, *minpre=L;
    while(p)
    {
        if(p->data < min->data)
        {
            min = p;
            minpre = pre;
        }

        pre = p;
        p = p->next;
    }
    minpre->next = min->next;
    free(min);
}
17、有两个整数数组A和B，它们分别有m、n个整数。并且都是按非递减序列，现将B数组插入A数组中，使得A数组中各元素不大于B数组中各元素，且还是非递减序列。
#include <stdio.h>
int ArrayOrder(int a[],int b[],int m,int n)
{
    int i,j;
    for(i=0;i<m&&i<n;i++)
    {
        if(a[i]>b[i])
        {
            a[i]=b[i];
        }
    }
    if(m<n)
    {
        for(i=m;i<n;i++)
            a[i]=b[i];
    }
       
    return m<n?n:m;

}
void main()
{
    int a[30],b[30];
    int i,m,n,len;
    printf("请输入两个数组分别的个数,以空格隔开\n");
    scanf("%d %d",&m,&n);
    printf("第一个数组输入：\n");
    for(i = 0;i < m;i ++)
        scanf("%d",&a[i]);
    printf("第二个数组输入：\n");
    for(i = 0;i < n;i ++)
        scanf("%d",&b[i]);
    len=ArrayOrder(a,b,m,n);
    for(i=0;i<len;i++)
    printf("%-4d",a[i]);
    printf("\n");
    for(i=0;i<n;i++)
    printf("%-4d",b[i]);
    printf("\n");
}


18、两个递增有序整数数列链表La和Lb，将他们合并后，变成一个新的链表，要求该链表递减排序。（结点node由整型data和节点指针next构成）
#include <stdio.h>
#include <malloc.h>
#define N 5
struct Node{
    int data;
    struct Node *next;
};
struct Node * CreateLinklist()
{
    struct Node *p,*Head,*q;
    int i,temp;
    Head=(struct Node *)malloc(sizeof(struct Node));
    q=Head;
    printf("建立单链表,输入%d个数据:\n",N);
    for(i=0;i<N;i++)
    {
        scanf("%d",&temp);
        p=(struct Node *)malloc(sizeof(struct Node));
        p->data=temp;
        q->next=p;
        q=p;
    }
    q->next=NULL;
    return Head;
}
struct Node * ReverseLinklist(struct Node * Head)
{
    struct Node *p,*q;
    p=Head->next;
    Head->next=NULL;
    while(p)
    {
        q=p->next;
        p->next=Head->next;
        Head->next=p;
        p=q;
    }
    return Head;
   
}
struct Node * MergeList(struct Node *list1,struct Node *list2)
{
    struct Node * list3,*r,*la=list1->next,*lb=list2->next;
    list3=(struct Node*)malloc(sizeof(struct Node));
    r=list3;
    if(la->data<=lb->data)
    {
        r->next=la;
        r=la;
        la=la->next;
    }
    else
    {
        r->next=lb;
        r=lb;
        lb=lb->next;
    }
    while(la&&lb)
    {
        if(la->data<=lb->data)
        {
            r->next=la;
            r=la;
            la=la->next;
        }
        else
        {
            r->next=lb;
            r=lb;
            lb=lb->next;