数据结构--实验

已于 2024-06-08 09:56:33 修改
阅读量359 收藏 3
点赞数 11
分类专栏： 大学专业课程 文章标签： 数据结构 c++ 算法
于 2024-06-08 09:56:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74031434/article/details/138646110
版权

话不多说，直接启动！👌🤣

目录

一、线性表😎

1、建立链表 

 2、插入元素

3、删除特定位置的元素

 4、输出特定元素值的位置

5、输出特定位置的元素值

 6、输出整个链表

 实现

二、栈和队列😘

栈

顺序栈

1、建立顺序栈

2、入栈

3、出栈

4、取栈顶

5、遍历栈

6、判栈空

实现： 

链栈

1、建立链栈

2、入栈

3、出栈

4、取栈顶

5、遍历栈

6、判栈空

实现： 

队列

顺序队列

1、建立顺序队列

2、入队

3、出队

4、求队列长度

5、遍历队列

实现：

链式队列

1、建立链式队列

2、入队

3、出队

4、求队列长度

5、遍历队列

实现：

 三、树和二叉树

实现：

 四、图

实现：

五、查找和排序

 折半查找实现：

快速排序实现： 

 

一、线性表😎

1、建立链表 

#include<iostream>
#include<vector>
using namespace std;
//定义单链表结点结构体 
struct ListNode{
	int val;
	ListNode* next;
};
//创建链表
ListNode* CreateList(){
	ListNode* head = new ListNode();//创建头结点
	head->next = nullptr;//初始化头结点的next指针为空
	
	return head; 
} 
int main(){
	ListNode* head = CreateList();
}

 2、插入元素

//在链表中插入元素
void Insert(ListNode* head, int i, int val) { // 需要链表，第i个位置，插入val值
    ListNode* current = head; // 初始化当前结点为头结点
    while (i-- > 0) { // 循环i次找插入位置
        current = current->next;
    }
    ListNode* newNode = new ListNode();
    newNode->val = val;
    newNode->next = current->next;
    current->next = newNode;
}

3、删除特定位置的元素

//删除特定位置的元素
void Delete(ListNode* head,int index){//需要链表，第i个位置
	if(index<0)return;
	ListNode* current = head;
	for(int i=0;i<index&&current!=nullptr;i++){
		current=current->next;
	}
	if(current==nullptr)return;
	ListNode* toDelete = current->next;
    current->next = current->next->next;
    delete toDelete;
}

 4、输出特定元素值的位置

//输出特定元素值的位置
void PrintValue(ListNode* head, int index) {
    ListNode* current = head;
    int position = 0;
    while (current != nullptr) {
        if (current->val == index) {
            cout << "元素值：" << current->val << " 的位置是：" << position << endl;
            break;
        }
        current = current->next;
        position++;
    }
    if (current == nullptr) {
        cout << "索引超出链表范围" << endl;
    }
}

5、输出特定位置的元素值

//输出特定位置的元素值
void PrintNodeAtPosition(ListNode* head, int index) {
    ListNode* current = head;
    for (int i = 0; i < index && current != nullptr; i++) {
        current = current->next;
    }
    if (current != nullptr) {
        cout << "元素位置：" << index << ", 值：" << current->val << endl;
    } else {
        cout << "索引超出链表范围" << endl;
    }
}

 6、输出整个链表

//输出整个链表
void PrintList(ListNode* head) {
    ListNode* current = head;
    while (current != nullptr) {
        cout << current->val << " --> ";
        current = current->next;
    }
    cout << "nullptr" << endl;
}

 实现

#include<iostream>
#include<vector>
using namespace std;
//定义单链表结点结构体 
struct ListNode{
	int val;
	ListNode* next;
};
//创建链表
ListNode* CreateList(){
	ListNode* head = new ListNode();//创建头结点
	head->next = nullptr;//初始化头结点的next指针为空
	
	return head; 
} 
//在链表中插入元素
void Insert(ListNode* head, int i, int val) { // 需要链表，第i个位置，插入val值
    ListNode* current = head; // 初始化当前结点为头结点
    while (i-- > 0) { // 循环i次找插入位置
        current = current->next;
    }
    ListNode* newNode = new ListNode();
    newNode->val = val;
    newNode->next = current->next;
    current->next = newNode;
}
//删除特定位置的元素
void Delete(ListNode* head,int index){//需要链表，第i个位置
	if(index<0)return;
	ListNode* current = head;
	for(int i=0;i<index&&current!=nullptr;i++){
		current=current->next;
	}
	if(current==nullptr)return;
	ListNode* toDelete = current->next;
    current->next = current->next->next;
    delete toDelete;
}
//从输入读取链表元素并插入
void ReadInputToList(ListNode* head) {
    cout << "请输入你需要建立的初始链表（只允许实数）：" << endl;
    vector<double> LinkList;
    double input;
    while (cin >> input) {
        LinkList.push_back(input);
		if(cin.peek() == '\n'){
    		cin.ignore();
    		break;
		}
    }
    int index = 0;
    for (double value : LinkList) {
        Insert(head, index++, static_cast<int>(value)); // 将读取的实数转换为整数后插入链表
    }
} 
//输出特定元素值的位置
void PrintValue(ListNode* head, int index) {
    ListNode* current = head;
    int position = 0;
    while (current != nullptr) {
        if (current->val == index) {
            cout << "元素值：" << current->val << " 的位置是：" << position << endl;
            break;
        }
        current = current->next;
        position++;
    }
    if (current == nullptr) {
        cout << "索引超出链表范围" << endl;
    }
}

