数据结构实验3

#include<stdio.h>
#include<malloc.h>
#define  MAXSIZE 20
typedef struct BNode
{
    char data;
    struct BNode *lchild, *rchild;
}*BTree;

void CreateBTree(BTree &T)
{
    char data;
    scanf_s("%c",&data);
    if (data == '#')
    {
        T = NULL;
    }
    else
    {
        T = (BTree) malloc(sizeof(BNode));
        T->data = data;
        CreateBTree(T->lchild);
        CreateBTree(T->rchild);
    }
}

//feidigui xianxubianli
void PreOrder1(BTree b)
{
    BTree St[MAXSIZE], p;
    int top = -1;
    if (b != NULL)
    {
        top++;
        St[top] = b;
        while (top > -1)
        {
            p = St[top];
            top--;
            printf("%c ", p->data);
            if (p->rchild != NULL)
            {
                top++;
                St[top] = p->rchild;
            }
            if (p->lchild != NULL)
            {
                top++;
                St[top] = p->lchild;
            }
        }
    }
}

//feidigui zhongxu
void InOrder1(BTree t)
{
    int top = 0;
    BTree St[MAXSIZE];
    BTree p;
    p = t;
    while (p || top)
    {
        while (p)
        {
            St[top++] = p;
            p = p->lchild;
        }
        if (top)
        {
            p = St[--top];
            printf("%c ",p->data );
            p = p->rchild;
        }
    }
}
//feidigui houxubianli
void PsOrder1(BTree t)
{
    BTree St[MAXSIZE], p;
    int flag, top = -1;
    do
    {
        while (t)
        {
            top++;
            St[top] = t;
            t = t->lchild;
        }
        p = NULL;
        flag = 1;
        while (top != -1 && flag)
        {
            t = St[top];
            if (t->rchild == p)
            {
                printf("%c ", t->data);
                top--;
                p = t;
            }
            else
            {
                t = t->rchild;
                flag = 0;
            }
        }
    } while (top != -1);
}

//digui xianxu
void PreOrder2(BTree p)
{
    if (p != NULL)
    {
        printf("%c ", p->data);
        PreOrder2(p->lchild);
        PreOrder2(p->rchild);
    }
}
//digui zhongxu
void InOrder2(BTree p)
{
    if (p != NULL)
    {
        InOrder2(p->lchild);
        printf("%c ", p->data);
        InOrder2(p->rchild);
    }
}
//digui houxu
void PsOrder2(BTree p)
{
    if (p != NULL)
    {
        PsOrder2(p->lchild);
        PsOrder2(p->rchild);
        printf("%c ", p->data);
    }
}

int main()
{
    BTree b;
    printf("create a tree such as ABC##DE#G##F### \n");
    CreateBTree(b);
    printf("非递归先序遍历：\n");
    PreOrder1(b);
    printf("\n");
    printf("非递归中序遍历：\n");
    InOrder1(b);
    printf("\n");
    printf("非递归后序遍历：\n");
    PsOrder1(b);
    printf("\n");
    printf("递归先序遍历：\n");
    PreOrder2(b);
    printf("\n");
    printf("递归中序遍历：\n");
    InOrder2(b);
    printf("\n");
    printf("递归后序遍历：\n");
    PsOrder2(b);
    printf("\n");
}

 

#include<iostream>
#include<iomanip>
#include<vector>
using namespace std;

typedef vector<char>Collection;
typedef vector<vector<char>>Matrix;

void Coll_Print(Collection C);
void Matrix_Print(Matrix M);

int Coll_ChLocate(Collection C,char ch);
bool Coll_ChFind(Collection Ca,char ch);
bool Matrix_ColFind(Matrix M,Collection C);
bool Coll_Belong(Collection Ca,Collection Cb);
Collection Coll_Or(Collection Ca,Collection Cb);
Collection Coll_And(Collection Ca,Collection Cb);
Matrix Matrix_Or(Matrix Ma,Matrix Mb);
Matrix Matrix_Minus(Matrix Ma,Matrix Mb);
void Make_MCC(Collection Ca,vector<Collection>&pi,vector<vector>R);

