c++数据结构 and over

前前后后做了一段时间，终于可以在这里把数据结构先搁置一下，算法总是吸引人去研究，但是总是痴迷于算法却不能进步更大，或许下一步我应该先试试windows网络编程，或者是windows程序设计，虽然看起来都差不多，但实际上应该差不少，网络编程更侧重于各种协议。先把代码呈上：

//-----------------------------------【程序说明】----------------------------------------------
//  程序名称:：LinearList
//  2016年3月 AddSomething by arrstd
//  描述：李春葆的数据结构第四版，数据结构的思考，c++入门式，this is over
//---------------------------------------------------------------------------------------------

#pragma once
#ifndef  LINEARLIST
#define  LINEARLIST

#include<iostream>
using namespace std;

//---------------------------------------------------------------------------------------------
//  线性表之顺序表

#define MaxSize 18              //设置data的大小，这里和李春葆一样设置为50

//顺序表类
class SqList {
private:
    int data[MaxSize];              //存放数据的数组
    int length;                     //顺序表实际长度
public:
    SqList();
    void CreateList(int a[],int n); //创建顺序表，把一个数组内的数据放在顺序表中
    bool ListEmpty();               //判断是否为空表
    int ListLength();               //返回顺序表的长度
    void DispList();                //输出顺序表内容
    bool GetElem(int i,int &e);     //得到位置为i的值，并赋值给e
    int LocateElem(int e);          //得到值为e的数据的位置，有多个相同的值时，这里只返回的一个值得位置
    bool ListInsert(int i, int e);  //在位置为i的地方插入值e
    bool ListDelete(int i);         //删除位置为i的值
};

SqList::SqList()
{
    data[MaxSize] = { 0 };
    length = 0;
}

void SqList::CreateList(int a[], int n)
{
    for (int i = 0; i < n; i++)
    {
        this->data[i] = a[i];
    }
    this->length = n;
}

bool SqList::ListEmpty()
{
    return(this->length == 0);
}

int SqList::ListLength()
{
    return this->length;
}

void SqList::DispList()
{
    for (int i = 0; i != this->length; i++)
    {
        cout << this->data[i] << " ";
    }
    cout << endl;
}

bool SqList::GetElem(int i, int &e)
{
    if (i<1 || i>this->length)
        return false;
    e = this->data[i-1];
    return true;
}

int SqList::LocateElem(int e)
{
    int i = 0;
    while (i < this->length && this->data[i] != e)
        i++;
    if (i >= this->length)
        return 0;
    else
        return i + 1;
}

bool SqList::ListInsert(int i, int e)
{
    if (i<1 || i>this->length + 1)
        return false;
    --i;
    for (int j = this->length; j != i; j--)
    {
        this->data[j] = this->data[j - 1];
    }
    this->data[i] = e;
    this->length++;
    return true;
}

bool SqList::ListDelete(int i)
{
    if (i<1 || i>this->length)
        return false;
    for (int j = --i; j != this->length - 1; j++)
    {
        this->data[j] = this->data[j + 1];
    }
    this->length--;
    return true;
}

//  线性表之顺序表
//---------------------------------------------------------------------------------------------



//---------------------------------------------------------------------------------------------
//  线性表之链表

/**************************************单链表*************************************************/

class LinkList
{
private:
    int data;
    LinkList* next;
public:
    void CreateListF(int a[],int n);        //头插法建立单链表
    void CreateListR(int a[],int n);        //尾插法建立单链表
    int ListLength();                           //返回单链表的实际长度
    void DispList();                            //输出单链表
};

void LinkList::CreateListF(int a[], int n)
{
    this->next = NULL;
    for (int i = 0; i != n; i++)
    {
        LinkList* s = new LinkList;
        s->data = a[i];
        s->next = this->next;
        this->next = s;
    }
}

