数据结构代码实现（一）

/*二叉树的实现与遍历
#include <iostream>
#include <malloc.h>
using namespace std;

typedef struct btnode
{
    char data;
    struct btnode * plchild;
    struct btnode * prchild;
}BTNODE,* PBTNODE;

PBTNODE createBtnode();//建造静态链式二叉树
void pretraBtree(PBTNODE pt);//先序遍历
void intraBtree(PBTNODE pt);//中序
void posttraBtree(PBTNODE pt);//后序

int main()
{
    PBTNODE pt=createBtnode();

    pretraBtree(pt);
    cout<<endl;
    intraBtree(pt);
    cout<<endl;
    posttraBtree(pt);
    cout<<endl;

    return 0;
}

void pretraBtree(PBTNODE pt)
{
    if(pt==NULL) return ;
    cout<<pt->data<<endl;
    pretraBtree(pt->plchild);
    pretraBtree(pt->prchild);
}

void intraBtree(PBTNODE pt)
{
    if(pt==NULL) return ;
    intraBtree(pt->plchild);
    cout<<pt->data<<endl;
    intraBtree(pt->prchild);
}

void posttraBtree(PBTNODE pt)
{
    if(pt==NULL) return ;
    posttraBtree(pt->plchild);
    posttraBtree(pt->prchild);
    cout<<pt->data<<endl;
}

void createBtnode(PBTNODE t)
{
    int temp;
    cin>>temp;
    if(temp!=0)
    {
        PBTNODE pt=(PBTNODE)malloc(BTNODE);
        if(!(*t))
        {
            exit(-1);
        }
        (*t)->data=temp;
        createBtnode((*t));
        createBtnode((*t));
    }
}

//静态链式二叉树
PBTNODE createBtnode()
{
    PBTNODE pa=(PBTNODE)malloc(sizeof(BTNODE));
    PBTNODE pb=(PBTNODE)malloc(sizeof(BTNODE));
    PBTNODE pc=(PBTNODE)malloc(sizeof(BTNODE));
    PBTNODE pd=(PBTNODE)malloc(sizeof(BTNODE));
    PBTNODE pe=(PBTNODE)malloc(sizeof(BTNODE));

    pa->data='A';
    pb->data='B';
    pc->data='C';
    pd->data='D';
    pe->data='E';

    pa->plchild=pb;
    pa->prchild=pc;
    pb->plchild=pb->prchild=NULL;
    pc->plchild=pd;
    pc->prchild=NULL;
    pd->plchild=NULL;
    pd->prchild=pe;
    pe->plchild=pe->prchild=NULL;

    return pa;
}
*/







/*汉诺塔
#include <iostream>
#include <malloc.h>
using namespace std;

void hannuota(int n,char A,char B,char C)
{
    if(n==1)
    {
        cout<<"将编号为"<<n<<"的盘子从"<<A<<"转移到"<<C<<endl;
    }
    else
    {
        hannuota(n-1,A,C,B);
        cout<<"将编号为"<<n<<"的盘子从"<<A<<"转移到"<<C<<endl;
        hannuota(n-1,B,A,C);
    }
}

int main()
{
    char ch1='A';
    char ch2='B';
    char ch3='C';

    int n;

    cout<<"请输入盘子的个数：";
    cin>>n;

    hannuota(n,'A','B','C');
    return 0;
}*/











/*求1+2+3+...+100的和
int f(int n)
{
    if(n==1) return 1;
    else return n+f(n-1);
}

int main()
{
    cout<<f(100);
    return 0;
}*/




/*阶乘的递归实现
规模大的问题的解决依赖于规模较小的问题的解决而解决
当规模递减到某种程度，当这个规模下问题可以很容易解
决时再递推回来，这个问题就解决了
int f(int n)
{
    if(n==1) return 1;
    else return n*f(n-1);
}

int main()
{
    cout<<f(3);
    return 0;
}*/







/*求阶乘的循环实现
int main()
{
    int val,m=1;
    cout<<"请输入一个数字";
    cout<<"val=";
    cin>>val;
    for(int i=1;i<=val;i++)
    {
        m=m*i;
    }
    cout<<m<<endl;
    return 0;
}*/

