数据结构学习第二十三天

13:50:24 2019-09-14

继续把未看完的看完

 13:19:50 2019-09-15

补上了归并的非递归算法

 16:10:24 2019-09-17

补上了 堆排序的精明版本

排序算法

定理:任意$N$个不同元素组成的序列平均具有$N(N-1)/4$个逆序对

定理:任何仅以交换相邻两元素来排序的算法，其平均时间复杂度为$Ω(N^2)$

这样子 冒泡排序 插入排序 的最坏情况都是 N^2

要使排序算法变高效 得使用间隔元素来交换 在一次排序中 交换多个逆序对的元素

希尔排序

定义增量序列$D_M>D_{M-1}>...>D_1=1$

$对每个D_k进行“D_k-间隔”排序（k=M,M-1,...1)$

$注意：“D_k-间隔"有序的序列，在执行”D_{k-1}间隔“排序后，仍然是“D_k-间隔"有序的$

如果增量元素不互质，则小增量可能根本不起作用

比如 $N=N/2$ 最坏情况 时候 $T= heta(N^{2})$

那么就会有其他的增量序列:

　　Hibbard增量序列 $D_k=2^k-1$  --相邻元素互质  最坏情况$T= heta(N^{3/2})$

　　猜想 Hibbard增量的 平均复杂度 $T_{avg}=O(N^{5/4})$

　　Sedgewick增量序列 $ {1,5,19,41,109,.....}$

　　$9*4^i-9*2^i或4^i-3*2^i+1$猜想$T_{avg}=O(N^{7/6})  T_{worst}=O(N^{4/3})$

归并排序的时间复杂度为$O(NlogN)$ 该算法是稳定的

冒泡排序 插入排序 希尔排序 选择排序 堆排序 归并排序(递归与非递归) (ps:其中堆排序写的是憨憨版本 之后会添上精明版本)

