数据结构躬行记9_散列表&快速排序

散列表

概念

散列表，又称杂凑表，是一种十分实用的查找技术，具有极高的查找效率。其基本思想是根据 关键码值（查找码）与表项存储位置的映射关系，进行高效、精确的查找。查找效率与散列函数的 计算复杂度、冲突解决方案的使用有直接的关系。散列查找是根据关键码（查找码）与表项存储位 置的映射关系，进行高效、精确的查找，因此也需要采用顺序结构存储。 当关键码比较多时，很可能出现散列函数值相同的情况，即出现冲突。我们通常也称为冲突的 两个关键是该散列函数的同义词。

要点

p=H(key), p是地址，key是关键字，H称为散列函数。散列函数的构造方法有：数字分析法，平方取中法，折叠法，除留余数法。（代码中采用除留余数法）。冲突处理的方法采用开放地址法的二次探测法。

代码实现

#include<iostream>
using namespace std;
#define Length 50
typedef int keyType;
typedef struct
{
    keyType data;
    char other;
}SList,*List;
int H(keyType m);
void createList(List &l)
{
    l = new SList[Length];
    for(int i=0;i<Length;i++)
        l[i].data = 0;
    cout<<"请输入初始化存入的个数:";
    int counts;
    cin>>counts;
    if(counts>50)
    {
        cout<<"散列表空间不足";
        return ;
    }
    for(int i=0;i<counts;i++)
    {
        cout<<"请输入第"<<i+1<<"个数:";
        keyType tmp;
        cin>>tmp;
        if(!l[H(tmp)].data)
        l[H(tmp)].data = tmp;
        else
        {
            int next = H(tmp);
            while(l[next].data)
            {
                next = (next+1)%47;
            }
            l[next].data = tmp;
        }
    }
}
int H(keyType m)
{
    return m%47;
}

int searchList(List l,keyType key)
{
    int h = H(key);
    if(l[h].data == 0)
    {
        return -1;
    }else if(l[h].data==key){
        return h;
    }else{
        for(int i=0;i<Length;i++)
        {
            int next = (h+1)%47;
            if(l[next].data ==0)
                return -1;
            else if(l[next].data == key)
                return next;
        }
        return -1;
    }
}

int main()
{
    List l;
    createList(l);
    cout<<endl;
    while(true){
    cout<<"请输入要查询的关键字:";
    int key;
    cin>>key;
    int mysearch = searchList(l,key);
    if(mysearch==-1)
        cout<<"没有找到"<<endl;
    else
        cout<<"位置："<<mysearch<<endl;
        int k;
        cin>>k;
        if(!k)
            break;
    }

  return 0;
}

快速排序

思想概念

快速排序采用了一种分治的策略，通常称其为分治法。其基本思想是将原问题分解为若干个规 模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题 的解。

具体排序过程

第一步，在待排序的n个记录中任取一个记录，以该记录的排序码为准，将所有记录分成两组， 第1组各记录的排序码都小于等于该排序码，第2组各记录的排序码都大于该排序码，并把该记录排 在这两组中间。

第二步，采用同样的方法，对左边的组和右边的组进行排序，直到所有记录都排到相应的位置 为止。（递归思想）

要点

在快速排序中，选定了以第一个元素为基准，接着就拿最后一个元素和第一个元素 比较，如果大于第一个元素，则保持不变，再拿倒数第二个元素和基准比较，如果小于基准，则进 行交换。交换之后，再从前面的元素开始与基准比较，如果小于基准，则保持不变；如果大于基 准，则交换。交换之后，再从后面开始比较，依次类推，前后交叉进行。

 

 代码实现

#include<iostream>
using namespace std;
typedef char other;
#define maxl 5000
typedef struct
{
    int data;
    other info;
}elem,*elemptr;

typedef struct
{
    elemptr p;
    int length;
}SList;

void InitList(SList &t)
{
    t.p = new elem[maxl];
    t.length = 0;
}
void createList(SList &t)
{
    cout<<"请输入赋值的个数:";
    int counts;
    cin>>counts;
    for(int i=1;i<=counts;i++)
    {
        cout<<"请输入第"<<i<<"个数:";
        int tmp;
        cin>>tmp;
        t.p[i].data = tmp;
        t.length++;
    }
}
//根据low  和high  进行一轮快速排序
int partition(SList &t,int low,int high)
{
    t.p[0].data = t.p[low].data;
    int pivotkey = t.p[low].data;
    while(low<high)
    {
        while(low<high&&(t.p[high].data>=pivotkey)) high--;
        t.p[low].data = t.p[high].data;
        while(low<high&&(t.p[low].data<=pivotkey))  low++;
        t.p[high].data = t.p[low].data;
    }
    t.p[low].data = pivotkey;

    return low;
}
//递归进行快排
void Qsort(SList &t,int low,int high)
{
     if(low<high)
     {
         int mid = partition(t,low,high);
         Qsort(t,low,mid-1);
         Qsort(t,mid+1,high);
     }
}

void show(SList t)
{
    int len =t.length;
    for(int i=1;i<len;i++)
        cout<<t.p[i].data<<"  ";

    cout<<endl;
}
int main()
{
    SList t;
    InitList(t);
    createList(t);
    cout<<"排序前:";
    show(t);
    int low = 1;
    int high = t.length;
    Qsort(t,low,high);
    cout<<"排序后:";
    show(t);

  return 0;
}