//输出特定位置的元素值
void PrintNodeAtPosition(ListNode* head, int index) {
    ListNode* current = head;
    for (int i = 0; i < index && current != nullptr; i++) {
        current = current->next;
    }
    if (current != nullptr) {
        cout << "元素位置：" << index << ", 值：" << current->val << endl;
    } else {
        cout << "索引超出链表范围" << endl;
    }
}
//输出整个链表
void PrintList(ListNode* head) {
    ListNode* current = head;
    while (current != nullptr) {
        cout << current->val << " --> ";
        current = current->next;
    }
    cout << "nullptr" << endl;
}
int main(){
	ListNode* head = CreateList();
	ReadInputToList(head);
	cout<<"1.输出链表中的所有结点"<<endl;
	PrintList(head);
	cout<<"2.输出元素25的位置"<<endl;
	PrintValue(head,25);
	cout<<"3.输出第5个元素"<<endl;
	PrintNodeAtPosition(head,5);
	cout<<"4.在第 3 个元素前插入值为 98 的元素，然后输出链表"<<endl;
	Insert(head,3,98);
	PrintList(head);
	cout<<"5.输出删除第 4 个元素后的链表"<<endl;
	Delete(head,4);
	PrintList(head);
	return 0;
}

二、栈和队列😘

栈

顺序栈

1、建立顺序栈
// 建立顺序栈
struct Stack {
    int *elem; // 指向动态分配的数组
    int top; // 栈顶指针
    int MaxSize; // 栈的最大容量
};

// 创建栈
Stack* CreateStack(int MaxSize) {
    Stack* stack = new Stack();
    stack->elem = new int[MaxSize];
    stack->top = -1;
    stack->MaxSize = MaxSize;
    return stack;
}
2、入栈
// 入栈
void Push(Stack* stack, int val) {
    if (stack->top < stack->MaxSize - 1) { // 如果栈未满
        stack->elem[++stack->top] = val; // 栈顶指针后移并赋值
    } else {
        cout << "栈已满，无法入栈" << endl;
    }
}
3、出栈
// 出栈
int Pop(Stack* stack) {
    if (stack->top >= 0) { // 如果栈非空
        return stack->elem[stack->top--]; // 返回栈顶元素并移动栈顶指针
    } else {
        cout << "栈为空，无法出栈" << endl;
        return -1; // 返回-1表示栈空
    }
}
4、取栈顶
// 取栈顶
int GetTop(Stack* stack) {
    if (stack->top >= 0) { // 如果栈非空
        return stack->elem[stack->top]; // 返回栈顶元素
    } else {
        cout << "栈为空，无法获取栈顶元素。" << endl;
        return -1; // 返回-1表示栈空
    }
}
5、遍历栈
// 遍历栈
void TraverseStack(Stack* stack) {
        for (int i = 0; i <= stack->top; i++) {
            cout << stack->elem[i] << " ";
        }
        cout << endl;
}
6、判栈空
// 判断栈是否为空
bool IsEmpty(Stack* stack) {
    return stack->top < 0; // 如果栈顶指针小于0，则栈为空
}
实现： 
#include <iostream>
#include <vector>
using namespace std;

// 建立顺序栈
struct Stack {
    int *elem; // 指向动态分配的数组
    int top; // 栈顶指针
    int MaxSize; // 栈的最大容量
};

// 创建栈
Stack* CreateStack(int MaxSize) {
    Stack* stack = new Stack();
    stack->elem = new int[MaxSize];
    stack->top = -1;
    stack->MaxSize = MaxSize;
    return stack;
}

// 入栈
void Push(Stack* stack, int val) {
    if (stack->top < stack->MaxSize - 1) { // 如果栈未满
        stack->elem[++stack->top] = val; // 栈顶指针后移并赋值
    } else {
        cout << "栈已满，无法入栈" << endl;
    }
}