#define _CRT_SECURE_NO_WARNINGS  
#include<stdio.h>
#include<malloc.h>
void Print(int A[], int N)
{
    for (int i = 0; i < N; i++)
        printf("%d ", A[i]);
    printf("
");
}
//排序算法

//冒泡排序   //最好 O(N) 最坏 O(N^2)  算法稳定
void Swap(int A[], int i, int j)
{
    int temp = A[i];
    A[i] = A[j];
    A[j] = temp;
}
void Bubble_Sort(int A[], int N)
{
    for (int i = 0; i < N; i++)
    {
        int IsSwap = 0;
        for (int j = 0; j < N - i-1; j++)
        {
            if (A[j] > A[j + 1])
            {
                IsSwap = 1;
                Swap(A, j, j + 1);
            }
        }
        if (!IsSwap)
            break;
    }
}

//插入排序  //最好O(N) 最坏 O(N^2)  算法稳定
void Insert(int A[], int j, int i) 
{
    int temp = A[i];
    for (; i > j; i--)
        A[i] = A[i - 1];
    A[j] = temp;
}
void Insert_Sort(int A[], int N)
{
    /*for (int i = 0; i < N-1; i++)
    {
        int m = i + 1;
        int j = i;
        while (j >= 0 && A[j] > A[m])
            j--;
        Insert(A, j+1, m);
    }*/
    /*for (int i = 1; i < N; i++)
    {
        int temp = A[i];
        int j;
        for (j = i - 1; j >= 0 && A[j] > temp; j--)
            A[j + 1] = A[j];
        A[j + 1] = temp;
    }*/
    for (int p = 1; p < N; p++)
    {
        int temp = A[p];
        int i;
        for (i = p; i > 0 && A[i - 1] > temp; i--)
            A[i] = A[i - 1];
        A[i] = temp;
    }
}

//希尔排序  //最坏情况  //改进插入排序
void Shell_Sort(int A[], int N)
{
    /*for (int D = N / 2; D > 0; D /= 2)
    {
        for (int p = D; p < N; p++)
        {
            int temp = A[p];
            int i;
            for (i = p; i >= D && A[i - D] > temp; i -= D)
                A[i] = A[i - D];
            A[i] = temp;
        }
    }*/
    // 利用Sedgewick增量序列
    int Si;
    int Sedgewick[] = { 929,505,209,109,41,19,5,1,0 };
    for (Si = 0; Sedgewick[Si] >=N; Si++)  //初始的增量Sedgewick[Si]不能超过待排序序列长度
        ;
    for (int D = Sedgewick[Si]; D>0;D=Sedgewick[++Si])
    {
        for (int p = D; p < N; p++)
        {
            int temp = A[p];
            int i;
            for (i = p; i >= D && A[i - D] > temp; i -= D)
                A[i] = A[i - D];
            A[i] = temp;
        }
    }
}

//选择排序
void Selection_Sort(int A[], int N)
{
    for (int i = 0; i < N; i++)
    {
        int MinPosition = i;
        int Min = A[i];
        int j;
        for (j = i + 1; j < N; j++)
        {
            if (A[j] < Min)
            {
                MinPosition = j;
                Min = A[j];
            }
        }
        Swap(A, i, MinPosition);
    }
}

//堆排序  //选择排序的一种改进
//改进了寻找最小元的算法 利用最小堆来实现
typedef struct HeapStruct* MinHeap;
struct HeapStruct
{
    int* Elements;
    int Size;
    int Capacity;
};
MinHeap Create(int MaxSize)
{
    MinHeap H = (MinHeap)malloc(sizeof(struct HeapStruct));
    H->Elements = (int*)malloc(sizeof(int) * (MaxSize + 1));
    H->Capacity = MaxSize;
    H->Size = 0;
    H->Elements[0] = -10001;
    return H;
}
MinHeap H = Create(20);
//建立最小堆
void PrecDown(MinHeap H, int i)  //下滤
{
    int Parent, Child;
    int Tmp = H->Elements[i];
    for (Parent = i; Parent * 2 <= H->Size; Parent = Child)
    {
        Child = Parent * 2;
        if ((Child != H->Size) && (H->Elements[Child] > H->Elements[Child + 1]))
            Child++;
        if (Tmp <= H->Elements[Child])break;
        else
            H->Elements[Parent] = H->Elements[Child];
    }
    H->Elements[Parent] = Tmp;
}
void BuildMinHeap(MinHeap H)
{
    int i;
    for (i = H->Size / 2; i > 0; i--)
        PrecDown(H, i);
}
int DeleteMin(MinHeap H)
{
    int Parent, Child;
    int MinItem, temp;
    MinItem = H->Elements[1];
    temp = H->Elements[H->Size--];
    for (Parent = 1; Parent * 2 <= H->Size; Parent = Child)
    {
        Child = Parent * 2;
        if (Child != H->Size && H->Elements[Child] > H->Elements[Child + 1])
            Child++;
        if (H->Elements[Child] >= temp)break;
        else
            H->Elements[Parent] = H->Elements[Child];
    }
    H->Elements[Parent] = temp;
    return MinItem;
}

//利用最大堆实现堆排序 (升序)
void Precdown(int A[], int i, int N)
{
    int Parent, Child;
    int Tmp;
    Tmp = A[i];
    for (Parent = i; (Parent * 2) + 1 <= N; Parent = Child)
    {
        Child = (Parent * 2) + 1;
        if (Child != N && A[Child] < A[Child + 1])
            Child++;
        if (A[Child]<=Tmp)break;
        else
            A[Parent] = A[Child];
    }
    A[Parent] = Tmp;
}
void BuildMaxHeap(int A[], int N)
{
    for (int i = (N - 1) / 2; i >= 0; i--)
        Precdown(A, i, N - 1);
}

void Heap_Sort(int A[], int N)   
{
    //算法一 利用最小堆
    /*int Tmp[10] = { 0 };
    for (int i = 0; i < 10; i++)
        Tmp[i] = DeleteMin(H);
    for (int i = 0; i < 10; i++)
        A[i] = Tmp[i];*/

    /*for (int i = 0; i < 10; i++)
        A[i] = DeleteMin(H);*/
    //算法二 利用最大堆后 再调整
    BuildMaxHeap(A, N);
    //之后调整最大堆
    for (int i = N - 1; i >= 0; i--)
    {
        Swap(A, 0, i);
        Precdown(A, 0, i - 1);
    }
}

//归并排序
//递归算法
void Merge(int A[],int lo,int mi,int hi)
{
    //两个有序序列的合并
    int* B = (int*)malloc(sizeof(int) * (mi - lo));
    for (int i = 0; i < mi - lo;i++)B[i] = A[lo + i];
    int i, j, k; 
    i = lo;
    j = 0;
    k = mi;
    /*while (j<mi-lo||k<hi)
    {
        if((j<mi-lo)&&(k>=hi||B[j]<=A[k]))A[i++]=B[j++];
        if ((k < hi) && (j >= mi-lo|| B[j] > A[k]))A[i++] = A[k++];
    }*/
    //化简版
    while (j<mi-lo)
    {
        if (k >= hi || B[j] <= A[k])A[i++] = B[j++];
        if (k<hi && B[j]>A[k])A[i++] = A[k++];
    }
    /*邓公版本*/
    /*int* A1= A + lo;
    int* B = (int*)malloc(sizeof(int) * (mi - lo));
    for (int i = 0; i < mi - lo; B[i] = A1[i++]);
    int* C = A + mi;
    int i, j, k;
    for (i = j = k = 0; j < mi - lo || k < hi-mi;)
    {
        if (j < mi - lo&&((k >= hi - mi)||B[j] <=C[k]))A1[i++] = B[j++];
        if (k < hi - mi && (j >= mi - lo || B[j] > C[k]))A1[i++] = C[k++];
    }*/
    //简化
    /*for (i = j = k = 0; j < mi - lo;)
    {
        if (k >= hi - mi || B[j] <= C[k])A1[i++] = B[j++];
        if (k < hi - mi && (j >= mi - lo || B[j] > C[k]))A1[i++] = C[k++];
    }*/
    free(B);
}
void MergeSort(int A[],int lo,int hi)
{
    if (lo == hi - 1)
        return;
    int mi = (lo + hi) >> 1;
    MergeSort(A,lo, mi);
    MergeSort(A, mi, hi);
    Merge(A,lo, mi, hi);
}
//非递归算法
void Merge_pass(int A[],int N, int length) //length为当前有序子列的长度
{
    int i;
    for (i = 0; i <= N - 2 * length;i += 2 * length)
        Merge(A,i, i + length, i + 2 * length);
    if (i+length< N)    //如果最后有两个子列
        Merge(A, i, i+length, N);  
}
void Merge_Sort(int A[], int N)
{
    int length = 1;
    while (length<=N)
    {
        Merge_pass(A, N, length);
        length *= 2;
    }
}

int main() 
{
    int A[10];
    for (int i = 0; i < 10; i++)
        scanf("%d", &A[i]);
    //Bubble_Sort(A, 10);    //冒泡排序
    //Insert_Sort(A, 10);    //插入排序
    //Shell_Sort(A, 10);    //希尔排序
    //Selection_Sort(A, 10);    //选择排序

    //堆排序   //最小堆之憨憨算法
    /*for (int i = 1; i <= 10; i++)
        H->Elements[++H->Size] = A[i - 1];
    BuildMinHeap(H);   //构建最小堆
    Heap_Sort(A, 10);*/

    //堆排序  //最大堆之精比算法
    Heap_Sort(A, 10);

    //MergeSort(A,0,10) //归并排序递归算法
    //Merge_Sort(A,10);    //归并排序非递归算法
    Print(A, 10);
    return 0;
}

快速排序:是排序算法中最快的 但要注意实现的细节(对于大规模数据来说)

首先要注意主元的选取 对主元的选取会影响到算法的时间复杂度  还有就是快速排序是利用递归实现的 对于小规模数据 可能整体时间不入插入排序快 因此可以使用一个$Cutoff$ 当数据规模过小时 不使用快排 而使用 插入排序

 下面会给出对快速排序的测试

 表排序 

不移动元素本身 而移动指针的 排序 叫做间接排序

利用一个Table数组来对下标进行排序

物理排序 

　　N个数字的排列由若干个独立的环组成

桶排序

基数排序 

　　用“次位优先" (Least Significant Digit)

　　"主位优先"(Most Significant Digit)

对排序的测试

 冒泡排序: 可以看出当数据量过大时 运行超时

插入排序:虽然所有数据都能排序，但当数据量过大时，耗时增加

希尔排序(Sedgewick):希尔排序快了不少

选择排序:答案正确,耗时却不少

 堆排序(憨憨版本):速度也很快

 堆排序(精明版本): 速度也挺好

归并排序(递归)：也很快 但占的内存却很大 比前面的排序大了4、5倍 经检查 是因为没有在归并算法里free掉申请的空间

 每次申请完空间后释放掉 内存占用就少了许多

 归并排序(非递归) :看起来内存占用并没有少 一方面是因为我没有用陈越姥姥的方法去写递归与非递归的排序 更重要的是开辟的数组空间很大  但也可以看出 非递归算法比递归快一些

对快速排序的测试:

对pivot进行测试(此时不使用Cutoff来限定范围)：

①pivot采取A[0]  有三个数据点耗时较多

 ②pivot采取A[mi]  速度不错

 ③pivot采取 三元选中值  某个数据点慢了些  其他都挺快的

 ④采用随机函数rand() 速度也行 不知道改一改获取rand值的函数会不会更快点

 对Cutoff进行测试(此时选取pivot为A[mi]):

①Cutoff取值为50

②Cutoff取100

 ③Cutoff取200

 ④Cutoff取300

 ⑤Cutoff取400

PTA第27题 简单的一道桶排序题

#define _CRT_SECURE_NO_WARNINGS  
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
int Bucket[55];
int main()
{
    int N,Num;
    scanf("%d", &N);
    for (int i = 0; i < N; i++)
    {
        scanf("%d", &Num);
        Bucket[Num]++;
    }
    int count = 0;
    for (int i = 0; i < 55; i++)
    {
        if (Bucket[i])
        {
            printf("%d:%d
", i, Bucket[i]);
            count++;
        }
    }
}

 PTA 第25题 根据给的2串数组 判断是 插入排序还是 归并排序

我是用归并的想法 不断检查以Length为长度的数组 判断是否满足是归并的最小条件(Length=2时满足) 

如果满足 就继续向下查 更新之后需要的长度L 不是就返回去做下一步操作

(os:这是PTA 2014年冬季考试题...我做了有一个小时四十分钟。。这还不算昨天思考的时间。。这要去考试不得凉凉)

#define _CRT_SECURE_NO_WARNINGS  
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
int A[110];
int B[110];
int L;
void Print(int N)
{
    int i;
    for (i = 0; i < N - 1; i++)
        printf("%d ", B[i]);
    printf("%d", B[i]);
}
int IsOrder(int B[],int lo, int hi)
{
    for (int i = lo; i < hi - 1; i++)
        if (B[i] > B[i + 1])
            return 0;
    return 1;
}
int ChargeLength(int B[], int N, int Length)  //检查以Length为长度的序列
{
    int i;
    for (i = 0; i < N -Length; i +=Length)
        if (!IsOrder(B, i, i+Length))
            return 0;
    if (i< N)
        if (!IsOrder(B, i, N))
            return 0;
    L = Length;
    return 1;
}
int Charge(int B[], int N)
{
    int Length = 2;
    while(Length <=N)
    {
        if (ChargeLength(B, N, Length))
            Length *= 2;
        else
            if (Length > 2)
                return 1;
            else
                return 0;
    }
}

void Insert_Once(int B[],int i,int N)
{
    int j;
    int Temp = B[i];
    for (j = i; j > 0 && B[j - 1] >Temp; j--)
        B[j] = B[j - 1];
    B[j] = Temp;
}

void Merge(int lo, int mi, int hi)
{
    int* B1 = (int*)malloc(sizeof(int) * (mi - lo));
    for (int i = 0; i < mi - lo; i++)B1[i] = B[lo + i];
    int i, j, k;
    i = lo;
    j = 0;
    k = mi;
    while (j < mi - lo)
    {
        if (k >= hi || B1[j] <= B[k])B[i++] = B1[j++];
        if (k<hi && B1[j]>B[k])B[i++] = B[k++];
    }
    free(B1);
}
void Merge_Once(int B[], int Length, int N)
{
    int i;
    for (i = 0; i < N - 2 * Length; i += 2 * Length)
        Merge(i, i + Length, i + 2 * Length);
    if (i + Length < N)
        Merge(i, i + Length, N);
}

int main()
{
    int N;
    int Flag = 0;
    int OrderPosition = 0;
    scanf("%d", &N);
    for (int i = 0; i < N; i++)
        scanf("%d", &A[i]);
    for (int i = 0; i < N; i++)
        scanf("%d", &B[i]);
    if (Flag=Charge(B, N))
        printf("Merge Sort
");
    else
        printf("Insertion Sort
");
    for (int i = 0; i < N - 1; i++)
        if (B[i] <=B[i + 1])     //这里必须是大于等于
            OrderPosition = i + 1;
        else
            break;
    if (Flag)
        Merge_Once(B, L, N);
    else
        Insert_Once(B, OrderPosition+1, N);
    Print(N);
    return 0;
}

 PTA 第26题 根据给的两串数组 判断是 插入排序还是 堆排序 

观察数据可以发现是利用 精明算法来 实现堆排序

判断是 堆排序还是 插入排序 我是直接看 前三个元素 

这道题 给出的例子至少会经过一次排序 所以看前三个元素 就可以知道是什么排序了 简单来说 插入排序最早就把前两个元素排好序了 而 堆排序对前两个元素的排序是最后才排的

至于接下来做一步操作 插入排序很简单  堆排序我是直接把排序好的结果 与 给的 数据 进行比较 来找出 那个位置点

#define _CRT_SECURE_NO_WARNINGS  
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
int A[110];
int B[110];
int L;
void Swap(int *C,int i, int j)
{
    int temp = C[i];
    C[i] = C[j];
    C[j] = temp;
}

void Print(int N)
{
    int i;
    for (i = 0; i < N - 1; i++)
        printf("%d ", B[i]);
    printf("%d", B[i]);
}

int Charge(int N)
{
    int i;
    if (B[0] > B[1] && B[0] > B[2])
        return 1;
    else
        return 0;
}

void Insert_Once(int i, int N)
{
    int j;
    int Temp = B[i];
    for (j = i; j > 0 && B[j - 1] > Temp; j--)
        B[j] = B[j - 1];
    B[j] = Temp;
}

void PrecDown(int i,int N)
{
    int Parent, Child;
    int Tmp = A[i];
    for (Parent = i; Parent * 2 + 1 <= N; Parent = Child)
    {
        Child = Parent * 2 + 1;
        if (Child != N && A[Child] < A[Child + 1])
            Child++;
        if (Tmp >= A[Child])break;
        else
            A[Parent] = A[Child];
    }
    A[Parent] = Tmp;
}

void BuildMaxHeap(int N)
{
    for (int i = (N - 1) / 2; i >= 0; i--)
        PrecDown(i, N - 1);
}

void Heap_Sort(int N)
{
    for (int i = N - 1; i >= 0; i--)
    {
        Swap(A, 0, i);
        PrecDown(0, i-1);
    }
}

int FindI(int N)
{
    int i;
    for (i = N - 1; i >= 0 && A[i] == B[i]; i--);
    return i;
}

void PrecDown_Once(int i)
{
    Swap(B,0, i);
    int Parent, Child;
    int tmp;
    tmp = B[0];
    for (Parent = 0; (Parent * 2) + 1 <= i-1; Parent = Child)
    {
        Child = (Parent * 2) + 1;
        if (Child != i-1&& B[Child]<B[Child + 1])
            Child++;
        if (tmp >= B[Child])break;
        else
            B[Parent] = B[Child];
    }
    B[Parent] = tmp;
}

void Heap_Once(int N)
{
    BuildMaxHeap(N);
    Heap_Sort(N);
    int i = FindI(N);
    PrecDown_Once(i);
}

int main()
{
    int N;
    int Flag = 0;
    int OrderPosition = 0;
    scanf("%d", &N);
    for (int i = 0; i < N; i++)
        scanf("%d", &A[i]);
    for (int i = 0; i < N; i++)
        scanf("%d", &B[i]);
    if (Flag = Charge(N))
        printf("Heap Sort
");
    else
        printf("Insertion Sort
");
    for (int i = 0; i < N - 1; i++)
        if (B[i] <= B[i + 1])     //这里必须是大于等于
            OrderPosition = i + 1;
        else
            break;
    if (Flag)
        Heap_Once(N);
    else
        Insert_Once(OrderPosition + 1, N);
    Print(N);
    return 0;
}