快速排序与查找

排序和查找程序设计

实验目的：

1.掌握快速排序方法，实现无序数据的快速排序；

2. 掌握二分查找方法，实现有序数据的二分查找；

实验任务：

1. 编写算法实现快速排序：首先建立静态查找表，然后对其进行快速排序（非递减），输出排序后的数据序列；

2. 编写算法实现二分查找：在第1题有序表的基础上根据查找元素进行二分查找，并给出查找过程中依次比较元素的下标，查找成功时给出元素所在的位序，不成功时给出“未找到该元素”的信息；

 

测试数据：

输入的数据元素原始序列为（79，4，34，2，7，3，43，12，36，55，74，87，80）；

对其进行快速排序后，查找的数据元素分别为2，79，88和90

实验要求：

1、   采用顺序存储的数据结构建立静态查找表。

2、   静态查找表的建立直接进行赋值，不需要从键盘依次输入。

3、   对静态查找表进行快速排序后输出有序序列（非递减）；

4、   需要查找的元素从键盘输入；

5、   静态查找表的基本操作应定义相应的函数实现。

头文件

#ifndef STATICSEARCHTABLE_H_INCLUDED
#define STATICSEARCHTABLE_H_INCLUDED
#include<iostream>
#include<cstring>
using namespace std;

typedef int KeyType;
//元素类型
typedef struct
{
    KeyType Key;//关键字域
    int data;//其他域
}ElemType;

typedef struct//静态查找表的顺序存储结构
{
    ElemType *elem;//数据元素存储空间基址，建表时按实际长度分配，0号留空
    int length;//表长度
}SSTable;

void Create(SSTable &ST,int n);//构造一个含有n个数据元素的静态查找表
void Destroy(SSTable &ST);//销毁静态查找表ST
int Search(SSTable &ST,KeyType Key);//在顺序表ST中顺序查找关键字等于Key的数据元素，若找到，则返回该元素在表中的位置，否则返回0
int BinSearch(SSTable &ST,KeyType Key, int low, int high);//二分法查找
void menu();//主菜单
int Partition(SSTable &ST, int low, int high);
//交换顺序表中子表的记录，并使枢轴记录到位并返回其所在位置，此时在它之前（后）的记录均不大于（小于）它
void Qsort(SSTable &ST,int low, int high);//对顺序表的子序列做快速排序
void swap(int a, int b);

#endif // STATICSEARCHTABLE_H_INCLUDED

.cpp文件

#include"StaticSearchTable.h"
#include<stdio.h>
#include<malloc.h>
//构造一个含有n个数据元素的静态查找表
void Create(SSTable &ST,int n)
{
    ElemType *p = (ElemType *)malloc((n+1)*sizeof(ElemType));//多分配一个空间为监视哨
    ST.elem = p;//把p的基址指向顺序表的基址
    ST.length = n;//顺序表的长度
}



//销毁静态查找表ST
void Destroy(SSTable &ST)
{
    free(ST.elem);
}

//在顺序表ST中顺序查找关键字等于Key的数据元素，若找到，则返回该元素在表中的位置，否则返回0
int Search(SSTable &ST,KeyType Key)
{
    int i;
    ST.elem[0].Key = Key;
    for(i=ST.length; ST.elem[i].Key != Key; i--)
        ;//从后往前找
        if(i == 0)
            printf(" 未能找到该元素");
    return i;
}

//二分法查找
int BinSearch(SSTable &ST,KeyType Key, int low, int high)
{
    int mid;
    if(low > high)
        return -1;
    mid = (low+high)/2;
    printf("%d\t",ST.elem[mid].Key);
    if(ST.elem[mid].Key == Key)
        return mid;
    else if(ST.elem[mid].Key >= Key)
        return BinSearch(ST,Key,low,mid-1);
    else
        return BinSearch(ST,Key,mid+1,high);
}
void swap(int a, int b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}

//交换顺序表中子表的记录，并使枢轴记录到位并返回其所在位置，此时在它之前（后）的记录均不大于（小于）它
int Partition(SSTable &ST, int low, int high)
{
    int pivotkey = ST.elem[low].Key;//用子表的第一个位置做枢轴记录
    while(low < high)
    {
        while(low < high && ST.elem[high].Key >= pivotkey)
            --high;
        swap(ST.elem[low], ST.elem[high]);
        while(low < high && ST.elem[low].Key <= pivotkey)
            ++low;
        swap(ST.elem[low], ST.elem[high]);
    }
    return low;
}

//对顺序表的子序列做快速排序
void Qsort(SSTable &ST,int low, int high)
{
    if(low < high)
    {
        int pivotloc = Partition(ST,low,high);
        Qsort(ST,low,pivotloc-1);
        Qsort(ST,pivotloc+1,high);
    }
}

void menu()
{
    printf("1.");
    printf("请输入您的选择：");
}

主函数

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

using namespace std;

int main()
{
    SSTable ST;
    int a[13]={79,4,34,2,7,3,43,12,36,55,74,87,80};
    int n = 13;
    int i;
    Create(ST,n);
    for(i = 1; i <= n; i++)
    {
        ST.elem[i].Key = a[i-1];
    }
    printf("初始化输入的元素为：\n");
    for(i = 0; i < 13; i++)
    {
        printf("%d  ",a[i]);
    }
    Qsort(ST,1,n);
    printf("\n快速排序结果为：\n");
    for(i = 1; i <= n; i++)
    {
        printf("%d  ",ST.elem[i].Key);
    }
    int k;
    while(k != 0)
    {
         printf("\n请输入您要查找的元素：");
         scanf("%d",&k);
         int d ;
         printf("按顺序查找查找位置为：");
         printf("%d",d = Search(ST,k));
         printf("\n按顺序查找查找次数为： %d",ST.length - d);
         printf("\n按二分法查找经过的元素为: ");
         if(BinSearch(ST,k,1,n) == -1)
         {
            printf("未能找到该元素！\n");
         }


    }


    return 0;
}