// 出栈
int Pop(Stack* stack) {
    if (stack->top >= 0) { // 如果栈非空
        return stack->elem[stack->top--]; // 返回栈顶元素并移动栈顶指针
    } else {
        cout << "栈为空，无法出栈" << endl;
        return -1; // 返回-1表示栈空
    }
}

// 取栈顶
int GetTop(Stack* stack) {
    if (stack->top >= 0) { // 如果栈非空
        return stack->elem[stack->top]; // 返回栈顶元素
    } else {
        cout << "栈为空，无法获取栈顶元素。" << endl;
        return -1; // 返回-1表示栈空
    }
}

// 遍历栈
void TraverseStack(Stack* stack) {
        for (int i = 0; i <= stack->top; i++) {
            cout << stack->elem[i] << " ";
        }
        cout << endl;
}

// 判断栈是否为空
bool IsEmpty(Stack* stack) {
    return stack->top < 0; // 如果栈顶指针小于0，则栈为空
}

// 从输入读取元素并添加
void ReadInputToStack(Stack* stack) {
    cout << "请输入你需要建立的初始顺序栈（只允许实数）：" << endl;
    vector<double> Arr;
    double input;
    while (cin >> input) {
        Arr.push_back(input);
        if (cin.peek() == '\n') {
            cin.ignore();
            break;
        }
    }
    int index = 0;
    for (double value : Arr) { // 遍历Arr而不是stack
        Push(stack, static_cast<int>(value));
    }
}

int main() {
    int max = 0;
    cout << "请输入栈的最大容量：" << endl;
    cin >> max;
    Stack* stack = CreateStack(max);
    ReadInputToStack(stack);
    TraverseStack(stack);
    return 0;
}

链栈

1、建立链栈
// 定义链栈节点结构体
struct StackNode {
    int val;
    StackNode* next;
};

// 创建链栈
StackNode* CreateStack() {
    StackNode* head = new StackNode(); // 创建头节点
    head->next = nullptr;
    return head;
}
2、入栈
// 入栈操作
void Push(StackNode* head, int val) {
    StackNode* newNode = new StackNode{val, nullptr}; // 创建新节点
    newNode->next = head->next; // 将新节点链接到链表
    head->next = newNode; // 头节点指向新节点
}
3、出栈
// 出栈操作
int Pop(StackNode* head) {
    if (head->next == nullptr) {
        cout << "栈为空，无法出栈。" << endl;
        return -1; // 返回-1表示栈空
    }
    StackNode* temp = head->next; // 临时节点
    int val = temp->val; // 保存要返回的值
    head->next = temp->next; // 头节点指向下一个节点
    delete temp; // 释放临时节点
    return val; // 返回栈顶元素
}
4、取栈顶
// 获取栈顶元素
int GetTop(StackNode* head) {
    if (head->next == nullptr) {
        cout << "栈为空，无法获取栈顶元素。" << endl;
        return -1; // 返回-1表示栈空
    }
    return head->next->val; // 返回栈顶元素
}
5、遍历栈
// 遍历链栈
void TraverseStack(StackNode* head) {
    if (head->next == nullptr) {
        cout << "栈为空。" << endl;
        return;
    }
    StackNode* current = head->next; // 从栈顶开始遍历
    cout << "链栈元素: ";
    while (current != nullptr) {
        cout << current->val << " ";
        current = current->next; // 移动到下一个节点
    }
    cout << endl;
}
6、判栈空
// 判断栈是否为空
bool IsEmpty(StackNode* head) {
    return head->next == nullptr; // 如果头节点的next指针为空，则栈为空
}
实现： 
#include<iostream>
using namespace std;

// 定义链栈节点结构体
struct StackNode {
    int val;
    StackNode* next;
};

// 创建链栈
StackNode* CreateStack() {
    StackNode* head = new StackNode(); // 创建头节点
    head->next = nullptr;
    return head;
}

// 入栈操作
void Push(StackNode* head, int val) {
    StackNode* newNode = new StackNode{val, nullptr}; // 创建新节点
    newNode->next = head->next; // 将新节点链接到链表
    head->next = newNode; // 头节点指向新节点
}

// 出栈操作
int Pop(StackNode* head) {
    if (head->next == nullptr) {
        cout << "栈为空，无法出栈。" << endl;
        return -1; // 返回-1表示栈空
    }
    StackNode* temp = head->next; // 临时节点
    int val = temp->val; // 保存要返回的值
    head->next = temp->next; // 头节点指向下一个节点
    delete temp; // 释放临时节点
    return val; // 返回栈顶元素
}

