常用的内部排序算法

#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#define MaxSize 30 
typedef  int  KeyType;
typedef struct {
        KeyType  key;
}RecordType;
//直接插入排序


void InsertSort(RecordType r[], int length)
{
    for (int i = 2; i < length; i++)
    {
        r[0] = r[i];             //将待插入的记录放在监视哨中
        int j = i - 1;
        while (r[0].key < r[j].key)
        {
            r[j + 1] = r[j];
            j = j - 1;
        }
        r[j + 1] = r[0];      //将待插入记录插入到已排序的序列中


    }
}


//简单选择排序


void SelectSort(RecordType r[], int length) 
{


    int x;
    //假设待排序列有n个数从第一个开始，以次与其后面的数比较，需要比较n-1次
    for (int i = 1; i <= length - 1; i++)
    {
        int k = i;
        for (int j = i + 1; j <= length; j++)  //j从2开始
        {
            if (r[j].key < r[k].key)
            {
                k = j;
            }
        }
        if (k != i)             //当r[j].key>=r[k].key 将r[k]的值借助中间变量X与x[i]的值交换
        {
            x = r[i].key;               //r[i].key为最小数
            r[i].key = r[k].key;
            r[k].key = x;


        }
    }
}


//冒泡排序


void BubbleSort(RecordType r[], int length)
{
    int t;
    for (int i = 1; i <= length; i++)
    {
        for (int j = 1; j <= length - i - 1; j++)
        {
            if (r[j].key > r[j + 1].key)
            {
                t = r[j+1].key;
                r[j + 1].key = r[j].key;
                r[j].key = t;
            }
        }
    }
}


//快速排序


int QKPass(RecordType r[], int left, int right) //一趟快速排序算法
{
    int low = left;
    int high = right;
    r[0] = r[left];
    while (low < high)
    {
        while (low<high && r[high].key>r[0].key)
        {
            high--;
        }
        if (low < high)
        {
            r[low] = r[high];
            low++;
        }
        while (low < high && r[low].key < r[0].key)
        {
            low++;
        }
        if (low < high)
        {
            r[high] = r[low];
            high--;
        }
    }
    r[low] = r[0];
    return low;               //返回基准记录的位置
}
void QKSort(RecordType r[], int low, int high)      //快速排序 
{
    if (low < high)
    {
        int pos = QKPass(r, low, high);         //调用一趟快速排序，以枢轴元素为界划分两个子区间
        QKSort(r, low, pos - 1);             //对左部子表进行快速排序
        QKSort(r, pos + 1, high);             //对右部子表进行快速排序
    }
}
void quickSort2(RecordType r[], int low, int high)   //快排非递归 
{
stack<int> t;
if(left<right)
{
int p = partition(r, low, high);
 
if (p-1>low)
{
t.push(low);
t.push(p-1);
}
if (p+1<high)
{
t.push(p+1);
t.push(high);
}
 
while(!t.empty())
{
int r0 = t.top();
t.pop();
int l = t.top();
t.pop();
 
p = partition(r, l, r0);
 
if (p-1>l)
{
t.push(l);
t.push(p-1);
}
if (p+1<r0)
{
t.push(p+1);
t.push(r0);
}
 
}
}
}


//堆排序
void sift(RecordType r[], int n, int m)
{//对编号为m的节点进行调整
    int i = m;
    r[0] = r[i];
    int j = 2 * i;
    while (j <= n)
    {
        if (j < n && r[j].key<r[j + 1].key)
        {
            j = j + 1;
        }
        if (r[j].key>r[0].key)
        {
            r[i] = r[j];
            i = j;
            j = 2 * i;
        }
        else
        {
            break;
        }
    }
    r[i] = r[0];
}
void HeapSort(RecordType r[], int length)
{
    //初建堆
    int i;
    for (i = length / 2; i > 0; i--)
    {
        sift(r, length, i);
    }
    //调整
    for (i = length; i > 1; i--)
    {
        r[0] = r[1];
        r[1] = r[i];
        r[i] = r[0];
        sift(r, i - 1, 1);
    }
}


//希尔排序
void ShellInsert(RecordType r[], int length, int delta)  //Shell插入，其中delta 为增量
{
    int i, j;
    for (i = 1 + delta; i <= length; i++)
    {
        if (r[i].key < r[i - delta].key)
        {
            r[0] = r[i];          //备份r[i](不做监视哨)
            for (j = i - delta; j > 0 && r[j].key > r[0].key; j -= delta)
            {
                r[j + delta] = r[j];
            }
            r[j + delta] = r[0];
        }
    }
}


void ShellSort(RecordType r[], int length, int delta[], int n)//希尔排序,delta为增量数组，n为增量数组长度
{
    for (int i = 0; i < n; i++)
    {
        ShellInsert(r, length, delta[i]);
    }
}




void ShowResult(RecordType* r, int length)        //输出结果
{


    for (int i = 1; i <= length; i++)
    {
        printf("%d\t", r[i]);


        if (i % 10 == 0)
        {
            printf("\n");
        }
    }
}




//菜单
void menu()
{
printf("内部排序的基本操作\n");
printf("\t\t\t1.实现简单选择排序、直接插入排序和冒泡排序\n");
printf("\t\t\t2.实现希尔排序算法\n");
printf("\t\t\t3.实现快速排序算法\n");
printf("\t\t\t4.实现堆排序算法\n");
printf("\t\t\t5.实现快速排序非递归算法\n");
printf("\t\t\t6.重新输入数字\n");
printf("\t\t\t 0.退出\n");
}
int main()
{
int i; 
RecordType r[31] ;
    int delta[] = { 15, 7, 3, 1 }; 
int choice,n;
printf("请输入数字个数....(1~30)\n");
    scanf("%d",&n);
printf("请输入数字，回车分开.....\n");
    for(i=1;i<=n;i++){
      scanf("%d",&r[i].key);
}
while(1)
{
menu();
    printf("请选择你的操作：\n");
        scanf("%d",&choice);
       
        switch(choice)
{
            case 1:
            printf("直接插入排序：....\n");
            InsertSort(r, n);
            ShowResult(r, n);
            printf("\n");
            printf("简单选择排序：....\n");
            SelectSort(r, n);
            ShowResult(r, n);
            printf("\n");
            printf("冒泡排序：....\n");
            BubbleSort(r, n);
            ShowResult(r, n);
            printf("\n");
break;
    case 2:
    printf("希尔排序：....\n");
            ShellSort(r, n, delta, 4);
            ShowResult(r, n);
            printf("\n");
break;
case 3:
    printf("快速排序：....\n");
    QKSort(r, 1, n-1);
            ShowResult(r, n);
            printf("\n");
break;
case 4:
    printf("堆排序：....\n");
            HeapSort(r, n);
            ShowResult(r, n);
            printf("\n");
break;
case 5:
printf("快速排序非递归...\n");
quickSort2(r,1,n-1);
ShowResult(r, n);
            printf("\n");
break;
case 6:
printf("请输入数字个数....(1~30)\n");
        scanf("%d",&n);
        printf("请输入数字，空格分开.....\n");
        for(i=1;i<=n;i++){
        scanf("%d",&r[i].key);
}
break;
            case 0:
      return 0;
            default:
                printf("输入错误，请重新输入！\n");
}
}

}