/*递归的简单使用
void f(int n)
{
    if(n==1) cout<<"hhh"<<endl;
    else f(n-1);
}
int main()
{
    f(10);//只输出一个hhh
    return 0;
}*/
/*
void f();
void g();
void k();

int main()
{
    f();
    cout<<"0000"<<endl;
    return 0;
}
void f()
{
    cout<<"FFFF"<<endl;
    g();
    cout<<"1111"<<endl;
}
void g()
{
    cout<<"GGGG"<<endl;
    k();
    cout<<"2222"<<endl;
}
void k()
{
    cout<<"KKKK"<<endl;
}

*/















/*队列
#include <iostream>
#include <malloc.h>
using namespace std;

typedef struct Queue
{
    int * pbase;
    int front;
    int rear;
}QUEUE,* PQUEUE;

void init(QUEUE * p2.求阶乘Q);//队列初始化
bool ruQueue(QUEUE * pQ,int val);//入队
bool fullQueue(QUEUE * pQ);//判断队列是否满
void traverseQueue(QUEUE * pQ);//遍历队列
bool emptyQueue(QUEUE * pQ);//判断是否为空
bool chuQueue(QUEUE * pQ,int * pval);//出队并返回删除元素

int main()
{
    QUEUE Q;
    int val;
    init(&Q);
    ruQueue(&Q,1);
    ruQueue(&Q,2);
    ruQueue(&Q,3);
    ruQueue(&Q,4);
    ruQueue(&Q,5);
    ruQueue(&Q,6);
    ruQueue(&Q,7);
    traverseQueue(&Q);
    if(chuQueue(&Q,&val))
    {
        cout<<val<<endl;
    }
    else
    {
        cout<<"false"<<endl;
    }
    traverseQueue(&Q);
    return 0;
}

void init(QUEUE * pQ)
{
    pQ->pbase=(int *)malloc(sizeof(int)*6);
    pQ->front=0;
    pQ->rear=0;
}

bool ruQueue(QUEUE * pQ,int val)
{
    if(fullQueue(pQ))
    {
        return false;
    }
    else
    {
        pQ->pbase[pQ->rear]=val;
        pQ->rear=(pQ->rear+1)%6;//数组长度
        return true;
    }
}

bool fullQueue(QUEUE * pQ)
{
    if((pQ->rear+1)%6==pQ->front)
    {
        return true;
    }
    else return false;
}

void traverseQueue(QUEUE * pQ)
{
    int i=pQ->front;
    while(i!=pQ->rear)
    {
        cout<<pQ->pbase[i]<<" ";
        i=(i+1)%6;
    }
}
bool emptyQueue(QUEUE * pQ)
{
    if(pQ->front==pQ->rear)
        return true;
    else return false;
}

bool chuQueue(QUEUE * pQ,int * pval)//返回删除元素
{
    if(emptyQueue(pQ))
    {
        return false;
    }
    else
    {
        *pval=pQ->pbase[pQ->front];
        pQ->front=(pQ->front+1)%6;
        return true;
    }
}*/