// 遍历链栈
void TraverseStack(StackNode* head) {
    if (head->next == nullptr) {
        cout << "栈为空。" << endl;
        return;
    }
    StackNode* current = head->next; // 从栈顶开始遍历
    cout << "链栈元素: ";
    while (current != nullptr) {
        cout << current->val << " ";
        current = current->next; // 移动到下一个节点
    }
    cout << endl;
}

// 获取栈顶元素
int GetTop(StackNode* head) {
    if (head->next == nullptr) {
        cout << "栈为空，无法获取栈顶元素。" << endl;
        return -1; // 返回-1表示栈空
    }
    return head->next->val; // 返回栈顶元素
}

// 判断栈是否为空
bool IsEmpty(StackNode* head) {
    return head->next == nullptr; // 如果头节点的next指针为空，则栈为空
}

int main() {
    StackNode* stack = CreateStack(); // 创建链栈
    
    cout << "入栈元素: 10, 20, 30, 40, 50" << endl;
    Push(stack, 10);
    Push(stack, 20);
    Push(stack, 30);
    Push(stack, 40);
    Push(stack, 50);
    
    cout << "栈顶元素: " << GetTop(stack) << endl;
    cout << "出栈元素: " << Pop(stack) << endl;
    cout << "栈顶元素: " << GetTop(stack) << endl;
    
    TraverseStack(stack); // 调用遍历链栈的方法
    
    cout << "栈是否为空: " << (IsEmpty(stack) ? "是" : "否") << endl;
    
    return 0;
}

队列

顺序队列

1、建立顺序队列
// 定义队列结构体
struct Queue {
    vector<int> elements; // 使用vector来存储队列元素
};

// 创建队列
Queue* CreateQueue() {
    return new Queue(); // 创建队列对象
}
2、入队
// 入队操作
void Enqueue(Queue* queue, int val) {
    queue->elements.push_back(val); // 将元素添加到队列末尾
}
3、出队
// 出队操作
int Dequeue(Queue* queue) {
    if (queue->elements.empty()) { // 如果队列为空
        cout << "队列为空，无法出队。" << endl;
        return -1; // 返回-1表示队空
    }
    int val = queue->elements.front(); // 获取队首元素
    queue->elements.erase(queue->elements.begin()); // 删除队首元素
    return val; // 返回队首元素
}
4、求队列长度
int GetQueueLength(Queue* queue) {
    return queue->elements.size(); // 返回队列中元素的数量
}
5、遍历队列
// 遍历队列
void TraverseQueue(Queue* queue) {
    if (queue->elements.empty()) { // 如果队列为空
        cout << "队列为空。" << endl;
        return;
    }
    cout << "队列元素: ";
    for (int val : queue->elements) {
        cout << val << " ";
    }
    cout << endl;
}
实现：
#include<iostream>
#include<vector>
using namespace std;

// 定义队列结构体
struct Queue {
    vector<int> elements; // 使用vector来存储队列元素
};

// 创建队列
Queue* CreateQueue() {
    return new Queue(); // 创建队列对象
}

// 入队操作
void Enqueue(Queue* queue, int val) {
    queue->elements.push_back(val); // 将元素添加到队列末尾
}

// 出队操作
int Dequeue(Queue* queue) {
    if (queue->elements.empty()) { // 如果队列为空
        cout << "队列为空，无法出队。" << endl;
        return -1; // 返回-1表示队空
    }
    int val = queue->elements.front(); // 获取队首元素
    queue->elements.erase(queue->elements.begin()); // 删除队首元素
    return val; // 返回队首元素
}

// 获取队列长度
int GetQueueLength(Queue* queue) {
    return queue->elements.size(); // 返回队列中元素的数量
}

// 遍历队列
void TraverseQueue(Queue* queue) {
    if (queue->elements.empty()) { // 如果队列为空
        cout << "队列为空。" << endl;
        return;
    }
    cout << "队列元素: ";
    for (int val : queue->elements) {
        cout << val << " ";
    }
    cout << endl;
}

// 获取队首元素
int GetFront(Queue* queue) {
    if (queue->elements.empty()) { // 如果队列为空
        cout << "队列为空，无法获取队首元素。" << endl;
        return -1; // 返回-1表示队空
    }
    return queue->elements.front(); // 返回队首元素
}

// 判断队列是否为空
bool IsEmpty(Queue* queue) {
    return queue->elements.empty(); // 如果队列大小为0，则队列为空
}

