数据结构

 

随便记录下数据结构的作业和实验啥的

线性表

第一次实验课

顺序表中移动零元素

【样例输入】

8

4 0 1 3 0 6 0 8

【样例输出】

{ 4 0 1 3 0 6 0 8 }

{ 4 1 3 6 8 0 0 0 }

 

seqlist.h

#include <iostream>
#include <stdlib.h>
using namespace std;


class SeqList    // class : seqlist
{
public:
    SeqList(int size);    // 构造函数
    void outPut();        // 输出顺序表
    void create_SeqList();    //创建顺序表
    void move_Zero_to_the_last();    // 移动0元素至末尾

public:
    int *data;        
    int maxSize;    // 定义顺序表最大长度
    int last;        // last pointer

};


SeqList::SeqList(int size)
{
    maxSize = size;
    last = -1;
    data = new int[maxSize];        // 申请maxSize大小的空间用来存放数据

    if(data == NULL)            // 如果data == 空，说明动态申请内存的过程出现错误
    {
        cout << "alloca error!" << endl;
        exit(1);
    }
}

void SeqList::outPut()
{
    int i;
    cout << "{ ";        // 按格式输出
    for(i = 0; i <= last; i++)        // 循环条件为 i 小于等于 last
    {
        cout << data[i] << ' ';
    }
    cout << '}';
}
    
void SeqList::create_SeqList()
{
    int length;        // 数组元素个数
    cin >> length;

    for(int i = 0; i < length; i++)
    {
        cin >> data[i];            // 输入数组元素
        last++;                    // last指针递增
    }
}

void SeqList::move_Zero_to_the_last()
{
    for(int i = 0; i <= last; i++)        // 第一层循环用来遍历数组元素
    {
        if( data[i] == 0)                // 如果发现某个数组元素为0，则与最近的一个非0元素交换
        {
            for(int j = i; j <= last; j++)            //  第二层循环用来遍历最近的非0元素，如果找到则与data[i](0元素) 交换
            {
                if(data[j] != 0)
                {
                    data[i] = data[j];            // 交换数组中的零元素与最近的一个非0元素
                    data[j] = 0;
                    break;
                }
            }
        }
    }
}

main.cpp

#include <iostream>
#include "SeqList.h"
using namespace std;


int main()
{
    SeqList s1(100);

    s1.create_SeqList();    // 创建数组
    s1.outPut();            // 输出数组元素
    s1.move_Zero_to_the_last();        // 将顺序表中元素的0值全部移动至后方
    cout << endl;
    s1.outPut();            // 再次输出元素
    
}

单链表中找出最小值并插入链表头部

【样例输入】

7 2 4 5 1 8 -1

【样例输出】

7-->2-->4-->5-->1-->8

1-->7-->2-->4-->5-->8

 

太懒了没包含头文件

#include <iostream>
#include <stdlib.h>
using namespace std;


struct LinkNode            // 定义链表节点类型的结构体
{
    LinkNode *link;        // 节点的指针
    int data;            // 节点的数据部分

    LinkNode(int num)    // 对一个节点进行初始化
    {
        link = NULL;
        data = num;
    }
};


class SingleList
{
public:
    SingleList()        // 构造函数
    {
        first = new LinkNode(0);
    }

    void outPut();        // 输出该链表
    void create_SingleList();    // 创建链表
public:
    LinkNode *first;
};


void SingleList::outPut()
{
    int i = 0;                            // 定义一个变量辅助按格式输出
    LinkNode *current = first -> link;        // 定义一个current指针辅助输出

    while(true)
    {
        if(i == 0)
        {
            cout << current -> data;
            current = current -> link;        // 指针后移
            i++;
        }

        else
        {
            cout << "-->" << current -> data;
            current = current -> link;    // 指针后移
        }
        if( current == NULL )        // 遍历完毕，退出循环
        {
            cout << endl;
            break;
        }
    }
}

void SingleList::create_SingleList()
{
    int number;            // 定义一个变量用来输入链表数据
    LinkNode *current = first;        // 定义两个工作指针 ｃｕｒｒｅｎｔ和ｗｏｒｋ
    LinkNode *work = first;

    while(true)
    {
        cin >> number;
        if( number == -1)        // 输入-1时退出循环
            break;
        work = new LinkNode(number);
        current -> link = work;        // 链接单链表
        current = work;    //链表后移
    }
}


LinkNode* find_min(LinkNode *first)
{
    LinkNode *current = first -> link;    // 定义一个current指针
    int min = current -> data;
    LinkNode *min_link;            // 最小元素对应的节点

    while( true )
    {
        if( min > current -> data )
        {
            min = current -> data;        // 遍历链表，找到最小元素值
            min_link = current;        // 记录最小元素值对应的节点，作为返回值返回
        }

        if( current -> link == NULL)        // 如果下一个节点为空，说明遍历完成
            break;
        else
            current = current -> link;
    }
    if(min == first->link->data)
        return first->link;        // 如果最小值对应的节点为首元节点，则直接返回首元节点
    return min_link;            // 返回最小元素值对应的节点
}