void LinkList::CreateListR(int a[], int n)
{
    LinkList *r = this , *s;
    for (int i = 0; i != n; i++)
    {
        s = new LinkList;
        s->data = a[i];
        r->next = s;
        r = s;
    }
    r->next = NULL;
}

int LinkList::ListLength()
{
    int n = 0;
    LinkList* p = this;
    while (p->next)
    {
        n++;
        p = p->next;
    }
    return n;
}

void LinkList::DispList()
{
    LinkList* p = this->next;
    while (p != NULL)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}


/**************************************双链表*************************************************/

class DLinkList
{
private:
    int data;
    DLinkList* prior;
    DLinkList* next;
public:
    void CreateDListF(int a[], int n);  //头插法建立双链表
    void DispDList();                       //输出双链表
    void CreateDListR(int a[], int n);  //尾插法建立双链表
};

void DLinkList::CreateDListF(int a[], int n)
{
    this->next = this->prior = NULL;
    for (int i = 0; i != n; i++)
    {
        DLinkList* s = new DLinkList;
        s->data = a[i];
        s->next = this->next;
        if (this->next)
        {
            this->next->prior = s;
        }
        this->next = s;
        s->prior = this;
    }
}

void DLinkList::CreateDListR(int a[], int n)
{
    DLinkList *s, *r = this;
    for (int i = 0; i != n; i++)
    {
        s = new DLinkList;
        s->data = a[i];
        r->next = s;
        s->prior = r;
        r = s;
    }
    r->next = NULL;
}