void Coll_Print(Collection C)
{
    cout<<"{";
    for(int i=0;i<C.size();i++)
    {
        cout<<C[i];
        if(i!=C.size()-1)
            cout<<",";
    }
    cout<<"}";
}

void Matrix_Print(Matrix M)
{
    cout<<"{";
    for(int i=0;i<M.size();i++)
    {
        Coll_Print(M[i]);
        if(i!=M.size()-1)
            cout<<",";
    }
    cout<<"}"<<endl;
}

int Coll_ChLocate(Collection C,char ch)
{
    for(int i=0;i<C.size();i++)
        if(C[i]==ch)
            return i;
        return -1;
}

bool Coll_ChFind(Collection Ca,char ch)
{
    for(int i=0;i<Ca.size();i++)
    {
        if(Ca[i]==ch)
            return true;
    }
    return false;
}

bool Matrix_CoFind(Matrix M,Collection C)
{
    for(int i=0;i<M.size();i++)
        if(M[i]==C)
            return true;
        return false;
}

bool Coll_Belong(Collection Ca,Collection Cb)
{
    if(Ca.size()>Cb.size())
        return false;
    else
    {
        for(int i=0;i<Ca.size();i++)
        {
            if(!Coll_ChFind(Ca,Ca[i]))
                return false;
        }
        return false;
    }
}

Collection Coll_Or(Collectin ca,Collection Cb)
{
    int main=(Ca.size()>Cb.size()?Cb.size():Ca.size());

    Collection CB=(Ca.size()>Cb.size()?Ca:Cb);
    Collection CS=(ca.size()>Cb.size()?Cb:Ca);

    Collection Cc;

    for(int i=0;i<min;i++)
    {
        if(Coll_ChFind(CB,CS[i]))
            Cc.push+back(CS[i]);
    }
    return Cc;
}

Collection Coll_And(Collection Ca,Collection Cb)
{
    int min=(Ca.size()>Cb.size()?Cb.size():Ca.size());

    Collection CB=(Ca.size()>Cb.size()?Ca:Cb);
    Collection CS=(Ca.size()>Cb.size()?Cb:Ca);

    for(int i=0;i<min;i++)
    {
        if(!Coll_ChFind(CB,CS[i]))
            CB.push_back(CS[i]);
    }
    return CB;
}

Matrix Matrix_Or(Matrix Ma,Matrix Mb)
{
    int min=(Ma.size()>Mb.size()?Ma.size());
    Matrix MB=(Ma.size()>Mb.size?Ma:Mb);
    Matrix MS=(Ma.size()>Mb.size()?Mb:Ma);

    for(int i=0;i<min;i++)
        if(!Matrix_ColFind(MB,MS[i]))
            MB.push_back(MS[i]);

        return MB;
}

Matrix Matrix_Minus(Matrix Ma,Matrix Mb)
{
    int i,min=(Ma.size()>Mb.size()?Mb.size():Ma.size());
    Matrix Mc;
    for(i=0;i<min;i++)
    {
        if(!Matrix_ColFind(mb,Ma[i]))
            Mc.push_back(ma[i]);
    }
    if(min==Ma.size())
        return Mc;
    else
    {
        for(;i<Ma.size();i++)
            Mc.push_back(Ma[i]);
        return Mc;
    }
}

void Make_MCC(Collection Ca,vector<Collection>&pi,vector<vector<bool>> R)
{
    int n=Ca.size(),i,j,k;
    Collection A=ca,Xi;
    Collection S,S1,S2,Col_temp,Col_temp2;
    vector<Collection>Mat_temp1,Mat_temp2;

    if(n==1)
    {
        cout<<"Can not Careate the MCC!\n";
        return;
    }
    for(i=n-1;i>1;i--)
    {
        Xi.clear();
        Xi.push_back(Ca[i-1]);

        A.clear();
        for(j=i+1;j<=n;j++)
        {
            if(R[j-1][i-1])
                A.push_back(Ca[j-1]);
        }
        for(k=0;k.pi.size();k++)
        {
            S=pi[k];
            if((Coll_And(S,A)).size()!=0)
            {
                Col.temp1.clear();
                Col.temp2.clear();

                Col_temp1=Coll_And(S,A);
                Col_temp2=Coll_Or(Xi,Col_temp);

                Mat_temp1.clear();
                Mat.temp1.push_back(Col_temp2);

                pi=Matrix_Or(pi,Mat_temp1);
            }
        }
        for(i=0;i<pi.size();i++)
        {
            S1.clear();
            s1=pi[i];
            for(j=0;j<pi.size();j++)
            {
                S2.clear();
                S2=pi[j];
                if(Coll_BeLong(S1,S2))
                {
                    Mat_temp2.clear();
                    Mat.temp.push_back(S1);
                    pi=Matrix_Minus(pi,Mat_temp2);
                }
            }
        }
    }
}

 