void insert_header(LinkNode *first,LinkNode *min)
{
    LinkNode *current = first -> link;
    while(true)
    {
        if(min == first -> link)
        {
            break;                // 如果最小元素值对应的节点就是首元节点，则不需要任何操作
        }

        if(current -> link != min)
        {
            current = current -> link;    // 遍历链表，找到最小元素值对应的节点
        }
        else
        {
            current -> link = min -> link;        // 使最小元素值对应节点之前的节点的下一个元素为最小元素值对应节点之后的节点，即将最小元素值脱链
            min -> link = first -> link;        // 将最小元素值对应的节点的下一个节点记为原本的首元节点
            first -> link = min;            // 将最小元素值对应的节点记在头节点后面，即为新的首元节点
            break;
        }
    }
}

int main()
{
    SingleList s1;

    s1.create_SingleList();            // 建立链表
    s1.outPut();                // 输出链表

    LinkNode *min_link;
    min_link = find_min(s1.first);        // 用一个linknode类型的指针接收最小元素值对应的节点
    insert_header(s1.first,min_link);    // 插入到头部成为首元节点
    s1.outPut();                // 输出改变后的链表
}

合并链表

【问题描述】
 两个非降序链表的并集，例如将链表1->2->3 和 2->3->5 并为 1->2->3->5，只能输出结果，不能修改两个链表的数据。

【输入形式】
 第一行为第一个链表的各结点值，以空格分隔。
 第二行为第二个链表的各结点值，以空格分隔。

【输出形式】
 合并好的链表，以非降序排列，值与值之间以空格分隔。

【样例输入】
 4 7 10 34
 1 4 6 29 34 34 52

【样例输出】
 1 4 6 7 10 29 34 52

【评分标准】
 要使用链表实现，否则不能得分。

这个附加题还是挺难的，做了好久

wtcl orz

SingleList.h

#include <iostream>
#include <stdlib.h>
using namespace std;

/*
author: lemon
date: 2020-10-16
*/

struct LinkNode            // 定义链表节点类型的结构体
{
    LinkNode *link;        // 节点的指针
    int data;            // 节点的数据部分

    LinkNode(int num)    // 对一个节点进行初始化
    {
        link = NULL;
        data = num;
    }
};


class SingleList
{
public:
    SingleList()        // 构造函数
    {
        first = new LinkNode(0);
    }
    void create_SingleList();    // 创建链表
public:
    LinkNode *first;
};