/*栈
#include <iostream>
#include <malloc.h>
#include <cstdio>
#include <cstdlib>
using namespace std;

typedef struct node
{
    int data;
    struct node * pnext;
}NODE,* PNODE;

typedef struct stack1
{
    PNODE ptop;//指向栈顶元素的节点
    PNODE pbottem;//指向栈底下面的无用节点
}STACK,* PSTACK;

void initstack(PSTACK ps);
void pushstack(PSTACK ps,int val);
void traversestack(PSTACK ps);
bool popstack(PSTACK ps,int * pval);
void clearstack(PSTACK ps);

int main()
{
    STACK s;
    int val;
    initstack(&s);//建立一个空栈
    pushstack(&s,1);//压栈
    pushstack(&s,2);
    pushstack(&s,3);
    pushstack(&s,4);
    pushstack(&s,5);
    traversestack(&s);//遍历输出栈
    if(popstack(&s,&val))
    {
        cout<<val<<endl;
    }
    traversestack(&s);
    clearstack(&s);
    traversestack(&s);
    return 0;
}

void initstack(PSTACK ps)
{
    PNODE pnew=(PNODE)malloc(sizeof(NODE));
    if(pnew==NULL)
    {
        cout<<"分配失败"<<endl;
        exit(-1);
    }
    ps->ptop=pnew;
    ps->pbottem=pnew;
    pnew->pnext=NULL;
}

void pushstack(PSTACK ps,int val)
{
    PNODE pnew=(PNODE)malloc(sizeof(NODE));
    pnew->data=val;
    pnew->pnext=ps->ptop;
    ps->ptop=pnew;
    return ;
}

void traversestack(PSTACK ps)
{
    PNODE pnew=ps->ptop;
    while(pnew!=ps->pbottem)
    {
        cout<<pnew->data<<" ";
        pnew=pnew->pnext;
    }
    return ;
}

bool popstack(PSTACK ps,int * pval)
{
    if(ps->ptop==ps->pbottem)
    {
        return false;
    }
    else{
        PNODE pnew=ps->ptop;
        *pval=pnew->data;
        ps->ptop=ps->ptop->pnext;
        free(pnew);
    }
}

void clearstack(PSTACK ps)
{
    if(ps->ptop==ps->pbottem)
    {
        return ;
    }
    else {
        PNODE p=ps->ptop;
        PNODE q=NULL;
        while(p!=ps->pbottem)
        {
            q=p->pnext;
            free(p);
            p=q;
        }
        ps->ptop=ps->pbottem;
        return ;
    }
}*/
/*
#include <iostream>
#include <malloc.h>
using namespace std;
void f(int k);//动态分配的内存在堆里面分配内存，静态非配的内存再栈里面分配
int main()
{
    int i=10;
    int * p=(int *)malloc(200);
    return 0;
}
void f(int k)
{
    int m;
    double * q=(double *)malloc(200);
}
*/



/*链表的实现与功能
#include <iostream>
#include <malloc.h>
#include <cstdlib>
using namespace std;

typedef struct node
{
    int data;
    struct node * pnext;
}NODE,* PNODE;


PNODE create_list();//创建一个链表
void traverse_list(PNODE phead);//遍历链表

bool isEmpty(PNODE phead);//判断是否为空
int lengthList(PNODE phead);//求长度
bool insertList(PNODE phead,int i,int val);//插入
bool deleteList(PNODE phead,int i,int * val);//删除
void sortList(PNODE phead);//排序

int main()
{
    PNODE phead=NULL;

    phead=create_list();//创建一个非循环单链表，将首地址分配给phead；

    traverse_list(phead);//遍历

    if(isEmpty(phead)==1) cout<<"空"<<endl;
    else cout<<"不空"<<endl;

    int x=lengthList(phead);
    cout<<x<<endl;

    sortList(phead);

    traverse_list(phead);

    insertList(phead,4,33);//1~(phead->data)-1;

    traverse_list(phead);
    int val;
    deleteList(phead,4,&val);
    cout<<val;
    traverse_list(phead);
    return 0;
}
PNODE create_list()//是对不同节点的存储，每次开辟一个节点的空间
{
    int len;
    int val;

    cin>>len;//输入链表长度,即链表节点个数

    PNODE phead=(PNODE)malloc(sizeof(NODE));
    if(phead==NULL) cout<<"分配失败"<<endl;

    phead->data=len;

    PNODE ptail=phead;
    ptail->pnext=NULL;

    phead->data=0;

    for(int i=0;i<len;i++)
    {
        cout<<"请输入节点值: ";
        cin>>val;//节点值

        PNODE pnew=(PNODE)malloc(sizeof(NODE));
        if(pnew==NULL) cout<<"分配失败"<<endl;

        pnew->data=val;
        ptail->pnext=pnew;
        pnew->pnext=NULL;
        ptail=pnew;

        phead->data++;

    }
    return phead;
}
void traverse_list(PNODE phead)
{
    PNODE p=phead->pnext;
    for(;p!=NULL;)//继续进行程序的条件
    {
        cout<<p->data<<endl;
        p=p->pnext;
    }
    return ;
}

bool isEmpty(PNODE phead)
{
    if(phead->pnext==NULL) return true;
    else return false;
}
int lengthList(PNODE phead)
{
    return phead->data;
}

void sortList(PNODE phead)
{
    PNODE p,q;
    int len=phead->data;
    int i,j,t;
    for(i=0,p=phead->pnext;i<len-1;i++,p=p->pnext)
    {
        for(j=i+1,q=p->pnext;j<len;j++,q=q->pnext)
        {
            if((p->data)>(q->data))
            {
                t=p->data;
                p->data=q->data;
                q->data=t;
            }
        }
    }
    return ;

}

//在phead所指向链表的第pos个节点前插入一个新的节点，值为val
//pos从一开始
bool insertList(PNODE phead,int pos,int val)
{
    int i=0;
    PNODE p=phead;
    while(p!=NULL&&i<pos-1)
    {
        p=p->pnext;
        i++;
    }//指向了pos前面的一个节点
    if(i>pos-1||p==NULL) return false;
    PNODE pnew=(PNODE)malloc(sizeof(NODE));
    if(pnew==NULL)
    {
        cout<<"失败"<<endl;
        exit(-1);
    }
    pnew->data=val;
    PNODE q=p->pnext;
    p->pnext=pnew;
    pnew->pnext=q;
    return true;
}

bool deleteList(PNODE phead,int pos,int * val)
{
    int i=0;
    PNODE p=phead;
    while(p->pnext!=NULL&&i<pos-1)
    {
        p=p->pnext;
        i++;
    }
    if(p->pnext==NULL||i>pos-1)
        return false;

    PNODE q=p->pnext;
    *val=q->data;
    p->pnext=p->pnext->pnext;
    free(q);
    q=NULL;
    return true;
}
*/


