数据结构学习第十天

15:01:58 2019-08-25

学习

22:43:01 2019-08-25

看的太慢了。。。马上要开学了

#include<stdio.h>
#include<malloc.h>
typedef struct Node* PtrToNode;
struct Node
{
    int Data;
    PtrToNode Pred;   //前驱
    PtrToNode Succ;   //后继
};
PtrToNode Header;//头哨兵
PtrToNode Trailer;//尾哨兵      //前面写的双向链表只给 头部加了一个表头(哑节点)  现在给尾部也加一个哑节点
int size;      //规模

void Init();   //初始化
PtrToNode InsertPred(int Element);   //前插入
PtrToNode InsertSucc(int Element);   //后插入
int Size();        //返回列表当前规模(节点总数)
PtrToNode First() { return Header->Succ; }   //返回首节点位置
PtrToNode Last()  { return Trailer->Pred;}     //返回末节点位置
PtrToNode InsertAsFirst(int Element);  //将元素E当首节点插入
PtrToNode InsertAsLast(int Element) { InsertBefore(Trailer, Element); }   //将元素E当末节点插入
PtrToNode InsertBefore(PtrToNode P, int Element);   //将元素E当作P的前驱元插入
PtrToNode InsertAfter(PtrToNode P, int Element);   //将元素E当作P的后驱元插入
int Remove(PtrToNode P);    //删除节点 返回删除的数据
int Disordered();        //判断所有节点是否有按非降序排列
void Sort();            //调整各节点的位置 使之按非降序排列
PtrToNode Find(int Element,int n,PtrToNode P); //查找目标元素E(从P(不包括)到P节点前n个元素) 失败时返回NULL 
PtrToNode Search(int Element,int n,PtrToNode P);  //在P节点前的n个元素中 查找E 返回不大于E且秩最大的节点
int DeDuplicate();     //剔除重复元素
int Uniquify();        //剔除重复元素
void Traverse();        //遍历列表



void Init()
{
    Header = (PtrToNode)malloc(sizeof(Node));
    Trailer = (PtrToNode)malloc(sizeof(Node));
    Header->Succ = Trailer; Header->Pred = NULL;
    Trailer->Pred = Header; Trailer->Succ = NULL;
    size = 0;
}

//无序列表
int VisitByRank(int r)   //寻秩序访问  效率低下
{
    PtrToNode P =First();   //首节点出发
    while (r--)
    {
        P = P->Succ;
    }
    return P->Data;
}

PtrToNode Find(int Element, int n, PtrToNode P)  //查找目标元素E(从P(不包括)到P节点前n个元素) 失败时返回NULL 
{
    /*PtrToNode Ptr = P;
    for (int i = 1; i < n + 1; i++)
    {
        Ptr = Ptr->Pred;
        if (Ptr->Data == Element)
            return Ptr;
    }
    return NULL;*/
    while (n--)
        if (Element ==(P = P->Succ)->Data) return P;
    return NULL;
}

PtrToNode InsertBefore(PtrToNode P, int Element)   //将元素E当作P的前驱元插入
{
    PtrToNode Ptr = (PtrToNode)malloc(sizeof(Node));
    Ptr->Data = Element;
    Ptr->Succ = P; Ptr->Pred = P->Pred;
    P->Pred = Ptr; Ptr->Pred->Succ = Ptr;
    size++;
}
PtrToNode InsertAfter(PtrToNode P, int Element)   //将元素E当作P的后继元插入
{
    PtrToNode Ptr = (PtrToNode)malloc(sizeof(Node));
    Ptr->Data = Element;
    Ptr->Pred = P; Ptr->Succ = P->Succ;
    P->Succ = Ptr; Ptr->Succ->Pred = Ptr;
    size++;
}
//复制 
void CopyNodes(PtrToNode P, int n)
{
    Init();   //创造一个新的首尾节点
    while (n--)
    {
        InsertAsLast(P->Data);
        P = P->Succ;
    }
}