void DLinkList::DispDList()
{
    DLinkList* p = this->next;
    while (p)
    {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

//  线性表之链表
//---------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------
//  栈
class SqStack
{
private:
    int data[MaxSize];
    int top;
public:
    SqStack();
    void DestroyStack();                //销毁栈，这里有bug导致程序不能正常结束
    bool StackEmpty();                  //判断是否为空栈
    int Push(int e);                    //进栈
    int Pop(int &e);                    //出栈
    int GetTop(int &e);                 //返回栈顶元素
    int BackLength();                   //返回栈实际长度
    int Show();                         //输出栈内元素
};

SqStack::SqStack()
{
    this->top = -1;
}

void SqStack::DestroyStack()
{
    delete[]this;
}

bool SqStack::StackEmpty()
{
    if (this->top == -1)
        return true;
    return false;
}

int SqStack::Push(int e)
{
    if (this->top == MaxSize)
        return false;
    this->top++;
    this->data[this->top] = e;
    return true;
}

int SqStack::Pop(int &e)
{
    if (this->top == -1)
        return false;
    e = this->data[this->top];
    this->top--;
    return true;
}

int SqStack::GetTop(int &e)
{
    if (this->top == -1)
        return false;
    e = this->data[this->top];
    return true;
}

int SqStack::BackLength()
{
    return this->top + 1;
}

int SqStack::Show()
{
    int n = this->top;
    if (this->top == -1)
        return false;
    for (int i = 0; i != BackLength(); int Queue::BackLength()
{
    if (this->front == this->rear)
        return false;
    return this->rear - this->front;
}

Queue::Queue()
{
    this->front = -1;
    this->rear = -1;
}

bool Queue::QueueEmpty()
{
    if (this->front == this->rear)
        return true;
    return false;
}

int Queue::enQueue(int &e)
{
    if (this->rear == MaxSize - 1)
        return false;
    this->rear++;
    this->data[this->rear] = e;
}

int Queue::deQueue()
{
    if (this->front == this->rear)
        return false;
    this->front++;
    return this->data[this->front];
}

int Queue::Show()
{
    if (this->front == this->rear)
        return false;
    for (int i = front + 1; i != rear+1; i++)
    {
        cout << this->data[i] << " ";
    }
    cout << endl;
}
//  队列
//---------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------
//顺序串
class SqString
{
private:
    char data[MaxSize];
    int length;
public:
    SqString();
    void StrAssing(char cstr[]);                //创建顺序串，把数组内的字符放入串，无/0
    int BackLength();                           //返回顺序串世纪长度
    bool StrEqual(SqString s);                  //判断两个顺序串是否相同，相同返回true，否则返回false
    void StrAdd(SqString s);                    //将另一个串添加到本串的尾部
    SqString* ConCatF(SqString s);              //本串在前，s串在后，生成新串并返回指针
    SqString* SubStr(int firstchar, int len);   //返回子串的指针，firstchar为第一个元素，len为长度
    void ShowAssing();
};

SqString::SqString()
{
    this->length = 0;
}

SqString* SqString::SubStr(int firstchar, int len)
{
    SqString* p = new SqString;
    if (firstchar < 1 || firstchar >= this->length || len > this->length - firstchar)
        return p;
    else
    {
        p->length = len;
        for (int i = 0, j = firstchar - 1; i != p->length; j++, i++)
        {
            p->data[i] = this->data[j];
        }
        return p;
    }
}

SqString* SqString::ConCatF(SqString s)
{
    SqString *p = new SqString;
    p->length = this->length + s.length;
    for (int i = 0 , j = 0; i != p->length; i++ )
    {
        if (i < this->length) p->data[i] = this->data[i];
        else 
        {
            p->data[i] = s.data[j]; 
            j++;
        }
    }
    return p;
}

int SqString::BackLength()
{
    return this->length;
}

bool SqString::StrEqual(SqString s)
{
    if (this->length != s.length) return false;
    for (int i = 0; i != this->length; i++)
    {
        if (this->data[i] != s.data[i])
        {
            return false;
            break;
        }
    }
    return true;
}

void SqString::StrAssing(char cstr[])
{
    for (int i = 0; cstr[i] != '\0'; i++)
    {
        if (i <= MaxSize - 1)
        {
            this->data[i] = cstr[i];
            this->length++;
        }
    }
}

void SqString::StrAdd(SqString s)
{
    for (int i = this->length,j=0; j != s.length && i!=MaxSize; j++,i++)
    {
        this->data[i] = s.data[j];
        this->length++;
    }
}

void SqString::ShowAssing()
{
    for (int i = 0; i !=this->length; i++)
    {
        cout << this->data[i] << " ";
    }
    cout << endl;
}



//顺序串

//链串

class LiString
{
private:
    char data;
    LiString* next;
};

//我不想弄这个，果断跳过

//链串
//---------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------
//二叉树                  嗯 使用递归会很容易做  但是使用for循环会出现难以按层次创建树，
//                        数据结构到这了先搁置下来

class BTNode
{
private:
    char data;
    BTNode* lchild;
    BTNode* rchild;
public:
    BTNode();
    void CreateBT(char a[],int n);
};

BTNode::BTNing
{
private:
    char data;
    LiString* next;
};

//我不想弄这个，果断跳过

//链串
//---------------------------------------------------------------------------------------------

//---------------------------------------------------------------------------------------------
//二叉树                  嗯 使用递归会很容易做  但是使用for循环会出现难以按层次创建树，
//                      数据结构到这了先搁置下来

class BTNode
{
private:
    char data;
    BTNode* lchild;
    BTNode* rchild;
public:
    BTNode();
    void CreateBT(char a[],int n);
};

BTNode::BT`
ode()
{
    this->lchild = NULL;
    this->rchild = NULL;
}

void BTNode::CreateBT(char a[], int n)
{
    if (n > 0)
    {
        this->data = a[0];
        BTNode *q = this;
        for (int i = 1; `
 != n; i++)
        {
            if (i * 2 < n) 
            {
                BTNode* p = new BTNode;
                p->data = a[i];
                if (i % 2 == 1) q->lchild = p;
                else q->rchild = p;
                if (q->lchild != NULL && q->rchild != NULL) q = q->lchild;
            }
        }
    }
}

//二叉树
//---------------------------------------------------------------------------------------------
#endif // ! LINEARLIST