int main() {
    Queue* queue = CreateQueue(); // 创建队列
    
    cout << "入队元素: 10, 20, 30, 40, 50" << endl;
    Enqueue(queue, 10);
    Enqueue(queue, 20);
    Enqueue(queue, 30);
    Enqueue(queue, 40);
    Enqueue(queue, 50);
    
    TraverseQueue(queue); // 遍历队列
    
    cout << "队列长度: " << GetQueueLength(queue) << endl;
    
    cout << "队首元素: " << GetFront(queue) << endl;
    cout << "出队元素: " << Dequeue(queue) << endl;
    cout << "队首元素: " << GetFront(queue) << endl;
    
    cout << "队列是否为空: " << (IsEmpty(queue) ? "是" : "否") << endl;
    
    return 0;
}

链式队列

1、建立链式队列
// 定义链队列节点结构体
struct QueueNode {
    int val;
    QueueNode* next;
};

// 创建链队列
QueueNode* CreateQueue() {
    QueueNode* head = new QueueNode(); // 创建头节点
    head->next = nullptr;
    return head;
}
2、入队
// 入队操作
void Enqueue(QueueNode* head, int val) {
    QueueNode* newNode = new QueueNode{val, nullptr}; // 创建新节点
    newNode->next = head->next; // 将新节点链接到链表
    head->next = newNode; // 头节点指向新节点
}
3、出队
// 出队操作
int Dequeue(QueueNode* head) {
    if (head->next == nullptr) {
        cout << "队列为空，无法出队。" << endl;
        return -1; // 返回-1表示队空
    }
    QueueNode* temp = head->next; // 临时节点
    int val = temp->val; // 保存要返回的值
    head->next = temp->next; // 头节点指向下一个节点
    delete temp; // 释放临时节点
    return val; // 返回队首元素
}
4、求队列长度
// 获取队列长度
int GetQueueLength(QueueNode* head) {
    int length = 0;
    QueueNode* current = head->next;
    while (current != nullptr) {
        length++; // 计算队列中元素的数量
        current = current->next;
    }
    return length;
}
5、遍历队列
// 遍历队列
void TraverseQueue(QueueNode* head) {
    if (head->next == nullptr) { // 如果队列为空
        cout << "队列为空。" << endl;
        return;
    }
    QueueNode* current = head->next;
    cout << "队列元素: ";
    while (current != nullptr) {
        cout << current->val << " ";
        current = current->next; // 移动到下一个节点
    }
    cout << endl;
}
实现：
#include<iostream>
using namespace std;

// 定义链队列节点结构体
struct QueueNode {
    int val;
    QueueNode* next;
};

// 创建链队列
QueueNode* CreateQueue() {
    QueueNode* head = new QueueNode(); // 创建头节点
    head->next = nullptr;
    return head;
}

// 入队操作
void Enqueue(QueueNode* head, int val) {
    QueueNode* newNode = new QueueNode{val, nullptr}; // 创建新节点
    QueueNode* current = head;
    while (current->next != nullptr) {
        current = current->next; // 移动到链表末尾
    }
    current->next = newNode; // 将新节点链接到链表末尾
}

// 出队操作
int Dequeue(QueueNode* head) {
    if (head->next == nullptr) {
        cout << "队列为空，无法出队。" << endl;
        return -1; // 返回-1表示队空
    }
    QueueNode* temp = head->next; // 临时节点
    int val = temp->val; // 保存要返回的值
    head->next = temp->next; // 头节点指向下一个节点
    delete temp; // 释放临时节点
    return val; // 返回队首元素
}

// 获取队列长度
int GetQueueLength(QueueNode* head) {
    int length = 0;
    QueueNode* current = head->next;
    while (current != nullptr) {
        length++; // 计算队列中元素的数量
        current = current->next;
    }
    return length;
}

// 遍历队列
void TraverseQueue(QueueNode* head) {
    if (head->next == nullptr) { // 如果队列为空
        cout << "队列为空。" << endl;
        return;
    }
    QueueNode* current = head->next;
    cout << "队列元素: ";
    while (current != nullptr) {
        cout << current->val << " ";
        current = current->next; // 移动到下一个节点
    }
    cout << endl;
}

// 获取队首元素
int GetFront(QueueNode* head) {
    if (head->next == nullptr) {
        cout << "队列为空，无法获取队首元素。" << endl;
        return -1; // 返回-1表示队空
    }
    return head->next->val; // 返回队首元素
}

// 判断队列是否为空
bool IsEmpty(QueueNode* head) {
    return head->next == nullptr; // 如果头节点的next指针为空，则队列空
}