int Remove(PtrToNode P)    //删除节点
{
    int Element = P->Data;   //备份数据
    P->Pred->Succ = P->Succ;
    P->Succ->Pred = P->Pred;
    free(P);
    size--;
    return Element;     //返回删除节点
}

int Delete()
{
    /*PtrToNode P1, P2;
    P1=P2=Header->Succ;
    while (size--)
    {
        P2 = P1->Succ;
        Remove(P1);      //这里写错了 如果按照我的想法应该用free
        P1 = P2;
    }
    free(Header);
    free(Trailer);*/  //憨憨博主的做法   这部分写的有问题 remove 会对size进行改变
    int OldSize = size;
    while (size)
    {
        Remove(Header->Succ);
    }
    free(Header);
    free(Trailer);
    return OldSize;
}

int DeDuplicate()
{
    if (size < 2) return 0;    //平凡情况
    int OldSize = size;
    PtrToNode P = First();
    int r = 1;
    while (Trailer!=(P=P->Succ))
    {
        PtrToNode Q = Find(P->Data, r, P);    
        Q ? Remove(Q) : r++;            //删除前面的元素 如果删除后面的会出错 因为此时P为NULL
    }
    return OldSize - size;
}

//有序列表
int Uniquify()      //O(n)
{
    /*if (size < 2) return 0;    //平凡情况
    int OldSize = size;
    PtrToNode P1, P2;
    P1 = First(); P2 = P1->Succ;
    while (Trailer!=P2)
    {
        if (P1->Data == P2->Data)
        {
            Remove(P2);
            P2 = P1->Succ;
        }
        else
        {
            P1 = P2;
            P2 = P1->Succ;
        }
    }
    return OldSize - size;*/
    //简化
    if (size < 2) return 0;    //平凡情况
    int OldSize = size;
    PtrToNode P1, P2;
    P1 = First();
    while (Trailer!=(P2=P1->Succ))
    {
        if (P1->Data!=P2->Data)
            P1 = P2;
        else
            Remove(P2);
    }
    return OldSize - size;
}

PtrToNode Search(int Element, int n, PtrToNode P) //在P节点前的n个元素中 查找E 返回不大于E且秩最大的节点  为其它接口使用提供了方便
{
    while (0<=n--)       //等于0的情况 是为了处理在P节点前的n个元素中 没有查找到 返回P前第n+1个元素
    {
        if (Element >= (P = P->Pred)->Data)
            break;
    }
    return P;
}

//排序算法

//选择排序         //O(n^2)
void SwapElement(PtrToNode P1, PtrToNode P2)    //交换两个节点的元素
{
    int Element = P1->Data;
    P1->Data = P2->Data;
    P1->Data = Element;
}
PtrToNode SelectMax(PtrToNode P, int n)
{
    PtrToNode Max = P;
    for (PtrToNode Cur = P; n > 1; n--)
    {
        if (Max->Data <= (Cur = Cur->Succ)->Data)    //元素相同时也要返回后面的元素
            Max = Cur;
    }
    return Max;
}
void SelectSort(PtrToNode P, int n)    //将P后n个元素进行排序
{
    PtrToNode head = P->Pred;
    PtrToNode tail = P;
    for (int i = 0; i < n; i++) tail = tail->Succ;
    while (n>1)
    {
        //InsertBefore(tail, Remove(SelectMax(head->Succ, n)));
        SwapElement(SelectMax(head->Succ, n),tail->Pred);
        tail = tail->Pred;
        n--;
        /*优化
        PtrToNode Max = SelectMax(head->Succ, n);
        if (tail->Pred != Max)
            SwapElement(Max, tail->Pred);
        tail = tail->Pred;
        n--;*/
    }
}

//插入排序            最好O(n)  最坏O(n^2)
void InsertionSort(PtrToNode P,int n) //从位置P开始 到之后的n个元素
{
    for (int r = 0; r < n; r++)
    {
        InsertAfter(Search(P->Data, r, P), P->Data);
        P = P->Succ;
        Remove(P->Pred);
    }
}

栈