数据结构实验报告（六）

实验6 排序

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define INFINITY INT_MAX
#define MAXSIZE 100

using namespace std;
typedef struct list
{int key;
}ElemType;
typedef struct {
ElemType data[MAXSIZE+1];
int length; /*参加排序元素的实际个数*/
}SeqList;
//创建顺序表
void creatList(SeqList &l)
{
    cout<<"请输入数据个数"<<endl;
    cin>>l.length;
    cout<<"请顺次输入一组无序数据"<<endl;
    for (int i=1;i<=l.length;i++)
    {
        cin>>l.data[i].key;
    }
}
// 直接插入排序
void InsertSort(SeqList &l)
{
    int i,j;
    for (i=2;i<=l.length;i++)
    {
        if (l.data[i].key < l.data[i-1].key )
        {
            l.data[0].key=l.data[i].key;
            l.data[i].key=l.data[i-1].key;
            for (j=i-2;l.data[0].key < l.data[j].key ;j--)
                l.data[j+1].key=l.data[j].key;
            l.data[j+1].key=l.data[0].key;
        }
    }
}
//输出顺序表元素
void print(SeqList l)
{
    int i;
    for (i=1;i<=l.length;i++)
        cout<<l.data[i].key<<" ";
    cout<<endl;
}
//冒泡排序
void BubbleSort(SeqList &l)
{
    int i,j;
    for (i=1;i<=l.length-1;i++)
        for (j=1;j<=l.length-i;j++)
    {
        if (l.data[j].key > l.data[j+1].key)
        {
           l.data[0]=l.data[j];
           l.data[j]=l.data[j+1];
           l.data[j+1]=l.data[0];
        }
    }
}
// 直接选择排序
void SelectSort(SeqList &l)
{
    int i,j,k;
    for (i=1;i<=l.length-1;i++)
    {
        k=i;
        for (j=i;j<=l.length;j++)
        {
          if (l.data[j].key<l.data[k].key)
          {
              k=j;
          }
        }
        if (k!=i)
        {
            l.data[0]=l.data[k];
            l.data[k]=l.data[i];
            l.data[i]=l.data[0];
        }
    }
}
//希尔插入
void ShellInsert(SeqList &l,int dk)
{
    //dk是位置增量
    int i,j;
    for (i=dk+1;i<=l.length;i++)
    {
        if (l.data[i].key < l.data[i-dk].key)
        {
            l.data[0]=l.data[i];
            for (j=i-dk;j>0&&l.data[0].key<l.data[j].key;j=j-dk)
            {
                l.data[j+dk]=l.data[j];
            }
            l.data[j+dk]=l.data[0];
        }
    }
}
//希尔排序
void ShellSort(SeqList &l,int dlta[],int t)
{
    //dlta[]是增量数组，每一次循环以dlta[k]为增量，dlta[0---t-1]
    int k;
    for (k=0;k<t;k++)
        ShellInsert(l,dlta[k]);
}
//快排
int Partition(SeqList &l,int low,int high)
{
    l.data[0]=l.data[low];
    int p;
    p=l.data[low].key;
    while (low<high)
    {
        while (low<high&&l.data[high].key>=p) high--;
        l.data[low]=l.data[high];
        while (low<high&&l.data[low].key<=p) low++;
        l.data[high]=l.data[low];
    }
    l.data[low]=l.data[0];
    return low;
}
void QSort(SeqList &l,int low,int high)
{
    int p;
    if (low<high)
    {
       p=Partition(l,low,high);
       QSort(l,low,p-1);
       QSort(l,p+1,high);
    }
}

//堆调整
void HeapAdjust(SeqList &l,int s,int m)
{
    ElemType rc=l.data[s];
    int j;
    for (j=2*s;j<=m;j*=2)
    {
        if (j<m && l.data[j].key < l.data[j+1].key)
            j++;
        if (!(rc.key < l.data[j].key))
            break;
        l.data[s]=l.data[j];s=j;
    }
    l.data[s]=rc;
}
//堆排序
void HeapSort(SeqList &l)
{
    int i;
    for (i=l.length/2;i>0;i--)
        HeapAdjust(l,i,l.length);
    for (i=l.length;i>1;i--)
    {
        l.data[0]=l.data[1];
        l.data[1]=l.data[i];//data[1]即为最大的数
        l.data[i]=l.data[0];
        HeapAdjust(l,1,i-1);
    }


}

