Sort调试通过的

typedef struct _tagStudentInfo
{
	int ID;
	char * name;
	int tel;
}StudentInfo,*stu;

typedef struct linknode
{
	int number;
	struct linknode *pNext;
}linknode,*nodetype;

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

//
/*
目前测试，结点的结构体只放了个number
*/
//


/*插入排序主例程*/ 

nodetype OrderList(nodetype pHead) 
{ 
    nodetype guard,pChoosedNode,pPreChoosedNode; /*pChoosedNode用来指向需要插入的结点，pPreChoosedNode用来指向pChoosedNode的前一个结点*/ 
    //for(pPreChoosedNode=pHead,pChoosedNode=pHead->pNext;pChoosedNode!=NULL;) 
	pPreChoosedNode=pHead,pChoosedNode=pHead->pNext;
	while(NULL!=pChoosedNode)
    { 
          guard=pHead; /*guard用来遍历寻找合适的插入位置*/ 
          //for(;guard!=pChoosedNode;guard=guard->pNext) 
		  while(guard!=pChoosedNode)
          { 
                 if(guard->pNext->number > pChoosedNode->number)/*如果找到，即把pChoosedNode所指向的结点插到guard后面，然后跳出循环*/ 
                { 
                   pPreChoosedNode->pNext=pChoosedNode->pNext; 
                   pChoosedNode->pNext=guard->pNext; 
                   guard->pNext=pChoosedNode; 
                   pChoosedNode=pPreChoosedNode->pNext; 
                   break; /*别忘了此处的break*/ 
                } 
				guard=guard->pNext;
          } 

          if(guard==pChoosedNode)/*此处需要注意，只在pChoosedNode所指结点不需要前插时，移动pChoosedNode和pPreChoosedNode*/ 
         { 
              pChoosedNode=pChoosedNode->pNext; 
              pPreChoosedNode=pPreChoosedNode->pNext; 
         } 
     } 
	 return pHead;
} 

// OK  创建单链表
nodetype CreateList()
{
	//声明指针变量pHead，用于保存头结点指针
	nodetype pHead;
    //分配头结点内存，并将返回指针赋给pHead
	pHead = malloc(sizeof *pHead); 
	//将pHead->data.id置为-1
	//将pHead的next置为NULL
	pHead->pNext = NULL;
	return pHead;
}

// OK  输出整个单链表的内容,pHead为头结点指针 
void Printlist(nodetype pHead)
{
	//声明一个指针变量Node，用于保存链表的当前结点
	nodetype pNode;
	//将pNode赋值为输入参数pHead->pNext
	pNode = pHead->pNext;
	//循环读取pNode->data字段的值，知道pNode为空指针
	while(pNode)
	{
		printf("The number is %d\n",pNode->number);
		//将pNode赋值为pNode->pNext
		pNode = pNode->pNext;
	}
}

// OK  计算单链表的长度，pHead为头结点指针
int GetListLen(nodetype pHead)
{
	//声明一个整形变量i，用于保存链表长度
	int i = 0;
	//声明一个指针变量pNode，用于保存链表的当前结点
	nodetype pNode = NULL;
	//将pNode赋值为输入参数pHead
	pNode = pHead;
	//循环读取pNode，直到pNode为空指针
	while(pNode)
	{
		i = i + 1;
		pNode = pNode->pNext;
	}
	return i;
}

// OK  查找学生ID为stuID的结点，pHead为头结点指针，stuID为学生ID
nodetype FindNodeByStuID(nodetype pHead,int stuID)
{
	//声明一个指针变量pNode，用于保存链表的当前结点
	nodetype pNode = pHead;
	//循环读取pNode->data中，iID字段的值，直到pNode为空指针
	while(pNode)
	{
		//如果pNode->data.ID等于 i
		if(pNode->number==stuID)
		{
			//则推出循环;
			break;
		}
		//将pNode赋值为pNode->pNext;
		pNode = pNode->pNext;
	}
	//返回pNode
	return pNode;
}

//在制定的学生ID结点后插入一个结点，pHead为头结点指针，iStuID为学生ID，pStudentInfo为结点值指针
// OK  nodetype InsertNode(nodetype pHead,int iStudID,StudentInfo * pStudentInfo)
nodetype InsertNode(nodetype pHead,int iStudID)
{
	//声明两个指针变量pNode,pNewNode,分别用于保存当前结点和新分配的结点指针
	nodetype pNode = NULL;
	nodetype pNewNode = malloc(sizeof *pNewNode);
	pNewNode->pNext = malloc(sizeof *(pNewNode->pNext));
	//找到值为iStudID的结点指针，并保存到pNode
	pNode = FindNodeByStuID(pHead,iStudID);
	//将pNode->pNext赋值为pNewNode,感觉有问题
	//pNewNode = pNode->pNext;
	pNewNode->pNext = pNode->pNext;
	pNode->pNext = pNewNode;
	pNewNode->number = 2010;
	//将pNewNode->pNext赋值为空,感觉有问题
//	pNewNode->pNext = NULL;
	//将pStudentInfo赋值给pNewNode的data域
	//返回pHead
	return pHead;
}


//在量表尾部插入一个结点，pHead为头结点指针，pStudentInfo为节点值指针
/*单链表插入排序的测试例程*/ 

int main(void) 
{ 

     /*构造一个包含头节点的单链表*/ 
     nodetype head = malloc(sizeof *head); 
     nodetype p = head;
	 nodetype test = NULL;
     int i=0; 
	 //int result = 0;

     while(i<6) 
    { 
         p->pNext = malloc(sizeof *head); 
         p = p->pNext; 
         p->number = rand()%100; 
         printf("%d",p->number); 
         p->pNext = NULL; 
         i++; 
    } 

    printf("\n"); 

	//Printlist(head);
	//CreateList();
	//result = GetListLen(head);
	//printf("result ========= %d\n",result);
	//test = FindNodeByStuID(head,34);
	test = InsertNode(head,34);

    /*插入排序*/ 
   // OrderList(head); 


    /*输出排序后的链表*/ 
    p=head->pNext; 
    while(p!=NULL) 
   { 
       printf("%d ",p->number); 
       p=p->pNext; 
   } 

   /*释放内存*/ 
    while(head) 
   { 
    p=head; 
    head=head->pNext; 
    free(p); 
   } 


    return 0; 
}