int main() {
    QueueNode* queue = CreateQueue(); // 创建链队列
    
    cout << "入队元素: 10, 20, 30, 40, 50" << endl;
    Enqueue(queue, 10);
    Enqueue(queue, 20);
    Enqueue(queue, 30);
    Enqueue(queue, 40);
    Enqueue(queue, 50);
    
    TraverseQueue(queue); // 遍历队列
    
    cout << "队列长度: " << GetQueueLength(queue) << endl;
    
    cout << "队首元素: " << GetFront(queue) << endl;
    cout << "出队元素: " << Dequeue(queue) << endl;
    cout << "队首元素: " << GetFront(queue) << endl;
    
    cout << "队列是否为空: " << (IsEmpty(queue) ? "是" : "否") << endl;
    
    return 0;
}

 三、树和二叉树

 

实现：

#include<iostream>
using namespace std;

// 结构体
struct Bittree {
    char data;
    Bittree *lchild;
    Bittree *rchild;
};

// 先序构建二叉树
Bittree* Creat() {
    char n;
    scanf(" %c", &n); // 注意在%c前加空格，以跳过任何前导空白
    if (n == '#') {
        return NULL;
    } else {
        Bittree* T = new Bittree();
        T->data = n;
        T->lchild = Creat();
        T->rchild = Creat();
        return T;
    }
}

// 先序遍历
void PreOrder(Bittree *T) {
    if (T) {
        printf("%2c", T->data);
        PreOrder(T->lchild);
        PreOrder(T->rchild);
    }
}

// 中序遍历
void InOrder(Bittree *T) {
    if (T) {
        InOrder(T->lchild);
        printf("%2c", T->data);
        InOrder(T->rchild);
    }
}

// 后序遍历
void PostOrder(Bittree *T) {
    if (T) {
        PostOrder(T->lchild);
        PostOrder(T->rchild);
        printf("%2c", T->data);
    }
}

// 统计叶子结点的个数
int Leaf(Bittree *T) {
    int LeafCount;
    if (T == NULL)
        LeafCount = 0;
    else if (T->lchild == NULL && T->rchild == NULL)
        LeafCount = 1;
    else
        LeafCount = Leaf(T->lchild) + Leaf(T->rchild);
    return LeafCount;
}

// 计算二叉树的深度
int TreeDepth(Bittree *T) {
    if (T == NULL)
        return 0;
    else {
        int depthleft = TreeDepth(T->lchild) + 1;
        int depthright = TreeDepth(T->rchild) + 1;
        return depthleft > depthright ? depthleft : depthright;
    }
}

int main() {
    printf("先序构造一颗二叉树（左/右孩子为空用'#'表示)：");
    Bittree *T = Creat();
    printf("此二叉树的先序遍历序列是:");
    PreOrder(T);
    printf("\n");
    printf("此二叉树的中序遍历序列是:");
    InOrder(T);
    printf("\n");
    printf("此二叉树的后序遍历序列是:");
    PostOrder(T);
    printf("\n");
    printf("这棵树叶子结点有%d个\n", Leaf(T));
    printf("这棵树的深度为:%d\n", TreeDepth(T));
    system("pause");
    return 0;
}

 四、图

实现：

#include<iostream>
#include<stack> // 引入栈头文件
using namespace std;
#define MAX_NUM 100

// 定义邻接矩阵
struct Graph{
    int MaxArr[MAX_NUM][MAX_NUM];
    int num;
}; 

// 初始化图
Graph* create(int n){
    Graph* graph=new Graph();
    graph->num=n;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            graph->MaxArr[i][j]=0;
        }
    }
    return graph;
} 

// 添加单向边
void addEdge(Graph* graph,int src,int dest){
    graph->MaxArr[src][dest]=1;
} 

// 广度优先搜索
bool bfs(Graph* graph,int start,int end,int* parent){
    int visited[MAX_NUM];
    bool inQueue[MAX_NUM];
    int queue[MAX_NUM];
    int front=0,rear=0;
    
    for(int i=0;i<graph->num;i++){
        visited[i]=false;
        inQueue[i]=false;
        parent[i]=-1;
    }
    
    queue[rear++]=start;
    inQueue[start]=true;
    visited[start]=true;
    
    while(front<rear){
        int current=queue[front++];
        for(int i=0;i<graph->num;i++){
            if(!visited[i]&&graph->MaxArr[current][i]==1){
                queue[rear++]=i;
                inQueue[i]=true;
                visited[i]=true;
                parent[i]=current;
            }
        }
    }
    return visited[end];
} 

// 输出路径
void printPath(int* parent,int end){
    printf("Path from start to %d: ", end);
    if(parent[end]==-1){
        printf("There is no path\n");
        return;
    }
    stack<int> path; // 使用栈来存储路径
    int current = end;
    while(current != -1) {
        path.push(current); // 将节点压入栈中
        current = parent[current];
    }
    // 逐个弹出栈中的元素以实现倒序输出
    while(!path.empty()) {
        printf("%d ", path.top());
        path.pop();
        if(!path.empty()) {
            printf("-> ");
        }
    }
    printf("\n");
} 