/*链表的插入与删除操作
#include <iostream>
using namespace std;

typedef struct node
{
    int data;           //数据域
    struct node * pnext;//指针域
}NODE,* PNODE;//NODE<->struct node;PNODE<->struct node *;
int main()
{
    //p->pnext等价于pnext这个成员，即(*p).pnext，记住它是个成员
    插入//r=p->pnext;p->pnext=q;q->next=r;//r是PNODE类型指针变量
    插入//q->pnext=p->pnext;p->pnext=q;
    删除//p->pnext=p->pnext->pext;三个元素（有瑕疵，不可用）
    删除//r=p->next;p->pnext=p->pnext->pnext;free(r);//释放这个地址的内存，即将这一片内存提醒系统可以使用
    PNODE p=(PNODE)malloc(sizeof(NODE));
    将动态非配的新节点的地址赋给p；
    free (p);
    删除p所指向的节点所占的内存，删除p这个地址的内存
    p->pnext;
    p所指向的结构体变量中的pnext成员本身
    return 0;
}*/
/*typedef的用法
#include <iostream>
using namespace std;
typedef int zhangsan;//为int再多取一个名字，zhangsan等价于int；

typedef struct Student
{
    int sid;
    char name[100];
    char sex;
}ST;            //ST等价于struct Student;
typedef struct Student
{
    int sid;
    char name[100];
    char sex;
}* PST;         //PST就是struct Student *;
typedef struct Student
{
    int sid;
    char name[200];
    int sex;
}ST,* PST;  //ST等价于struct Student,PST就是struct Student *;
int main()
{
    //struct Student st;//ST st;
    //struct Student * p=&st;/ST * p;

    return 0;
}*/



