数据结构学习第九天

13:57:09 2019-08

学习

16:56:35 2019-08-24

补充了插值查找

排序算法:起泡排序  归并排序(二路归并) 

#define _CRT_SECURE_NO_WARNINGS    //vs中scanf为不安全的函数 要使用 得加上这句话
#include<stdio.h>
#include<malloc.h>
#define Size 10
int Vector[Size] = { 1,8,5,64,54,32,15,96,12,3 };
void Swap(int i, int j)     //交换下表为i j的两个元素
{
    int temp = Vector[i];
    Vector[i] = Vector[j];
    Vector[j] = temp;
}
//排序算法
//起泡排序     最好O(n) 最坏O(n^2)
/*void BubbleSort()
{
    for (int i = 0; i < Size; i++)
    {
        int IsSwap = 0;   //判断是否经过交换
        for (int j = 0; j < Size-i-1; j++)
        {
            if (Vector[j] > Vector[j + 1])
            {
                Swap(j, j + 1);
                IsSwap = 1;
            }
        }
        if (!IsSwap)
            return;
    }
}*/
//邓公的写法
/*int Bubble(int lo, int hi)
{
    int IsSwap = 0;  //判断是否经过交换
    while (++lo<hi)
    {
        if (Vector[lo-1] > Vector[lo])
        {
            Swap(lo - 1, lo);
            IsSwap = 1;
        }
    }
    return IsSwap;
}
void BubbleSort(int lo,int hi)
{
    while (Bubble(lo,hi--));
}*/
//再改进
int Bubble(int lo, int hi)
{
    int LastPosition = 0; //最后交换的位置
    while (++lo < hi)
    {
        if (Vector[lo - 1] > Vector[lo])
        {
            Swap(lo - 1, lo);
            LastPosition = lo;
        }
    }
    return LastPosition;     //返回最后交换的位置
}
void BubbleSort(int lo, int hi)
{
    while (lo<(hi=Bubble(lo, hi)));     //将hi置为最后交换的位置 用lo来判断可以少一步进入函数
}

//归并排序      //O(nlogN)
//二路归并
/*void Merge(int lo, int mi, int hi)   //归并    
{
    int a[20] = { 0 };                //栈上申请空间 存放排序后的向量元素
    int i = 0;
    int low = lo;
    int mid = mi;
    while (low<mi||mid<hi)
    {
        if (low<mi&&(mid>=hi||Vector[low] < Vector[mid]))      //当mid>=hi时 右边已经没有元素了 这时候直接添加就可以  或者左边首元素小于右边首元素这时候也直接添加
            a[i++] = Vector[low++];                            //再者一定要保证low小于mi 因为在这个过程中(如果不加这个条件) low会超出 导致某一个元素比较2次
        else if(mid<hi&&(low>=mi||Vector[mid]<=Vector[low]))
            a[i++] = Vector[mid++];
    }
    for (int i = lo; i < hi; i++)      //将排好序的元素写回
    {
        Vector[i] = a[i - lo];
    }
}*/
//邓公的二路归并做法    //当然 邓公用的是c++ 这里是c的实现方法  
void Merge(int lo, int mi, int hi)   //O(n)  //邓公的做法是只为左边元素申请空间 对元素比对后的结果直接覆盖原数组  
{                                        //经过分析 这样做是对的 因为不管怎么做 右边的元素总不会被覆盖掉  始终保持着有效性
    int* A = Vector + lo;               //声明一个指向 左边向量首元素的指针
    int* B = (int*)malloc(sizeof(int) * (mi - lo));        //申请一块空间来存放左边元素
    for (int i = 0; i < mi - lo; B[i] = A[i++]);       //存放左边元素
    int* C = Vector + mi;                    //声明一个指向 右边向量首元素的指针
    /*for (int i = 0, j = 0, k = 0;j<mi-lo||k<hi-mi;)                    // i用于A j用于B k用于C
    {
        if ((j < mi - lo) && (k >= hi - mi || B[j] <=C[k]))A[i++] = B[j++];
        if ((k < hi - mi) && (j >= mi - lo || C[k] <B[j]))A[i++] = C[k++];        //这部分思想是相同的
    }*/
    //简化后    当j到了末尾 其实已经做完了 排序工作
    for (int i = 0, j = 0, k = 0; j < mi - lo /*|| k < hi - mi*/;)                    // i用于A j用于B k用于C
    {
        if (/*(j < mi - lo) && */k >= hi - mi || B[j] <=C[k])A[i++] = B[j++];
        if ((k < hi - mi) && /*(j >= mi - lo ||*/ C[k] < B[j])A[i++] = C[k++];        //这部分思想是相同的
    }
    free(B);
}

void MergeSort(int lo, int hi)     //排序     [lo,hi)
{
    if (hi - lo < 2)return;       //单元素自然有序
    int mi = (hi + lo) >> 1;      //取数组中点为界
    MergeSort(lo, mi);              //对前半部分排序
    MergeSort(mi, hi);              //对后半部分排序
    Merge(lo, mi, hi);            //归并
}

int main()
{
    MergeSort(0,Size);
    for (int i = 0; i < Size; i++)
        printf("%d ", Vector[i]);
    printf("
");
}

邓公讲的太好了   不能听现场真遗憾