#include <stdio.h> /*前面是函数声明 ，后面给出了函数体  为理解深刻 自己可以写main函数 帮助理解*/
#include <malloc.h>
#include <stdlib.h>

typedef struct node
{
    int data;
    struct node *link;
}NODE;

NODE *create ();
int countlist (NODE *head);  //返回链表结点的个数
void printlist (NODE *head);   //单链表的遍历
NODE *insertnode (NODE *head,int num);  //向有序的单链表中插入一个结点，保持链表的有序性
NODE *deletenode (NODE *head,int num);   //在单链表中删除值为num的结点
NODE *inverse (NODE *head);   //输出单链表的逆序
NODE *re_order1 (NODE *head);//将单链表按顺序重新排序
void bubblesort (NODE *head);

void main ()
{
    NODE *p;
    p=create ();
    bubblesort (p);
    for (;p!= NULL;p=p->link)
        printf ("%d ",p->data);

    
}






NODE *create ()//创建单链表
{
    NODE *head,*tail,*p;
    int num;

    head=tail=NULL; //建立头尾指针 ，置为空
    printf ("please input the numbers,-1 is the end \n");//提示 输入数据  ，输入-1结束
    scanf ("%d",&num);                       
    while (num!=-1)                             //条件循环
    {
        p=(NODE *)malloc (sizeof (NODE)); //申请一个指针p
        if (p==NULL)                          //申请失败 ，返回空指针，输出提示 Malloc failure
        {
            printf ("Malloc failure \n");
            return NULL;
        }
        p->data=num;                  //存放数据 放在结点的data里
        p->link=NULL;                   //p的指针域指向NULL
        if (head==NULL){             //如果头指针为空   p地址赋给head
        head=p;
        }
        else {                          //否则， 地址p赋给尾指针的指针域  即 尾指针指向p
            tail->link=p;
        }
        tail=p;                           //把p地址作为尾指针
        scanf ("%d",&num);                //继续输入数据，回到头一步，判断输入是否结束
    }
    return head;
}


int countlist (NODE *head)  //返回链表结点的个数
{
    int count=0;   //定义一个变量count，初始化0，作为结点的计数
    while (head){   // 当指针不为空，结点计数加一  
       count++;
       head=head->link;//指向下一个结点
    }
    return count;//返回结点个数 

}


void printlist (NODE *head)   //单链表的遍历
{
    while (head){  //指针不为空                 
       printf ("%6d",head->data);   //输出该结点的数据
       head=head->link;                   //指向下一个结点
    }
}