int main(){
    int Num,start,end;
    printf("输入结点个数：");
    scanf("%d",&Num);
    Graph* graph=create(Num);
    
    printf("输入边（以'src dest'形式，输入0 0结束）：");
    int src,dest;
    while(true){
        cin >> src >> dest;
        if(src == 0 && dest == 0) break; // 如果输入是0 0，则结束循环
        addEdge(graph,src,dest);
    }
    
    printf("输入起点：");
    scanf("%d",&start);
    
    printf("输入终点：");
    scanf("%d",&end);
    
    int* parent=(int*)malloc(Num*sizeof(int));
    if(bfs(graph,start,end,parent)){
        printPath(parent,end);
    }else{
        printf("There is no path\n");
    }
    
    free(parent);
    delete graph;
    return 0;
}

 

五、查找和排序

 折半查找实现：

#include <stdio.h>

// 折半查找函数
int binarySearch(int arr[], int l, int r, int x) {
    if (r >= l) {
        int mid = l + (r - l) / 2;

        // 如果中间元素正好是要找的值，返回索引
        if (arr[mid] == x)
            return mid;

        // 如果中间元素比要找的值小，在右半部分继续查找
        if (arr[mid] < x)
            return binarySearch(arr, mid + 1, r, x);

        // 如果中间元素比要找的值大，在左半部分继续查找
        return binarySearch(arr, l, mid - 1, x);
    }

    // 如果数组中没有找到值，返回-1
    return -1;
}

