单链表的基本操作（建立，输出及排序）

今天总结了一下单链表的基本操作：建立，求长度，输出结点，排序（冒泡及归并）

#include <iostream>
#include <stdio.h>

using namespace std;
struct ListNode
{
  int data;
  ListNode *next;
};
//尾插法，新建一个链表
ListNode *creatList( )
{
    ListNode *head,*p,*s;
    int x,cycle=1;
    head=new ListNode();//新建头结点,
    p=head;//p指向头结点
    while(cycle)//当输入0时，停止链表的建立
    {
        printf("\nPlease input the data:");
        scanf("%d",&x);//输入结点值
        if(x!=0)
        {
          s=new ListNode();//新建结点s
          s->data=x;//结点s的结点值为输入值x

          printf("\n%d",s->data);

          p->next=s;//将新建结点插入链表
          p=s;//更新链表结点
        }
        else
            cycle=0;
    }
    //head=head->next;//head指向第一个节点
    p->next=NULL;//尾指针
    //printf("\n %d",head->data);//输出头结点
    printf("\n");
    return head;
}
//求链表长度
int lenList(ListNode *head)
{
    int n=0;
    ListNode *p=head->next;//包含头结点的情况下，遍历从头结点的下一结点开始
    while(p!=NULL)
    {
        n++;
        p=p->next;
    }
    return n;
}
//输出单链表结点
void printList(ListNode *head)
{
    ListNode *p=head->next;//包含头结点的情况下，遍历从第一个结点开始
    int num=0;

    num=lenList(head);
    printf("There are %d nodes:",num);
    printf("\n");
    while(p!=NULL)
    {
        printf("%d ",p->data);
        p=p->next;
    }
}
int main()
{
    ListNode *head=creatList();
    BubbleSortList(head);
    printList(head);
    return 0;
}

#include <iostream>
#include <stdio.h>

using namespace std;
//以下声明适用于归并排序链表
#define MAXSIZE 1024
#define LENGTH 8
struct SqList
{
    int r[MAXSIZE+1];
    int length;
};
//冒泡法排序链表，（升序）
ListNode* BubbleSortList(ListNode *head)
{
    if(head==NULL||head->next==NULL)
        return;

    ListNode *p=head->next;//跳过头结点，从第一个结点开始
    ListNode *q=head->next;
    int temp;
    for(;p!=NULL;p=p->next)
    {
        for(;q!=NULL;q=q->next)
        {
            if(q->data>q->next->data)
            {
               temp=q->data;
               q->data=q->next->data;
               q->next->data=temp;
            }
        }
    }
    return head;
}

//归并法排序链表
void Merge(SqList sr,SqList &tr,int i,int m,int n)
{
    int j,k;
    for(int j=m+1,k=i;i<=m&&j<=n;++k)
    {
       if(sr.r[i]<=sr.r[j])
            tr.r[k]=sr.r[i++];
       else
           tr.r[k]=sr.r[j++];
    }
    while(i<=m)
        tr.r[k++]=sr.r[i++];
    while(j<=n)
        tr.r[k++]=sr.r[j++];
}
void Msort(SqList sr,SqList &tr,int s,int t)
{
  int m;
  SqList tr2;
  if(s==t)
        tr.r[s]=sr.r[t];
  else
  {
      m=(s+t)/2;
      Msort(sr,tr2,s,m);
      Msort(sr,tr2,m+1,t);

      Merge(tr2,tr,s,m,t);
  }
}
void MergeSort(SqList &L)
{
    Msort(L,L,1,L.length);
}
int main()
{
    //以下程序段，用于检查归并排序
    int i;
    SqList L={{0,49,38,65,97,13,76,27},LENGTH};
    MergeSort(L);
    for(i=1;i<=L.length;i++)
        cout<<L.r[i]<<" ";
    cout<<endl;
    return 0;
}

//删除单链表的某个结点，并返回头结点
//注意：当链表有头结点时，删除任一个结点，操作相同。
//不同的是无头结点的单链表。故该链表无头结点。
ListNode *deleteListNode(ListNode *head,int num)
{
   if(head==NULL)
      return NULL;
   ListNode *p,*q;
   p=head;
   //找到待删除节点在链表中的位置
   while(p->data!=num&&p->next!=NULL)
   {
       q=p;//保存待删除节点的前一节点
       p=p->next;
   }

   if(num==p->data)
   {
      if(p==head)//待删除节点为头结点
      {
         head=p->next;
         delete p;
      }
      else
      {
         q->next=p->next;//删除结点方法
         delete p;
      }
   }
   else
    printf("\n%d could not been found.",num);
   return head;
}

//单链表的插入
//有序的单链表，把值num插入
ListNode *insertListNode(ListNode *head,int num)
{
    ListNode *p=head,*q;
    ListNode *p0=new ListNode();
        p0->data=num;//新建插入结点

    //查找插入位置，即插入的前一节点
    while(p0->data>p->data&&p->next!=NULL)
    {
       q=p;//记录插入位置的前一个结点
       p=p->next;
    }

    if(p0->data<=p->data)
    {
        if(p==head)//插入头结点之前
        {
           p0->next=p;
           head=p0;
        }
        else//插入链表中间 q--p0--p1
        {
           p0->next=p;
           q->next=p0;
        }
    }
    else//插入位置位于链表尾部
    {
      p->next=p0;
      p0->next=NULL;
    }
    return head;
}