/*连续存储【数组】
#include <iostream>
#include <malloc.h>
#include <cstdio>
using namespace std;

//定义了一个数据类型，该数据类型的名字
//叫做struct Arr
struct Arr
{
    int * pBase;//存储的是数组第一个元素的位置
    int len;//数组所能容纳的最大元素的个数
    int cnt;//当前数组有效元素的个数
    //int increment//自动增长因子
};


void initArr(struct Arr * parr,int length);//初始化
bool appendArr(struct Arr * parr,int var);//追加
bool insertArr(struct Arr * parr,int pos,int val);//插入,pos的值从一开始
bool deleteArr(struct Arr * parr,int pos;int * pval);//删除相应位置的元素，*pval是删除的值
bool get();//获得相应下标的值
bool isEmpty(struct Arr * parr);//判断是否为空
bool isFull(struct Arr * parr);//检查是否为空
void sortArr();//排序
void showArr(struct Arr * parr);//输出数组
void inversionArr(struct Arr * parr);//倒置


int main()
{
    struct Arr arr;
    initArr(&arr,6);
    showArr(&arr);
    appendArr(&arr,1);
    appendArr(&arr,2);
    appendArr(&arr,3);
    appendArr(&arr,4);
    appendArr(&arr,5);

    //appendArr(&arr,6);
    //insertArr(&arr,1,99);

    insertArr(&arr,22,99);
    showArr(&arr);
    return 0;
}

void initArr(struct Arr * parr,int length)
{
    parr->pBase=(int *)malloc(sizeof(int)*length);
    if(parr->pBase==NULL)
    {
        cout<<"动态内存分配失败"<<endl;
        exit(-1);//终止整个程序
    }
    else
    {
        parr->len=length;
        parr->cnt=0;
    }
    return ;
}

bool isEmpty(struct Arr * parr)
{
    if(parr->cnt==0)
        return true;
    else
        return false;
}

void showArr(struct Arr * parr)
{
    if(isEmpty(parr)==1)
        cout<<"数组为空"<<endl;
    else
    {
        for(int i=0;i<parr->cnt;i++)
        {
            cout<<parr->pBase[i]<<endl;
        }
    }
}
bool isFull(struct Arr * parr)
{
    if(parr->cnt==parr->len) return true;
    else return false;
}
bool appendArr(struct Arr * parr,int var)//流程 功能 试数
{
    if(isFull(parr)) return false;
    else
    {
        parr->pBase[parr->cnt]=var;
        ++(parr->cnt);
        return true;
    }
}
bool insertArr(struct Arr * parr,int pos,int val)
{
    if(parr->cnt==parr->len) return false;
    if(pos<1||pos>parr->cnt+1) return false;
    for(int i=parr->cnt-1;i>=pos-1;i--)
    {
        parr->pBase[i+1]=parr->pBase[i];
    }
    parr->pBase[pos-1]=val;
    (parr->cnt)++;
    return true;
}
bool deleteArr(struct Arr * parr,int pos;int * pval)
{
    if(isEmpty(parr))
        return false;
    if(pos<1||pos>parr->cnt)
        return false;
    for(i=pos;i<parr->cnt;i++)
    {
        parr->pBase[i-1]=parr->pBase[i];
    }
    parr->cnt--;
    return true;
}
void inversionArr(struct Arr * parr)
{
    int i=0;
    int j=parr->cnt-1;
    int t;
    while(i<j)
    {
        t=parr->pBase[i];
        parr->pBase[i]=parr->pBase[j];
        parr->pBase[j]=t;
        i++;
        j--;
    }
    return ;
}
void sortArr(struct Arr * parr)
{
    for(int i=0;i<parr->cnt-1;i++)
    {
        for(int j=i+1;j<parr->cnt;j++)
        {
            if(parr->pBase[i]>parr->pBase[j])
            {
                int t=parr->pBase[i];
                parr->pBase[i]=parr->pBase[j];
                parr->pBase[j]=t;
            }
        }
    }
}*/