int main() {
    int arr[] = {12, 23, 28, 35, 37, 39, 50, 60, 78, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    int x;

    printf("输入待查找记录：");
    scanf("%d", &x);

    int result = binarySearch(arr, 0, n - 1, x);

    if (result == -1)
        printf("该记录不存在。\n");
    else
        printf("该记录在表中位置 %d。\n", result);

    return 0;
}

快速排序实现： 

#include <stdio.h>
int partition(int arr[], int low, int high);
void swap(int *xp, int *yp);

// 快速排序函数
void quickSort(int arr[], int low, int high) {
    if (low < high) {
        int pi = partition(arr, low, high);

        // 递归排序左半部分
        quickSort(arr, low, pi - 1);

        // 递归排序右半部分
        quickSort(arr, pi + 1, high);
    }
}

// 用于快速排序的辅助函数，用于分区
int partition(int arr[], int low, int high) {
    int pivot = arr[high]; // 选择最后一个元素作为基准
    int i = (low - 1); // 初始化指向比基准小的元素的指针

    for (int j = low; j <= high - 1; j++) {
        // 如果当前元素小于或等于基准，则交换元素
        if (arr[j] <= pivot) {
            i++;
            swap(&arr[i], &arr[j]);
        }
    }
    swap(&arr[i + 1], &arr[high]); // 将基准元素放在正确的位置
    return (i + 1);
}

// 交换两个元素
void swap(int *xp, int *yp) {
    int temp = *xp;
    *xp = *yp;
    *yp = temp;
}

int main() {
    int arr[] = {12, 23, 28, 35, 37, 39, 50, 60, 78, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    quickSort(arr, 0, n - 1);

    printf("排序后的数组：\n");
    for (int i = 0; i < n; i++)
        printf("%d ", arr[i]);

    return 0;
}

Li清水
关注
  • 11
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言-数据结构-栈-实验报告
m0_46566665的博客
12-23 6772
实验报告内容： 一、实验目的、要求： （1）熟练掌握栈的特点(先进后出FILO)及基本操作，如入栈、出栈等，栈的顺序存储结构和链式存储结构，以便在实际问题背景下灵活应用。 （2）编写适当的主函数和相关函数，使实验题目运行出正确结果。 （3）当场编程、调试、编译。 （4）程序具有一定的健壮性、可读性，尽量简洁。 （5）程序运行完成后分别存盘，上交实验报告，要求写出实验体会 二、实验内容： （1）实验题目 （2）主要函数的算法设计思想 （3）程序清单 （3）测试数据、实验结果及结论 （4）实验体会（实验中存在的
数据结构实验-二叉树实验
12-13
数据结构实验-二叉树实验
数据结构--实验二:二叉树的创建及遍历
OMTE910的博客
11-26 2960
一.实验目的 (1)熟练掌握二叉树的结构特征，以及各种存储结构的特点及适用范围。 (2)掌握在二叉链表存储结构中的常用遍历方法：先序递归遍历、中序递归遍历、后序递归遍历、中序遍历非递归算法；了解二叉树的层序遍历。 (3)了解二叉树遍历算法的简单应用。 二.实验内容 1.问题描述 已知二叉树，如图所示,基于图示二叉树编程实现以下算法： (1) 创建二叉树，以先序次序输入二叉树序列创建二叉树； (2) 采用先序遍历的递归算法遍历二叉树，并输出先序序列； (3) 采用中序遍历的递归和非递归算法遍历二叉树，并输出中
数据结构--实验一:一元多项式的乘法与加法运算
OMTE910的博客
11-26 2832
实验一:一元多项式的乘法与加法运算 1.实验目的 熟练掌握链式线性表的基本操作,以及在多项式运算上的应用。 2.实验内容 设计函数分别求两个一元多项式的乘积与和。 3.实验要求 (1)输人说明:输入分2行,每行分别先给出多项式非零项的个数,再以指数递降方式输入一个多项式非零项系数和指数(绝对值均为不超过1000的整数)。数字间以空格分隔。 (2)输出说明:输出分2行,分别以指数递降方式输出乘积多项式以及和多项式非零项的系数和指数。数字间以空格分隔,但结尾不能有多余空格。 (3)测试用例: 序号 输入 输出
数据结构-计算器实验报告
weixin_45908225的博客
07-25 3998
一、实验目的和要求 1. 设计并实现计算器。 要求：在课后作业-03、课后作业-05的作业内容基础上 （1）增加图形交互功能。 （2）增加3个逻辑运算符 &&、||、 ！，并能处理逻辑运算符和算术运算符的混合运算。 （3）增加容错功能，能进行异常处理。 二、实验环境 Qt 5.9 三、实验内容 在课后作业-03、课后作业-05的作业内容基础上 （1）增加图形交互功能。 （2）增加3个逻辑运算符 &&、||、 ！，并能处理逻辑运算符和算术运算符的混合运算。 （3）增加容错功能，
数据结构--哈夫曼树
热门推荐
XUN__MLF的博客
03-03 4万+
哈夫曼树及其应用 1、哈夫曼树的基本概念 路径：从树中一个结点到另一个结点之间的分支构成这两个结点间的路径 结点的路径长度：两结点间路径上的分支数。 树的路径长度：从树根到每一个结点的路径长度之和。记作TL 结点树目相同的二叉树中，完全二叉树是路径长度最短的二叉树 权(weight):将树中结点赋给一个有着某种含义的数值，则这个数值称为该结点的权 1结点的带权路径长度：从根结点到该结点之间的路径长度与该结点的权的乘积 树的带权路径长
数据结构--实验1.doc
10-10
数据结构--实验1.doc
c++数据结构-实验.zip
07-17
c++数据结构--实验 线性表的基本操作 1.实验内容与要求 1）理解线性表的概念 2）设计一个线性表，分别用顺序存储结构和链式存储结构实现，完成线性表的构造、查找、插入、删除、输出等基本操作。 3）掌握两种存储...
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。 2.再从键盘输入顺序任意的5个整数，按有序插入的要求生成第二个有序单链表，将该链表输出显示。 3.将这两个有序单链表...
数据结构-迷宫实验报告.doc
08-27
数据结构-迷宫实验报告.doc
数据结构（初阶3.单链表）
2401_83968713的博客
07-14 657
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 425
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构第35节 性能优化 算法的选择
hummhumm的专栏
07-18 388
算法的选择对于优化程序性能至关重要。不同的算法在时间复杂度、空间复杂度以及适用场景上有着明显的差异。下面我将结合具体的代码示例，来讲解几种常见的算法选择及其优化方法。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1851
栈超超超详解
数据结构(5.1)——树的性质
m0_65240792的博客
07-16 211
1%29%5D。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
最新发布
weixin_54468359的博客
07-18 934
24暑假刷题day15打卡 二叉树进阶
【数据结构】二叉树-1
m0_46676283的博客
07-15 864
现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
【数据结构】线性结构——数组、链表、栈和队列
Filotimo_的博客
07-15 1193
线性结构是指数据元素之间存在一对一的关系，包括数组、链表、栈和队列等。这里介绍了这四种数据结构的优缺点和适用场景。
【排序算法】—— 归并排序
2302_80105876的博客
07-15 826
归并排序，排序，归并排序非递归，有序数组排序，外排序算法
数据结构实验与习题解析
"这本《数据结构实验与习题》旨在帮助计算机专业的学生克服在学习数据结构过程中遇到的困难，提供理论学习与实践操作相结合的指导。它特别关注那些编程基础较弱的学生，提供了C语言基础知识的复习，以及一系列上机...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值