NODE *insertnode (NODE *head,int num)  //向有序的单链表中插入一个结点，保持链表的有序性
{
    NODE *p,*q,*list;

    list=(NODE *)malloc (sizeof (NODE));//申请一个指针
    if (list==NULL)
    {
        printf ("Insufficient Memory of list!");
        return NULL;
    }
    if (list){
    list->data=num;        /*这部分 我打的和书上有些出入 
    因为申请一个存储空间的时候  时常要判断返回的指针 看看是否分配失败*/         
    list->link=NULL;
    
    if (head==NULL)
    {
        return list;
    }
    }
    p=head;
    q=NULL;
    while (p)
    {
        if (p->data<num)   //判断该结点与我要插入的值的大小 ，当结点的值小于我要插入的值时
        {
            q=p;              //q记录该结点的地址
            p=p->link;                  //p指向下一个结点
        }
        else{             //当该结点的值大于我要插入的值 （这时 我就要插入我的值了 在上一个结点和这个结点之间）
           if (q)            //如果q为真 即q不为NULL （即我这个值不是插在第一个的  也就是不是最小的）
           {
               q->link=list;           //上一个结点的指针域指向我要插入的那个结点的地址list
               list->link=p;            //我插入结点的指针域指向下一个结点    完成插入操作
           }else{                   //插入的值是最小的 比以前链表的所有数据都小
               list->link=head;    //list的指针域指向原本的head
               head=list;               //头指针赋值list
           }
           break;
        }

    }
    if (!p)//  如果我要插入的值比任何原链表的数据都大，原尾指针的指针域赋list，尾指针即是list
        q->link=list;


    return head;
}



NODE *deletenode (NODE *head,int num)   //在单链表中删除值为num的结点
{
    NODE *p,*q;
    if (head==NULL)
        return head;
    q=NULL;p=head;
    while (p){                 //p不为空，即该结点不为空
         if (p->data==num)       //判断该结点的数据是否为我要删除的值  如果是
         {
             if (q==NULL)    //判断上一个结点是否为空  （即这个结点是不是头结点）
                                     //如果是头结点
             {
                 head=head->link;  // 头指针直接指向下一个结点
                 free (p);        //释放原头结点
                 p=head;          //把新的头指针赋给p
             }else         //如果不是头结点
             {
                 q->link=p->link;  //上一个结点的指针域，指向第三个结点的地址
                 free (p);         //释放中间的结点的内存空间
                 p=q->link;        //p指向下一个结点
             }
         }else               //该结点的数据不是我要删除的值
         {
             q=p;            //q指向该结点
             p=p->link;           //p指向下一个结点
         }
    }

    return head;
}


NODE *inverse (NODE *head)   //输出单链表的逆序
{
    NODE *middle,*tail,*lead;
    tail=middle=NULL;
    lead=head;
    while (lead)
    {
        middle=lead;
        lead=lead->link;
        middle->link=tail;
        tail=middle;
    }
    return middle;
}


NODE *re_order1 (NODE *head)
{
    NODE *h,*p,*q,*r;
    int t;
    if (head==NULL||head->link==NULL)//单链表为空表或者单链表里只有一个结点（元素）  直接返回head  ;不需排序。
        return (head);
    
    /*单链表不为空 执行以下步骤*/
    h=NULL;                       
    t=head->data;
    p=head;
    while (p->link)        //当下一结点不是尾结点时
        if (p->link->data<t)     //如果下一结点存放的数据小于本结点存放的数据
        {
            q=p->link;             //将下一结点地址赋给q
            p->link=q->link;       //
            if (h==NULL) h=q;                 //如果原本结点是头结点
            else r->link=q;   //不是头结点，新建一个结点 r插在q与前面一个结点之间，将r-->q-->p
            r=q;                  //r指向下一个结点

        }else         //如果下一结点存放的数据大于本结点的数据
            p=p->link;      //head指向下一个结点
        if (h==NULL)                     //如果始终不存在交换  ，返回原本的单链表
            return (head);
        else
        {
            r->link=head;   //返回头结点
            return (h);
        }
}

void bubblesort (NODE *head)                //链表的冒泡排序(这部分 咳咳  今天晚上时间不够  排序这方面看不下去了)
{
    NODE *pp,*p,*q,*last;
    last=head;
    while (last->link!=NULL)
        last=last->link;
    while (last!=head->link)
    {/*注意这部分的主要思想是 把最大的移到最后 尾指针置向前一位 把最大的再移到尾指针这 
                                                一直到尾指针==头指针   链表的冒泡顺序完成*/
        pp=head;
        p=pp->link;
        while (p!=last)
        {
            q=p->link;
            if (p->data>q->data)
            {
                pp->link=q;
                p->link=q->link;
                q->link=p;
                if (last==q)  last=p;
            }
            pp=(p->data<q->data)?p:q;  p=pp->link;
        }
        last=pp;
    }
}