SWUST OJ 960: 双向链表的操作问题

先给代码，然后再分析一下两个排序方法
题目描述
建立一个长度为n的带头结点的双向链表，使得该链表中的数据元素递增有序排列。（必须使用双向链表完成，数据类型为整型。）
输入
第一行：双向表的长度；
第二行：链表中的数据元素。
输出
输出双向链表中的数据元素的值。
样例输入
10
2 4 6 3 5 8 10 21 12 9
样例输出
2 3 4 5 6 8 9 10 12 21

/*双向链表的操作问题*/
 #include 
 #include 
 
 typedef struct DLNode
 {
     int data;
     struct DLNode *prior,*next;
 }DLinkList;
 
 void InitList(DLinkList *&L)
 {
     L =(DLinkList*)malloc(sizeof(DLinkList));
     L->prior = L;
     L->next = L;
 }
 
 void CreateList(DLinkList *&L, int n)
 {
     DLinkList * p,*r;
     r = L;
     for(int i=0; i < n; ++i)
     {
         p =(DLinkList*)malloc(sizeof(DLinkList));
         scanf("%d",&p->data);
         p->next = r->next;
         r->next->prior = p;
         r->next = p;
         p->prior = r;//四条线 
         L->prior = p;
         r = p;
     }
 }
 
 void Dis(DLinkList *L)
 {
     DLinkList *r;
     r = L;
     while(r->next!=L)
     {
         r = r->next;
         printf("%d ",r->data);
     }
 }
 

void sor(DLinkList *&L,int n)//排序
{
	int i,j,temp;
	int count=n;
	DLinkList *p=L; 
	DLinkList *min,*max; 
	p=p->next;
	for(i=1;inext;
				if(p->datadata)
				{
					temp=min->data;
					min->data=p->data;
					p->data=temp;
				}
			}
			n--;
		}
		else//第偶数遍正向
		{
			max=p;
			for(j=1;jprior;
				if(p->data>max->data)
				{
					temp=max->data;
					max->data=p->data;
					p->data=temp;
				}
			}
			n--;
		}
	}
}
 
 int main(int argc, char const *argv[])
 {
     DLinkList * L;
     int n;
     scanf("%d",&n);
     InitList(L);
     CreateList(L,n);
     sor(L,n);
     Dis(L);
     ;
 }

排序方法
1.冒泡排序的两种形式
我觉得冒泡排序就是每一次循环都有一个极值会向泡泡一样冒出来。以从小到大排序为例，我们常用的是依次比较两个相邻的元素如果低位比高位大则交换顺序，这个比较并交换的过程就是泡泡上浮的过程，经过一次遍历后最大值就会在数组的最右边，不断循环即可将实现从小到大排序的结果。
代码如下：

 void sor(DLinkList *&L,int n)
 {
     DLinkList *f,*s;
     int tem;
     f = L->next;
     s = f->next;
     for(int i=1;idata > s->data)
             {
                 tem = f->data;
                 f->data = s->data;
                 s->data = tem;
             }
             s = s->next;
             f = f->next;
         }
        
 
         f = L->next;
         s = f->next;
     }
 }

第二种冒泡排序也是通过比较和交换来实现冒泡过程的，只不过比较和交换的两个对象不是相邻元素。而是通过固定一个元素的位置，并将该元素与其右侧或左侧所有元素进行比较和交换。

  void sor(DLinkList *&L)
 {
     DLinkList *f,*s;
     int tem;
     f = L->next;
     s = f->next;
     while(f!=L)
     {
         while(s!=L)
         {
             if (f->data > s->data)
             {
                 tem = f->data;
                 f->data = s->data;
                 s->data = tem;
             }
             s = s->next;
         }
 
         f = f->next;
         s = f->next;
     }
 }

2.奇偶排序
奇偶排序法也可以算成冒泡排序，当i为奇数时，从左到右固定一个元素进行比较、交换，当i为偶数时，从右到左进行比较交换。

void sor(DLinkList *&L,int n)//排序
{
	int i,j,temp;
	int count=n;
	DLinkList *p=L; 
	DLinkList *min,*max; 
	p=p->next;
	for(i=1;inext;
				if(p->datadata)
				{
					temp=min->data;
					min->data=p->data;
					p->data=temp;
				}
			}
			n--;
		}
		else//第偶数遍正向
		{
			max=p;
			for(j=1;jprior;
				if(p->data>max->data)
				{
					temp=max->data;
					max->data=p->data;
					p->data=temp;
				}
			}
			n--;
		}
	}
}