用冒泡法进行链表排序

[xiao_xiao_zi]

Node *ListSort(Node *&h)
{

}

[wanjingwei]

node* p=(node*)malloc(sizeof(node));
node* q=(node*)malloc(sizeof(node));
p=head;//头结点
for(p;p->next!=NULL;p=p->next)//冒泡排序
for(q=p->next;q!=NULL;q=q->next)
{
if(p->value>=q->value)
{
int temp=p->value;
p->value=q->value;
q->value=temp;

}
}

[zjutyww]

好像诺西笔试考过这个

[zjutyww]

楼上的有问题:结点排序 不是里面的值换下
node* p=(node*)malloc(sizeof(node));
node* q=(node*)malloc(sizeof(node));
p=head;//头结点
for(p;p->next!=NULL;p=p->next)//冒泡排序
for(q=p->next;q!=NULL;q=q->next)
{
if(p->value>=q->value)
{
node* temp=p;
temp->next = q->next;
q=temp;
q->next =temp;



}
}

[cheng_fengming]

[Quote=引用 3 楼 zjutyww 的回复:]
楼上的有问题:结点排序 不是里面的值换下
node* p=(node*)malloc(sizeof(node));
node* q=(node*)malloc(sizeof(node));
    p=head;//头结点
for(p;p->next!=NULL;p=p->next)//冒泡排序
for(q=p->next;q!=NULL;q=q->next)
{
if(p->value>=q->value)
{
    node* temp=p;
    temp->next = q->next;
    q=temp;
    q->next =temp;
     
     

}
}

[/Quote]
这个要看具体的要求了，简单的做法可以只是把里面的值交换一下
要是结点本身交换（即结点得地址变了，而内容不变），这个就比较麻烦了。

[猫已经找不回了]

http://www.cnblogs.com/smile2you/archive/2009/03/12/1409982.html

[猫已经找不回了]

// LinkListSort.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "stdlib.h"

typedef int DataType;

typedef struct node
{
   DataType data;
   struct node *next;
}LinkNode;

LinkNode* Insert(DataType data,LinkNode *h);
//没有带头节点
LinkNode* CreateLinkList(int num)
{
   
   LinkNode *h;
   h=(LinkNode*)malloc(sizeof(LinkNode));
   h->next=NULL;
   return h;
}
/*
  向链表中出入数据
  参数为链表的头节点，和待插入的节点的数据
*/
LinkNode* Insert(DataType data,LinkNode *h)
{
   LinkNode *p=h,*pr;
   LinkNode *q;
  
   q=(LinkNode*)malloc(sizeof(LinkNode));

   q->data=data;  
   q->next=h->next;
   h->next=q;

  
   return h;
}
/*
显示链表的数据
*/
LinkNode* ShowLinkList(LinkNode *h)
{
    LinkNode *p=h;
    printf("\n");
    while(p!=NULL)
    {
    printf("%d-",p->data);
      p=p->next;
    }
    return h;
}

//链表实现冒泡排序- 从小到大
LinkNode* SortLinkList(LinkNode *h)
{

    LinkNode *hh=h,*pr,*p,*pp,*ppr,*temp,*ph;

    DataType min;
    int flag=1; //是否是头一次的节点
    ph=h;

    while(h!=NULL)
    {
        
    
            min=h->data;        
            p=h;
            pr=p;           
            ppr=pr;
            pp=p;
         /*
           排好顺序的链表为头节点hh开头，每次都从h节点开头的
           链表冒泡出数值最小的节点，接到hh链表开头的链表尾部。
           
         */

            //开始冒泡
            while(p!=NULL)
            {
                if(p->data<min) //找出 节点值数据最小的节点
                {    
                    ppr=pr;   //最小节点的父节点
                    pp=p;     //最小节点
                    min=p->data;  //节点的最小数值
                }
                pr=p;
                p=p->next;
            }        

           /*
             找到h节点之后，数值最小的节点， pp代表该最小节点
             ppr为pp的先驱节点
           */

            if(ppr==pp)
            {            
                h=pp;
                ph->next=h;
                if(flag==1)  //在还未建立头节点时，先建立头节点，hh代表该头节点
                {
                   hh=h;flag=0; //头节点h之前的节点都是已经按从小到达的顺序排好顺序的节点，
                }    
            }else
            {    
                /*
                 如果最小节点不是头节点p的后驱节点的话
                 就把头节点h和最小数值节点兑换
                */
                if(h!=ppr)
                {
                    /*
                      交换节点 h和pp
                      用到两个的节点的先驱节点ph和ppr
                    */
                temp=h->next;
                ppr->next=h;
                h->next=pp->next;            
                pp->next=temp;                                       
                h=pp;

                if(flag==1){hh=h;flag=0;}
                else
                {
                  ph->next=h;
                }

                }else
                {  /*
                     如果最小节点p是头节点h的后驱节点的话
                     调换两个节点
                   */
                    h->next=pp->next;
                    pp->next=h;
                    h=pp;
                    if(flag==1){hh=h;flag=0;}
                    else{
                        ph->next=pp;
                    }
                }            
                
                
        }    

        ph=h;//ph为头节点h移动时的先驱节点
        h=h->next;
    }

    

    return hh;
}

int _tmain(int argc, _TCHAR* argv[])
{
     LinkNode *h;
     h=CreateLinkList(10);
     h->data=3;
     Insert(1,h);
     Insert(2,h);
     Insert(8,h);

      Insert(3,h);
      Insert(4,h);
      Insert(5,h);
      Insert(8,h);
      Insert(5,h);
      Insert(45,h);
      Insert(40,h);
      Insert(5,h);
      
      ShowLinkList(h);

     h=SortLinkList(h);
     
     ShowLinkList(h);

    return 0;
}

[井白人]

ding

[suchx]

快速排序吧，冒泡法很慢的

[Steven_0610]

学习

[jiayucunyan]

两种做法

一种是交换节点内的值，
一种是交换节点指针。

都可以实现

不过，冒泡排序没有什么实用价值

[hemy818]

面试的时候让你任选一算法 对 10个数排序
你会放弃冒泡吗 ？

[hsnxyc]

min=h->data;
p=h;
pr=p;
ppr=pr;
pp=p;
这段代码具体是怎样交换指针的