/*预备知识
#include <iostream>
#include <malloc.h>
using namespace std;
struct Student
{
    int sid;
    int age;
};
struct Student * createStudent();
void showStudent(struct Student * p);
int main()
{
    struct Student * ps;
    ps=createStudent();
    showStudent(ps);
    return 0;
}
struct Student * createStudent()
{
    struct Student * p=(struct Student *)malloc(sizeof(struct Student));
    p->sid=99;
    p->age=120;
    return p;
}
void showStudent(struct Student * p)
{
    cout<<p->sid<<p->age<<endl;
}*/
/*#include <iostream>
using namespace std;
int f();
int main()
{
    int i=10;
    i=f();
    cout<<i<<endl;
}
int f()
{
    int j=20;
    return j;
}*/
/*#include <iostream>
using namespace std;
int main()
{
    int a[5]={4,10,1,2,8};
    int len;
    cin>>len;
    int * pArr=(int *)malloc(sizeof(int)*len);
            //动态分配sizeof(int)*len个字节的内存
            //int * 强制转换地址的类型，以规定每个数据所占用的空间
    *pArr=-1;//a[0]=-1;
    pArr[1]=10;//a[1]=10;pArr就是a；
    free(pArr);//把pArr所申请的的内存释放；
    return 0;
}*/
/*#include <iostream>
#include <cstring>
using namespace std;
struct Student
{
    int sid;
    char name[200];
    int age;
};
void f(struct Student * pst);
void ff(struct Student st);
int main()
{
    struct Student st;//已经为st分配了内存
    int i;
    f(&st);
    ff(st);
    cout<<st.sid<<st.name<<st.age;
    return 0;
}
void ff(struct Student st)//这种方式耗内存 耗时间 不推荐
{
    cout<<st.sid<<st.name<<st.age<<endl;
}
void f(struct Student * pst)
{
    pst->sid=99;
    strcpy(pst->name,"zhenghua");
    (*pst).age=22;
}*/

/*#include <iostream>
using namespace std;
struct Student
{
    int sid;
    char name[200];
    int age;
};
int main()
{
    struct Student st={1000,"lihua",20};
    struct Student * pst;
    pst=&st;
    pst->sid=99;//pst->sid       等价于 （*pst）.sid,
                //而（*pst）.sid 等价于  st.sid
                //所以pst->      等价于  st.sid
    cout<<pst->sid<<endl;
    return 0;
}*/
/*#include <iostream>
using namespace std;
struct Student//数据类型是struct Student
{
    int sid;
    string name;
    int age;
};//分号不能省
int main()
{
    struct Student st={1000,"zhengsan",20};
    cout<<st.sid<<" "<<st.name<<" "<<st.age<<endl;
    st.name="lihua";
    cout<<st.name<<endl;
    return 0;
}*/



/*#include <iostream>
using namespace std;
void f(int * * q);
int main()
{
    int i=9;
    int * p=&i;
    cout<<p<<endl;
    f(&p);
    cout<<p<<endl;
    return 0;
}
void f(int * * q)
{
    *q=(int *)0xFFFFFFFF;
}*/
/*#include <iostream>
using namespace std;
void f(int * p);

int main()
{
    int i=10;
    f(&i);
    cout<<i<<endl;
    return 0;
}
void f(int * p)
{
    *p=99;
}*/
/*#include <iostream>
using namespace std;
int main()
{
    double * p;
    double x=66.6;
    p=&x;//x占8个地址，一个字节一个地址，
         //p存放的是第一个字节或者第八个
         //字节的地址
    double array[3]={1.1,2.2,3.3};
    double * q;
    q=array;//或者q=&array[0];
    cout<<q<<endl;//输出的是十六进制整数即地址
    q=&array[1];
    cout<<q<<endl;
    cout<<sizeof(p)<<" "<<sizeof(q)<<endl;
    return 0;
}*/
/*#include <iostream>
using namespace std;
void showArray(int *p,int len);
int main()
{
    int a[5]={1,2,3,4,5};
    showArray(a,5);
    cout<<a[0]<<endl;
    return 0;
}
void showArray(int *p,int len)
{
    p[0]=-1;
    for(int i=0;i<len;i++)
        cout<<p[i]<<endl;
}*/
/*#include <iostream>
#include <cstdio>
using namespace std;
void f(int *i)
{
    *i=100;
}
void f1(int &j)//
{
    j=100;
}
int main()
{
    int i=9;
    f(&i);
    cout<<i<<endl;
    int j=9;
    f1(j);
    cout<<j<<endl;

}*/
/*int main()
{
    int * p;//p是个指针变量，int *表示该p变量只能存放int型变量的地址
    int i=10;
    int j;
    p=&i;
    j=*p;
    cout<<j<<endl;
    return 0;
}*/