void SingleList::create_SingleList()
{
    int number;            // 定义一个变量用来输入链表数据
    LinkNode *current = first;        // 定义两个工作指针 ｃｕｒｒｅｎｔ和ｗｏｒｋ
    LinkNode *work = first;

    while(true)
    {
        cin >> number;
        char c = cin.get(); // 获取当前输入字符
        work = new LinkNode(number);
        current -> link = work;        // 链接单链表
        current = work;    //链表后移
        if(c == '
')   // 如果当前输入是回车，则退出循环
        {
            break;
        }
    }
}

main.cpp

#include <iostream>
#include "SingleList.h"
using namespace std;

/*
author: lemon
date: 2020-10-16
*/

bool check_link_repeat(LinkNode *p)    // 定义一个检查链表上是否有重复元素的函数
{
    if(p -> link != NULL)        // 如果节点下一个节点不为空，则进入检查，否则返回false
    {
        if(p -> link -> data == p -> data)    // 如果当前节点的数据域等于下一个节点的数据域
        {
            return true;        // 如果通过if，则返回true
        }
        else
            return false;        // 否则返回false
    }
    else
        return false;
}


void output_TWO_link(LinkNode *s1,LinkNode *s2)
{
    LinkNode *current1 = s1 -> link;    // 分别定义两个current指针来对链表进行遍历操作
    LinkNode *current2 = s2 -> link;


    while(current1 != NULL || current2 != NULL)        // 如果current1和current2不同时为NULL，就一直循环
    {

        // ================================= same logic =================================
        if(current1 == NULL)            // 如果链表1为空
        {
            while(current2 != NULL)        // 当链表2不为空时进行循环
            {
                if(check_link_repeat(current2))    // 首先检查链表2中是否有相同元素
                {
                    current2 = current2 -> link;    // 如果有相同元素，则链表当前指针向后移动一个节点，然后continue
                    continue;
                }
                cout << current2 -> data << ' ';    // 输出链表2元素，同时指针向后移动
                current2 = current2 -> link;
            }
            break;
        }

        if(current2 == NULL)        // 此if语句和上面的if语句逻辑相同
        {
            while(current1 != NULL)        // 如果链表1不为空，就进入循环
            {
                if(check_link_repeat(current1))    // 检查链表1是否有相同元素
                {
                    current1 = current1 -> link;
                    continue;
                }
                cout << current1 -> data << ' ';
                current1 = current1 -> link;
            }
            break;
        } 
        // ================================= same logic =================================
        
        
        if(current1 -> data == current2 -> data)    // 如果链表1的数据元素等于链表2当前的数据元素，根据题目要求只输出一个即可
        {
            if(check_link_repeat(current1))        // 66-77行代码：首先对链表1和链表2 进行检查是否有重复元素
            {
                current1 = current1 -> link;
                continue;
            }

            if(check_link_repeat(current2))
            {
                current2 = current2 -> link;
                continue;
            }
            cout << current1 -> data << ' ';    // 输出一个即可
            current1 = current1 -> link;        // 链表1和链表2的指针同时向后移动
            current2 = current2 -> link;
            continue;
        }

        if(current1 -> data < current2 -> data)    // 如果链表1的当前数据小于链表2的元素，则输出链表1的元素，并且链表1的指针向后移动 
        {
            if(check_link_repeat(current1))    // 检查链表1是否有重复元素
            {
                current1 = current1 -> link;
                continue;
            }
            cout << current1 -> data << ' ';    // 输出链表1当前的元素值
            current1 = current1 -> link;        // 链表1指针向后移动
            continue;
        }

        if(current2 -> data < current1 -> data)    // 同理，如果链表2的当前数据小于链表1的元素，则输出链表2的元素，并且链表2的指针向后移动 
        {
            if(check_link_repeat(current2))
            {
                current2 = current2 -> link;
                continue;
            }
            cout << current2 -> data << ' ';
            current2 = current2 -> link;
            continue;
        }
    }
}

int main()
{
    SingleList s1;
    SingleList s2;

    s1.create_SingleList();        // 创建链表1和链表2
    s2.create_SingleList();

    output_TWO_link(s1.first,s2.first);    // 按合并的方式有序输出两个链表
    cout << endl;        // 最后输出回车
}

由于平台只能用校园网连，但是现在在宿舍连不到校园网555，只能本地写一些数据来测试了

唔，目测应该问题不大

栈和队列 作业

判断回文序列，简单题

Stack.h

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

/* 
    author: lemon
    date : 2020-10-18
*/

class Stack
{
public:
    Stack(int sz);    // 构造函数
    int create_Stack();    // 建立栈
    bool is_FULL();    // 判满
    char Pop();        // 元素出栈，并在内部判空

public:
    char *elements;    // 栈数组
    int top;    // 栈顶指针
    int maxSize;    // 最大元素数量
};

Stack::Stack(int size): top(-1) , maxSize(size)        // 构造函数
{
    elements = new char[maxSize];        // 申请一片连续的存储空间
    if( elements == NULL )        // 如果分配错误则退出程序
    {
        cout << "alloca error!" << endl;
        exit(0);
    }
}

int Stack::create_Stack()    // 建立栈
{
    int i;
    string str;
    cin >> str;        // 输入字符串
    for(i = 0; i < int(str.length()) ; i++)    // 逐个字符压栈
    {
        if(is_FULL())        // 判满
        {
            cout << "stack is full" << endl;
            exit(0);
        }
        elements[++top] = str[i];    // 压栈后栈顶指针上移
    }
    return int(str.length());    // 返回字符串的长度
}

bool Stack::is_FULL()    
{
    if(top == maxSize - 1)    // 如果栈顶指针为maxSize - 1则栈满，返回true
        return 1;
    else
        return 0;
}

 
char Stack::Pop()        // 弹栈
{
    char ch;
    ch = elements[top--];
    if( top <= -2)        // 如果栈顶指针 比 -2小则栈空，事实上等于-1就已经空了，但是没有以引用的方式返回，所以等于-1的时候要返回元素
    {
        top = -1;    // 设置top指针为-1 此时栈空
        exit(0);
    }
    return ch;
}

main.cpp

#include <iostream>
#include <string>
#include <stdlib.h>
#include "Stack.h"
using namespace std;

/* 
    author: lemon
    date : 2020-10-18
*/

void Juage_stack(Stack s1,int length)    // 判断字符串是否回文
{
    string higher = "";        // 字符串在栈的前半部分
    string lower = "";        // 字符串在栈的后半部分
    int len = length / 2;    // 取中间值

    if(length % 2 == 0)    // 字符串长度如果是偶数
    {
        for(int i = 0; i < len ; i++)
        {
            higher = higher + s1.Pop();        // 前半部分出栈，存到higher里
        }
        for(int i = 0; i < length - len ; i++)
        {
            lower = lower + s1.Pop();        // 后半部分出栈，存到lower里
        }
    }

    if(length % 2 != 0)    // 如果是奇数，则中间的一个字符需要舍弃
    {
        for(int i = 0; i < len ; i++)
        {
            higher = higher + s1.Pop();    // 前半部分出栈，存到higher里 
        }
        int flags = 0;    // 设置标志位，舍弃中间元素
        for(int i = 0; i < length - 1 - len ; i++)
        {
            if(flags == 0)
            {
                s1.Pop();    // 中间字符出栈，不需要存储
                flags = flags + 1;
            }
            lower = lower + s1.Pop();    // 后半部分出栈，存到lower里
        }
    }

    int flags = 0;    // 设定回文标志位，字符串中有一对回文则加一
    for(int i = 0; i < len ; i++)
    {
        if(higher[i] == lower[len - 1 - i])        // higher数组从前往后的字符 如果匹配 lower数组的至后向前的字符，则可以判断一对字符回文
            flags = flags + 1;
    }

    if(flags == len)        // 如果回文的数量等于字符串长度的一半，则可以判断该字符串回文
        cout << "yes" << endl;
    else
        cout << "no" << endl;

}

int main()
{
    Stack s1(1000);
    int string_len = s1.create_Stack();        // 创建栈
    Juage_stack(s1,string_len);    // 判断是否回文

    return 0;
}

栈和队列实验

第一题

【问题描述】假设一算术表达式中包括三种括号：圆括号“（”和“）”，方括号“[”和“]”，花括号“{”和“}”，且三种括号可按意 次序嵌套使用，试编写程序判定输入的表达式所含的括号是否正确配对出现（已知表达式已存入数据元素为字符的顺序表中）。若匹配，则返回1，否则返回0。
【输入形式】含括号的算数表达式
【输出形式】1/0
【样例输入】3+(44*[5-{6*[7*（45-10）]}])
【样例输出】1
【样例说明】判断括号是否匹配涉及两方面，括号个数和出现次序的判定。
【评分标准】

stack.h

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;


class Stack
{
public:
    Stack(int sz);    // 构造函数
    int create_Stack();    // 建立栈
    int quo();     // 匹配括号

public:
    char *elements;    // 栈数组
    int top;    // 栈顶指针
    int maxSize;    // 最大元素数量
};

Stack::Stack(int size): top(-1) , maxSize(size)        // 构造函数
{
    elements = new char[maxSize];        // 申请一片连续的存储空间
    if( elements == NULL )        // 如果分配错误则退出程序
    {
        cout << "alloca error!" << endl;
        exit(0);
    }
}

int Stack::create_Stack()    // 建立栈
{
    int i;
    string str;
    cin >> str;        // 输入字符串
    for(i = 0; i < int(str.length()) ; i++)    // 逐个字符压栈
    {
        elements[++top] = str[i];    // 压栈后栈顶指针上移
    }
    return int(str.length());    // 返回字符串的长度
}

int Stack::quo()
{
    int temp = top;    // 建立一个temp指针方便匹配时遍历
    char ch[100];    // 存储所有的右括号
    int j = 0;        // 用来取出ch数组对应的元素而设立的变量
    int flag = 0;    // 防止出现单个括号的情况
    int flags1 = 1;        // flags1和2确保后面对flag的操作只进行一次
    int flags2 = 1;

    for(int i = 0;i < top + 1;i++)     
    {
        // cout << "elements[" << temp << ']' << '=' << elements[temp] << endl;
         if(elements[temp] == '}' or elements[temp] == ']' or elements[temp] == ')')
        {
            if(flags1)
            {
                flag += 1;    // 如果有右括号，则flag标志位+1，并且该操作只进行一次
                flags1 = 0;
            }
            ch[i] = elements[temp];    // 如果elements[temp]是右括号，则将其赋值给ch[i]
            j++;                    // j++，方便后面对数组操作
            if(ch[i] == '}')            // 将ch数组元素对应的右括号转变为对应的左括号
                ch[i] = '{';
            if(ch[i] == ']')
                ch[i] = '[';
            if(ch[i] == ')')
                ch[i] = '(';
        }
        // ([])
        if(elements[temp] == '{' or elements[temp] == '[' or elements[temp] == '(')    // 如果匹配到左括号
        {    
            if(flags2)
            {    
                flag += 1;        // 如果有左括号，则flag标志位+1，并且该操作只进行一次
                flags2 = 0;
            }
            if(elements[temp] == ch[j-1])        // 如果和数组相应元素对应
            {
                j--;            // 数组元素也左移，准备下一次匹配
            }
            else                 // 如果不对应说明不匹配，则return 0
                return 0;
        }
        temp = temp - 1;    // temp下移
    }
    if(flag == 2 or flag == 0)
        return 1;        // 如果没有出现括号或出现左右括号且都匹配（即没有在for循环中return0），则说明匹配
    if(flag == 1)
        return 0;        // 如果只出现单括号，则返回0    

    return 0;    // 防止出现警告信息
}

main.cpp

#include <stdio.h>
#include <string.h>
#include "Stack.h"

// 201931223010 张泽宇 网络1901

int main()
{
    Stack s1(100);    // 建立栈
    s1.create_Stack();        // 向栈内输入表达式
    int k = s1.quo();        // 调用quo方法匹配括号
    cout << k << endl;    // 输出匹配结果
}

第二题

【问题描述】

已知Q是一个非空队列，S是一个空栈。仅使用少量工作变量以及对队列和栈的基本操作，编写一个算法，将队列Q中的所有元素逆置。

【输入形式】

输入的第一行为队列元素个数，第二行为队列从首至尾的元素

【输出形式】

输出队列的逆置

【样例输入】

3

1 2 3

【样例输出】

3 2 1

【评分标准】

需采用队列与栈的知识，否则不能得分

没写头文件，本来是写的了，交的时候忘了压缩了，就这样吧，我是懒狗

main.cpp

#include <iostream>
#include <string.h>
#include <stdlib.h>
using namespace std;

// 张泽宇 网络1901 201931223010

// 网络1901 张泽宇 201931223010

struct QueueNode    // 链式队列的节点
{
    int data;        // 存储数据
    QueueNode *link;    // 链接下一个队列节点
    QueueNode(int number,QueueNode *ptr = NULL) // 构造函数，含有头节点
    {
        data = number;
        link = ptr;
    }
};

class Queue     // 队列类
{
public:
    Queue();     // 构造函数
    void enter_Queue(int num);    // 入队
    void output();        // 输出
    int out_Queue();    // 出队

public:
    QueueNode *front;    // 头指针
    QueueNode *rear;    // 尾指针
};

Queue::Queue()
{
    front = rear = new QueueNode(0);    // 创建一个头节点，初始头指针和尾指针都指向该节点
}

void Queue::enter_Queue(int num)
{
    rear -> link = new QueueNode(num);    // 入队，new一片空间，然后将尾指针后移
    rear = rear -> link;
}

void Queue::output()
{
    QueueNode *temp = front -> link;    // 建立一个temp帮助输出
    while(temp != NULL)        // 输出队列元素值
    {
        cout << temp -> data << ' ';
        temp = temp -> link;    // 指针后移
    }
    cout << endl;
}

int Queue::out_Queue()        // 出队函数
{
    int x;    
    
    QueueNode *p = front -> link;        
    x = p -> data;            // 取队首节点的元素值
    front -> link = p -> link;    // 后移
    if(p == rear)    
        rear = front;
    delete p;
    return x;        // 将出队的元素返回
}


// 201931223010 张泽宇 网络1901

class Stack
{
public:
    Stack(int sz);    // 构造函数
    void Push(int x);    // 入栈
    int Pop();        // 出栈

public:
    int *elements;    // 栈数组
    int top;    // 栈顶指针
    int maxSize;    // 最大元素数量
};

Stack::Stack(int size): top(-1) , maxSize(size)        // 构造函数
{
    elements = new int[maxSize];        // 申请一片连续的存储空间
    if( elements == NULL )        // 如果分配错误则退出程序
    {
        cout << "alloca error!" << endl;
    }
}

void Stack::Push(int x)
{
    elements[++top] = x;        // 元素入栈
}

int Stack::Pop()
{
    int x;
    x = elements[top--];    // 元素出栈并返回
    return x;
}

int main()
{
    int cout_num,i;        // 定义变量
    Stack s1(8000);        // 创建栈对象
    cin >> cout_num;    // 输入的元素个数
    Queue q1;            // 创建队列对象
    int number;            // 将要输入队列的元素

    for(i = 0;i < cout_num; i++)
    {
        cin >> number;
        q1.enter_Queue(number);        // 将元素输入队列
    }

    for(i = 0;i < cout_num; i++)
    {
        number = q1.out_Queue();    // 元素出队
        s1.Push(number);            // 将出队的元素入栈，利用栈FILO的性质完成队列逆置
    }
    
    for(i = 0;i < cout_num; i++)
    {
        number = s1.Pop();        // 元素出栈，经过入栈和出栈，元素已经完成逆置
        q1.enter_Queue(number);    // 将出栈道元素入队
    }
    q1.output();        // 输出    
}

 二叉树作业

第一题：【问题描述】首先利用二叉树的前序遍历建立一棵二叉树，然后输入一个x值，在二叉树中搜索结点值为x的结点，找到函数返回该结点的指针，并输出success，找不到函数返回NULL，输出failure，该函数定义为二叉树类的一个成员函数，函数声明可以参考下面: 

BinTreeNode<T> * Find (BinTreeNode <T> *root,T item) ;  //在二叉树中搜索item

【输入形式】假设二叉树的结点为字符型，输入“#”表示空结点，输入有多行，第一行为建立二叉树用的字符串，具体见Sample Input，二叉树见教材P202页，图5.15，后面每一行为一个要搜索的x值，最后输入一个字符 '#' 结束

【输出形式】输出为多行，搜索x成功则输出success，搜索失败输出failure

【样例输入】

ABC##DE#G##F###

A

D

F

H

#

【样例输出】

success

success

success

failure

没做出来orz，参考了昊琛的代码，wtclllllllll

BinTree.h:

#include <iostream>
#include <stdlib.h>
using namespace std;

template <class T> 
struct BinTreeNode           
{     
     T data;                   // 放置数据
     BinTreeNode<T> *leftchild, *rightchild;   // 左孩子和右孩子
       BinTreeNode (T x, BinTreeNode<T> *lp = NULL, BinTreeNode<T> *rp = NULL) // 构造函数
     { 
        data = x;  
        leftchild = lp;  
        rightchild = rp; 
      }
};

template <class T> 
class BinaryTree     
{
  public:  
     BinaryTree (T value) : RefValue(value), root(NULL)  { }  // 构造函数

    BinTreeNode<T>* search(BinTreeNode<T> *root,T data);  // 搜索二叉树的值，返回BinTreeNode类型的指针
    void CreatTree(BinTreeNode<T> *& root);     // 先序创建二叉树
      
public:
     BinTreeNode<T> *root;     
     T RefValue;         
     
};


template <class T>
void BinaryTree<T>::CreatTree (BinTreeNode<T> *& root) 
{
   T item;
   cin >> item;
   if( item == '#' )    // 如果输入的值为'#'，说明为空，则令root等于NULL
   {
           root = NULL;
   }
   else
   {  
       root = new BinTreeNode<T>(item);
    CreatTree(root -> leftchild);        // 递归创建左子树
      CreatTree(root -> rightchild);        // 递归创建右子树
   }
}

template <class T>
BinTreeNode<T> * BinaryTree<T>::search (BinTreeNode<T> *root,T item)  // 搜索二叉树的值，返回BinTreeNode类型的指针
{  
  BinTreeNode<T> *work;   // 设立一个工作指针
    if (root == NULL)     // 如果当前节点为空，则返回空
        return NULL;
    if (root->data == item) // 如果搜索成功则返回当前节点指针
    {
        return root;
    }
    work = search(root->leftchild, item);   // 递归搜索左子树
    if (work != NULL)                       // 如果不为空则返回节点work
        return work;
    work = search(root->rightchild, item);  // 递归搜索右子树，到这里说明上一步左子树搜索为空值
    if (work != NULL)                   // 如果不为空返回节点work
        return work;
    return NULL;  
}

main.cpp:

#include "BinTree.h"
#include <string.h>
using namespace std;


int main()
{
    
    BinaryTree<char> n1('0');        // 创建类

    n1.CreatTree(n1.root);            // 先序生成二叉树
    char temp;

    while (1)                
    {
        cin >> temp;
        if(temp == '#')            // 不为#则继续
            break;
        if (n1.search(n1.root, temp) != NULL)    // 如果返回值不为空，说明找到，输出success
        {
            cout << "success" << endl;
        }
        else        // 返回值为空则查找失败
        {
            cout << "failure" << endl;
        }
    }

    return 0;
}

第二题：

【问题描述】首先利用二叉树的前序遍历建立一棵二叉树，分别用3个递归函数统计度为0，度为1和度为2的结点个数，并输出结果，这3个函数可以定义为二叉树的成员函数

【输入形式】假设二叉树的结点为字符型，输入“#”表示空结点，输入为一行字符串，具体见样例输入，二叉树见教材P202页，图5.15

【输出形式】输出只有1行，依次输出度为0的结点个数，度为1的结点个数，度为2的结点个数，3个数之间用空格分开，最后一个数据后面有一个空格，具体格式见样例输出

【样例输入】

ABC##DE#G##F###

【样例输出】

3 2 2

【样例说明】

其他测试数据：

输入：A##                             输出：1 0 0

输入：AB#D##C#E##        输出：2 2 1

比第一个简单多了QAQ

BinTree.h:

#include <iostream>
#include <stdlib.h>
using namespace std;

template <class T> 
struct BinTreeNode           
{     
     T data;                   // 放置数据
     BinTreeNode<T> *leftchild, *rightchild;   // 左孩子和右孩子
       BinTreeNode (T x, BinTreeNode<T> *lp = NULL, BinTreeNode<T> *rp = NULL) // 构造函数
     { 
        data = x;  
        leftchild = lp;  
        rightchild = rp; 
      }
};

template <class T> 
class BinaryTree     
{
  public:  
     BinaryTree (T value) : RefValue(value), root(NULL)  { }  // 构造函数
    void CreatTree(BinTreeNode<T> *& root);     // 先序创建二叉树
    void count_node(BinTreeNode<T> *root);  // 计算度为0，1，2的节点个数
      
public:
     BinTreeNode<T> *root;     
     T RefValue;
     int zero = 0;    // 度为0，1，2的节点个数，初始值为0
     int one = 0;
     int two = 0;         
     
};


template <class T>
void BinaryTree<T>::CreatTree (BinTreeNode<T> *& root) 
{
   T item;
   cin >> item;
   if( item == '#' )    // 如果输入的值为'#'，说明为空，则令root等于NULL
   {
           root = NULL;
   }
   else
   {  
       root = new BinTreeNode<T>(item);
    CreatTree(root -> leftchild);        // 递归创建左子树
      CreatTree(root -> rightchild);        // 递归创建右子树
   }
}


template <class T>
void  BinaryTree<T>::count_node(BinTreeNode<T> *root)
{  
    if(root -> leftchild == NULL && root -> rightchild == NULL) 
    // 如果一个节点的左右孩子都为空，则度为0
    {
      zero++;
    }

    if(root -> leftchild != NULL && root -> rightchild == NULL) 
    // 如果一个节点的左孩子不为空且右子树为空，则度为1，且递归调用计算其右孩子的度
    {
      one++;
      count_node(root -> leftchild);
    }

    if(root -> rightchild != NULL && root -> leftchild == NULL)
    // 如果一个节点的右孩子不为空且左子树为空，则度为1，且递归调用计算其左孩子的度
    {
      one++;
      count_node(root -> rightchild);
    }

    if(root -> leftchild != NULL && root -> rightchild != NULL)
    {
      // 如果一个节点的左右孩子都不为空，则度为2，且递归调用其左右孩子的度
      two++;
      count_node(root -> leftchild);
      count_node(root -> rightchild);
    }
}

main.cpp:

#include "BinTree.h"
#include <string.h>
using namespace std;


int main()
{
    
    BinaryTree<char> n1('0');        // 创建类

    n1.CreatTree(n1.root);            // 先序生成二叉树
    char temp;

    n1.count_node(n1.root);     // 计算度分别为0，1，2的节点数量

    cout << n1.zero << ' ' << n1.one << ' ' << n1.two << endl;  // 输出度分别为0，1，2的节点数量
    return 0;
}

#include <iostream>
#include <stdlib.h>
using namespace std;

/*
author: lemon
date: 2020-10-16
*/

struct LinkNode            // 定义链表节点类型的结构体
{
    LinkNode *link;        // 节点的指针
    int data;            // 节点的数据部分

    LinkNode(int num)    // 对一个节点进行初始化
    {
        link = NULL;
        data = num;
    }
};


class SingleList
{
public:
    SingleList()        // 构造函数
    {
        first = new LinkNode(0);
    }
    void create_SingleList();    // 创建链表
public:
    LinkNode *first;
};


void SingleList::create_SingleList()
{
    int number;            // 定义一个变量用来输入链表数据
    LinkNode *current = first;        // 定义两个工作指针 ｃｕｒｒｅｎｔ和ｗｏｒｋ
    LinkNode *work = first;

    while(true)
    {
        cin >> number;
        char c = cin.get(); // 获取当前输入字符
        work = new LinkNode(number);
        current -> link = work;        // 链接单链表
        current = work;    //链表后移
        if(c == '
')   // 如果当前输入是回车，则退出循环
        {
            break;
main.cp 

#include <iostream>
#include "SingleList.h"
using namespace std;

/*
author: lemon
date: 2020-10-16
*/

bool check_link_repeat(LinkNode *p)    // 定义一个检查链表上是否有重复元素的函数
{
    if(p -> link != NULL)        // 如果节点下一个节点不为空，则进入检查，否则返回false
    {
        if(p -> link -> data == p -> data)    // 如果当前节点的数据域等于下一个节点的数据域
        {
            return true;        // 如果通过if，则返回true
        }
        else
            return false;        // 否则返回false
    }
    else
        return false;
}


void output_TWO_link(LinkNode *s1,LinkNode *s2)
{
    LinkNode *current1 = s1 -> link;    // 分别定义两个current指针来对链表进行遍历操作
    LinkNode *current2 = s2 -> link;


    while(current1 != NULL || current2 != NULL)        // 如果current1和current2不同时为NULL，就一直循环
    {

        // ================================= same logic =================================
        if(current1 == NULL)            // 如果链表1为空
        {
            while(current2 != NULL)        // 当链表2不为空时进行循环
            {
                if(check_link_repeat(current2))    // 首先检查链表2中是否有相同元素
                {
                    current2 = current2 -> link;    // 如果有相同元素，则链表当前指针向后移动一个节点，然后continue
                    continue;
                }
                cout << current2 -> data << ' ';    // 输出链表2元素，同时指针向后移动
                current2 = current2 -> link;
            }
            break;
        }

        if(current2 == NULL)        // 此if语句和上面的if语句逻辑相同
        {
            while(current1 != NULL)        // 如果链表1不为空，就进入循环
            {
                if(check_link_repeat(current1))    // 检查链表1是否有相同元素
                {
                    current1 = current1 -> link;
                    continue;
                }
                cout << current1 -> data << ' ';
                current1 = current1 -> link;
            }
            break;
        } 
        // ================================= same logic =================================
        
        
        if(current1 -> data == current2 -> data)    // 如果链表1的数据元素等于链表2当前的数据元素，根据题目要求只输出一个即可
        {
            if(check_link_repeat(current1))        // 66-77行代码：首先对链表1和链表2 进行检查是否有重复元素
            {
                current1 = current1 -> link;
                continue;
            }

            if(check_link_repeat(current2))
            {
                current2 = current2 -> link;
                continue;
            }
            cout << current1 -> data << ' ';    // 输出一个即可
            current1 = current1 -> link;        // 链表1和链表2的指针同时向后移动
            current2 = current2 -> link;
            continue;
        }

        if(current1 -> data < current2 -> data)    // 如果链表1的当前数据小于链表2的元素，则输出链表1的元素，并且链表1的指针向后移动 
        {
            if(check_link_repeat(current1))    // 检查链表1是否有重复元素
            {
                current1 = current1 -> link;
                continue;
            }
            cout << current1 -> data << ' ';    // 输出链表1当前的元素值
            current1 = current1 -> link;        // 链表1指针向后移动
            continue;
        }

        if(current2 -> data < current1 -> data)    // 同理，如果链表2的当前数据小于链表1的元素，则输出链表2的元素，并且链表2的指针向后移动 
        {
            if(check_link_repeat(current2))
            {
                current2 = current2 -> link;
                continue;
            }
            cout << current2 -> data << ' ';
            current2 = current2 -> link;
            continue;
        }
    }
}

int main()
{
    SingleList s1;
    SingleList s2;

    s1.create_SingleList();        // 创建链表1和链表2
    s2.create_SingleList();

    output_TWO_link(s1.first,s2.first);    // 按合并的方式有序输出两个链表
    cout << endl;        // 最后输出回车

#include <iostream>
#include <stdlib.h>
using namespace std;


struct LinkNode            // 定义链表节点类型的结构体
{
    LinkNode *link;        // 节点的指针
    int data;            // 节点的数据部分

    LinkNode(int num)    // 对一个节点进行初始化
    {
        link = NULL;
        data = num;
    }
};


class SingleList
{
public:
    SingleList()        // 构造函数
    {
        first = new LinkNode(0);
    }

    void outPut();        // 输出该链表
    void create_SingleList();    // 创建链表
public:
    LinkNode *first;
};


void SingleList::outPut()
{
    int i = 0;                            // 定义一个变量辅助按格式输出
    LinkNode *current = first -> link;        // 定义一个current指针辅助输出
    
    while(true)
    {
        if(i == 0)
        {
            cout << current -> data;
            current = current -> link;        // 指针后移
            i++;
        }
        
        else
        {
            cout << "-->" << current -> data;
            current = current -> link;    // 指针后移
        }
        if( current == NULL )        // 遍历完毕，退出循环
        {
            cout << endl;
            break;
        }
    }
}

void SingleList::create_SingleList()
{
    int number;            // 定义一个变量用来输入链表数据
    LinkNode *current = first;        // 定义两个工作指针 ｃｕｒｒｅｎｔ和ｗｏｒｋ
    LinkNode *work = first;

    while(true)
    {
        cin >> number;
        if( number == -1)        // 输入-1时退出循环
            break;
        work = new LinkNode(number);    
        current -> link = work;        // 链接单链表
        current = work;    //链表后移 
    }
}


LinkNode* find_min(LinkNode *first)
{
    LinkNode *current = first -> link;    // 定义一个current指针
    int min = current -> data;
    LinkNode *min_link;            // 最小元素对应的节点

    while( true )
    {
        if( min > current -> data )
        {    
            min = current -> data;        // 遍历链表，找到最小元素值
            min_link = current;        // 记录最小元素值对应的节点，作为返回值返回
        }

        if( current -> link == NULL)        // 如果下一个节点为空，说明遍历完成
            break;    
        else
            current = current -> link;
    }
    if(min == first->link->data)
        return first->link;        // 如果最小值对应的节点为首元节点，则直接返回首元节点
    return min_link;            // 返回最小元素值对应的节点
}

void insert_header(LinkNode *first,LinkNode *min)
{
    LinkNode *current = first -> link;
    while(true)
    {
        if(min == first -> link)
        {    
            break;                // 如果最小元素值对应的节点就是首元节点，则不需要任何操作
        }

        if(current -> link != min)
        {
            current = current -> link;    // 遍历链表，找到最小元素值对应的节点
        }
        else
        {
            current -> link = min -> link;        // 使最小元素值对应节点之前的节点的下一个元素为最小元素值对应节点之后的节点，即将最小元素值脱链
            min -> link = first -> link;        // 将最小元素值对应的节点的下一个节点记为原本的首元节点
            first -> link = min;            // 将最小元素值对应的节点记在头节点后面，即为新的首元节点
            break;
        }
    }
}

int main()
{
    SingleList s1;
    
    s1.create_SingleList();            // 建立链表
    s1.outPut();                // 输出链表
    
    LinkNode *min_link;
    min_link = find_min(s1.first);        // 用一个linknode类型的指针接收最小元素值对应的节点
    insert_header(s1.first,min_link);    // 插入到头部成为首元节点
    s1.outPut();                // 输出改变后的链表

#include <iostream>
#include <stdlib.h>
using namespace std;

// 201931223010 张泽宇 网络1901 

struct LinkNode            // 定义链表节点类型的结构体
{
    LinkNode *link;        // 节点的指针
    int data;            // 节点的数据部分

    LinkNode(int num)    // 对一个节点进行初始化
    {
        link = NULL;
        data = num;
    }
};


class SingleList
{
public:
    SingleList()        // 构造函数
    {
        first = new LinkNode(0);
    }

    void outPut();        // 输出该链表
    void create_SingleList();    // 创建链表
public:
    LinkNode *first;
};


void SingleList::outPut()
{
    int i = 0;                            // 定义一个变量辅助按格式输出
    LinkNode *current = first -> link;        // 定义一个current指针辅助输出
    
    while(true)
    {
        if(i == 0)
        {
            cout << current -> data;
            current = current -> link;        // 指针后移
            i++;
        }
        
        else
        {
            cout << "-->" << current -> data;
            current = current -> link;    // 指针后移
        }
        if( current == NULL )        // 遍历完毕，退出循环
        {
            cout << endl;
            break;
        }
    }
}

void SingleList::create_SingleList()
{
    int number;            // 定义一个变量用来输入链表数据
    LinkNode *current = first;        // 定义两个工作指针 ｃｕｒｒｅｎｔ和ｗｏｒｋ
    LinkNode *work = first;

    while(true)
    {
        cin >> number;
        if( number == -1)        // 输入-1时退出循环
            break;
        work = new LinkNode(number);    
        current -> link = work;        // 链接单链表
        current = work;    //链表后移 
    }
}


LinkNode* find_min(LinkNode *first)
{
    LinkNode *current = first -> link;    // 定义一个current指针
    int min = current -> data;
    LinkNode *min_link;            // 最小元素对应的节点

    while( true )
    {
        if( min > current -> data )
        {    
            min = current -> data;        // 遍历链表，找到最小元素值
            min_link = current;        // 记录最小元素值对应的节点，作为返回值返回
        }

        if( current -> link == NULL)        // 如果下一个节点为空，说明遍历完成
            break;    
        else
            current = current -> link;
    }
    if(min == first->link->data)
        return first->link;        // 如果最小值对应的节点为首元节点，则直接返回首元节点
    return min_link;            // 返回最小元素值对应的节点
}

void insert_header(LinkNode *first,LinkNode *min)
{
    LinkNode *current = first -> link;
    while(true)
    {
        if(min == first -> link)
        {    
            break;                // 如果最小元素值对应的节点就是首元节点，则不需要任何操作
        }

        if(current -> link != min)
        {
            current = current -> link;    // 遍历链表，找到最小元素值对应的节点
        }
        else
        {
            current -> link = min -> link;        // 使最小元素值对应节点之前的节点的下一个元素为最小元素值对应节点之后的节点，即将最小元素值脱链
            min -> link = first -> link;        // 将最小元素值对应的节点的下一个节点记为原本的首元节点
            first -> link = min;            // 将最小元素值对应的节点记在头节点后面，即为新的首元节点
            break;
        }
    }
}

int main()
{
    SingleList s1;
    
    s1.create_SingleList();            // 建立链表
    s1.outPut();                // 输出链表
    
    LinkNode *min_link;
    min_link = find_min(s1.first);        // 用一个linknode类型的指针接收最小元素值对应的节点
    insert_header(s1.first,min_link);    // 插入到头部成为首元节点
    s1.outPut();