//折半插入排序
void BinInsertSort(SeqList &l)
{
    int i,j,low,high,mid;
    for (i=2;i<=l.length;i++)
    {
        l.data[0]=l.data[i];
        low=1;high=i-1;
        while (low<=high)
        {
            mid=(low+high)/2;
            if (l.data[0].key < l.data[mid].key ) high=mid-1;
            else low=mid+1;
        }
        for (j=i-1;j>=high+1;j--)
            l.data[j+1]=l.data[j];
        l.data[high+1]=l.data[0];
    }
}
// 链式存储实现简单选择排序
typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*linklist;
//创建单链表l
void createLinkList(linklist &l)
{
    linklist p,q;
    l=(linklist)malloc(sizeof(LNode));
    p=l;
    cout<<"请输入数据个数"<<endl;
    int n;cin>>n;
    cout<<"请输入一组数据"<<endl;
    ElemType e;

    for (int i=0;i<n;i++)
    {
        cin>>e.key;
        q=(linklist)malloc(sizeof(LNode));
        q->data.key=e.key;
        q->next=NULL;
        p->next=q;
        p=q;
    }

}
// 简单选择排序
void SelectSort_linklist(linklist &l)
{
    ElemType tmp;
    linklist p,q,k;//P为工作指针，Q为指向最小元素的指针,k为前面指向第一个为排序元素的指针
    p=l->next;q=p;k=p;
    while (k)
    {

    while (p)
    {
        if (p->data.key < q->data.key )
        {
            q=p;
        }
        p=p->next;
    }
    if (k!=q)
    {
        tmp=k->data;
        k->data=q->data;
        q->data=tmp;
    }
    k=k->next;
    p=k;
    q=k;
    }
}
//打印链表
void print_linklist(linklist l)
{
    linklist p=l->next;
    while (p)
    {
        cout<<p->data.key<<" ";
        p=p->next;
    }
    cout<<endl;
}
// 链式直接插入排序
void InsertSort_linklist(linklist &l)
{
    linklist p,q,t;
    p=l->next->next;//把P插入到链表L中
    l->next->next=NULL;
    q=l;
    while (p)
    {
        while (q->next && p->data.key >q->next->data.key)
            q=q->next;
        if (!q)
        {
            q->next = p;
            p=p->next;
            p->next=NULL;
        }
        else
        {
            t=p;p=p->next;
            t->next=q->next;
            q->next=t;
        }
        q=l;
    }
}
// 链式冒泡排序
void BubbleSort_linklist(linklist &l)
{
    linklist p=l->next,q,c;
    q=p->next;
    ElemType e;
    c=p;
    while (c)
    {
       while (q)
    {

        if (p->data.key > q->data.key )
        {
            e=p->data;
            p->data=q->data;
            q->data=e;
        }
        p=p->next;q=q->next;
    }
    p=l->next,q=p->next;
    c=c->next;
    }


}
int main()
{   cout<<"--------------------------------------------------------"<<endl;
    cout<<"1.InsertSort():直接插入排序"<<endl;
    cout<<"2.Bl.data[1]ubbleSort():冒泡排序"<<endl;
    cout<<"3.SelectSort():直接选择排序"<<endl;
    cout<<"4.ShellSort():希尔排序"<<endl;
    cout<<"5.QSort():快速排序"<<endl;
    cout<<"6.HeapSort():堆排序"<<endl;
    cout<<"7.BinInsertSort():折半插入排序"<<endl;
    cout<<"9.SelectSort_linklist():链式简单选择排序"<<endl;
    cout<<"10.InsertSort_linklist():链式直接插入排序"<<endl;
    cout<<"11.BubbleSort_linklist():链式冒泡排序"<<endl;
    cout<<"--------------------------------------------------------"<<endl;
ll1:cout<<"请输入您选择的函数序号"<<endl;
    int x;cin>>x;
    SeqList l;
    linklist l1;
    switch(x)
    {
    case 1:
    {
    creatList(l);
    cout<<"直接插入排序前的结果"<<endl;
    print(l);
    InsertSort(l);
    cout<<"直接插入排序后的结果"<<endl;
    print(l);
    break;
    }

    case 2:
    {
    creatList(l);
    cout<<"冒泡排序前的结果"<<endl;
    print(l);
    BubbleSort(l);
    cout<<"冒泡排序后的结果"<<endl;
    print(l);
       break;
    }

    case 3:
        {
    creatList(l);
    cout<<"直接选择排序前的结果"<<endl;
    print(l);
    SelectSort(l);
    cout<<"直接选择排序后的结果"<<endl;
    print(l);
            break;
        }
    case 4:
    creatList(l);
    cout<<"希尔排序前的结果"<<endl;
    print(l);
    int dlta[3];dlta[0]=5;dlta[1]=3;dlta[2]=1;
    ShellSort(l,dlta,3);
    cout<<"希尔排序后的结果"<<endl;
    print(l);
        break;

    case 5:
    creatList(l);
    cout<<"快速排序前的结果"<<endl;
    print(l);
    QSort(l,1,8);
    cout<<"快速排序后的结果"<<endl;
    print(l);
        break;

    case 6:
        {
    creatList(l);
    cout<<"堆排序前的结果"<<endl;
    print(l);
    HeapSort(l);
    cout<<"堆排序后的结果"<<endl;
    print(l);
      break;
        }

    case 7:
        {
    creatList(l);
    cout<<"折半插入排序前的结果"<<endl;
    print(l);
    BinInsertSort(l);
    cout<<"折半插入排序后的结果"<<endl;
    print(l);
      break;
        }
    case 9:
        {
            createLinkList(l1);
            cout<<"链式简单选择排序之前："<<endl;
            print_linklist(l1);
            SelectSort_linklist(l1);
            cout<<"链式简单选择排序之后："<<endl;
            print_linklist(l1);
            break;
        }
    case 10:
        {
            createLinkList(l1);
            cout<<"链式直接插入排序之前："<<endl;
            print_linklist(l1);
            InsertSort_linklist(l1);
            cout<<"链式直接插入排序之后："<<endl;
            InsertSort_linklist(l1);
            break;
        }

    case 11:
        {
            createLinkList(l1);
            cout<<"链式冒泡排序之前："<<endl;
            print_linklist(l1);
            BubbleSort_linklist(l1);
            cout<<"链式冒泡排序之后："<<endl;
            print_linklist(l1);
            break;
        }




    }
    cout<<"您是否还要继续测试其他函数？y/n"<<endl;
    fflush(stdin);
    char z;
    cin>>z;
    if (z=='y')
        goto ll1;
    else
    return 0;
}