数据结构C语言版 实验报告

数据结构C语言版实验报告
一、实验目的
本次实验旨在通过使用 C 语言实现常见的数据结构，加深对数据结构基本概念、原理和操作的理解，提高编程能力和解决实际问题的能力。

二、实验环境
操作系统：Windows 10
编程环境：Visual Studio 2019
编程语言：C 语言
三、实验内容
1、线性表
顺序表的实现与操作
链表的实现与操作
2、栈和队列
栈的实现与应用（表达式求值）
队列的实现与应用（模拟排队）
3、树和二叉树
二叉树的遍历（前序、中序、后序）
二叉搜索树的实现与操作
4、图
图的存储结构（邻接矩阵、邻接表）
图的遍历（深度优先搜索、广度优先搜索）
四、实验步骤及结果
1、线性表
顺序表的实现与操作
定义顺序表的数据结构，包括数组和表的长度。

实现顺序表的初始化、插入、删除、查找等操作。

测试顺序表的各种操作，输出操作结果。

｀｀｀c
include ＜stdioh>
include ＜stdlibh>
define MAX_SIZE 100
typedef struct ｛
int dataMAX_SIZE;
int length;
｝ SeqList;
／／初始化顺序表
void initList(SeqList L) ｛
L>length ＝ 0;
｝
／／插入元素到顺序表
int insertList(SeqList L, int pos, int element) ｛
if （L>length ＞＝ MAX_SIZE ｜｜ pos ＜ 0 ｜｜ pos ＞ L>length) ｛
return 0;
｝
for （int i ＝ L>length 1; i ＞＝ pos; i) ｛
L>datai ＋ 1 ＝ L>datai;
｝
L>datapos ＝ element;
L>length+＋；
return 1;
｝
／／删除顺序表中的元素
int deleteList(SeqList L, int pos) ｛
if （pos ＜ 0 ｜｜ pos ＞＝ L>length) ｛return 0;
｝
for （int i ＝ pos; i ＜ L>length 1; i+＋）｛L>datai ＝ L>datai ＋ 1;
｝
L>length;
return 1;
｝
／／查找顺序表中的元素
int searchList(SeqList L, int element) ｛
for （int i ＝ 0; i ＜ Llength; i+＋）｛
if （Ldatai ＝＝ element) ｛
return i;
｝
｝
return －1;
｝
int main(）｛
SeqList L;
initList(＆L)；
insertList(＆L, 0, 10)；
insertList(＆L, 1, 20)；
insertList(＆L, 2, 30)；
printf(＂顺序表元素: ＂）；
for （int i ＝ 0; i ＜ Llength; i+＋）｛
printf(＂％d ＂， Ldatai)；
｝
printf(＂＼n"）；
int pos ＝ searchList(L, 20)；
if （pos!＝－1) ｛
printf(＂元素 20 在顺序表中的位置: ％d\n"， pos)；｝ else ｛
printf(＂顺序表中未找到元素 20\n"）；
｝
deleteList(＆L, 1)；
printf(＂删除元素后的顺序表元素: ＂）；
for （int i ＝ 0; i ＜ Llength; i+＋）｛
printf(＂％d ＂， Ldatai)；
｝
printf(＂＼n"）；
return 0;
｝
｀｀｀
实验结果：成功实现顺序表的初始化、插入、删除、查找等操作，输出结果符合预期。

链表的实现与操作
定义链表的节点结构，包含数据和指向下一个节点的指针。

实现链表的创建、插入、删除、查找等操作。

测试链表的各种操作，输出操作结果。

｀｀｀c
include ＜stdioh>
include ＜stdlibh>
typedef struct Node ｛
int data;
struct Node next;
｝ Node;
／／创建链表
Node createList(）｛
Node head ＝ NULL;
return head;
｝
／／插入节点到链表头部
Node insertHead(Node head, int element) ｛
Node newNode ＝（Node ）malloc(sizeof(Node)）；newNode>data ＝ element;
newNode>next ＝ head;
head ＝ newNode;
return head;
｝
／／插入节点到链表尾部
Node insertTail(Node head, int element) ｛
Node newNode ＝（Node ）malloc(sizeof(Node)）；newNode>data ＝ element;
newNode>next ＝ NULL;
if （head ＝＝ NULL) ｛
head ＝ newNode;
return head;
｝
Node temp ＝ head;
while （temp>next!＝ NULL) ｛
temp ＝ temp>next;
｝
temp>next ＝ newNode;
return head;
｝
／／删除链表中的节点
Node deleteNode(Node head, int element) ｛
Node temp ＝ head;
Node prev ＝ NULL;
if （temp!＝ NULL ＆＆ temp>data ＝＝ element) ｛head ＝ temp>next;
free(temp)；
return head;
｝
while （temp!＝ NULL ＆＆ temp>data!＝ element) ｛prev ＝ temp;
temp ＝ temp>next;
｝
if （temp ＝＝ NULL) ｛
return head;
｝
prev>next ＝ temp>next;
free(temp)；
return head;
｝
／／查找链表中的节点
Node searchNode(Node head, int element) ｛Node temp ＝ head;
while （temp!＝ NULL) ｛
if （temp>data ＝＝ element) ｛
return temp;
｝
temp ＝ temp>next;
｝
return NULL;
｝
int main(）｛
Node head ＝ createList(）；
head ＝ insertHead(head, 10)；
head ＝ insertTail(head, 20)；
head ＝ insertTail(head, 30)；
printf(＂链表元素: ＂）；
while （temp!＝ NULL) ｛
printf(＂％d ＂， temp>data)；
temp ＝ temp>next;
｝
printf(＂＼n"）；
Node foundNode ＝ searchNode(head, 20)；if （foundNode!＝ NULL) ｛
printf(＂找到元素 20\n"）；
｝ else ｛
printf(＂未找到元素 20\n"）；
｝
head ＝ deleteNode(head, 20)；
printf(＂删除元素后的链表元素: ＂）；temp ＝ head;
while （temp!＝ NULL) ｛
printf(＂％d ＂， temp>data)；
｝
printf(＂＼n"）；
return 0;
｝
｀｀｀
实验结果：成功实现链表的创建、插入、删除、查找等操作，输出结果符合预期。

2、栈和队列
栈的实现与应用（表达式求值）
定义栈的数据结构。

实现栈的入栈、出栈操作。

使用栈来计算表达式的值。

｀｀｀c
include ＜stdioh>
include ＜stdlibh>
include ＜ctypeh>
define MAX_SIZE 100
typedef struct ｛
int dataMAX_SIZE;
int top;
｝ Stack;
／／初始化栈
void initStack(Stack S) ｛
S>top ＝－1;
｝
／／入栈
void push(Stack S, int element) ｛if （S>top ＝＝ MAX_SIZE 1) ｛printf(＂栈已满，无法入栈\n"）；return;
｝
S>data+＋S>top ＝ element;
｝
／／出栈
int pop(Stack S) ｛
if （S>top ＝＝－1) ｛
printf(＂栈为空，无法出栈\n"）；return －1;
｝
return S>dataS>top;
｝
／／计算表达式的值
int evaluateExpression(char expression) ｛Stack S;
initStack(＆S)；
int i ＝ 0;
while （expressioni!＝＇＼0'）｛
if （isdigit(expressioni)）｛
push(＆S, expressioni ＇0'）；
｝ else ｛
int operand2 ＝ pop(＆S)；
int operand1 ＝ pop(＆S)；
switch （expressioni) ｛
case ＇＋＇：
push(＆S, operand1 ＋ operand2)；break;
case ＇＇：
push(＆S, operand1 operand2)；break;
case ＇＇：
push(＆S, operand1 operand2)；break;
case ＇／＇：
if （operand2!＝ 0) ｛
push(＆S, operand1 ／ operand2)；｝ else ｛
printf(＂除数不能为 0\n"）；return －1;
｝
break;
｝
｝
i+＋；
｝
return pop(＆S)；
｝
int main(）｛
char expression ＝＂23+4"；
int result ＝ evaluateExpression(expression)；
printf(＂表达式％s 的值为: ％d\n"， expression, result)；return 0;
｝
｀｀｀
实验结果：能够正确计算给定表达式的值。

队列的实现与应用（模拟排队）
定义队列的数据结构。

实现队列的入队、出队操作。

模拟排队过程，输出队列的变化情况。

include ＜stdioh>
include ＜stdlibh>
define MAX_SIZE 10
typedef struct ｛
int dataMAX_SIZE;
int front;
int rear;
｝ Queue;
／／初始化队列
void initQueue(Queue Q) ｛
Q>front ＝ 0;
Q>rear ＝ 0;
｝
／／入队
int enQueue(Queue Q, int element) ｛
if （（Q>rear ＋ 1) ％ MAX_SIZE ＝＝ Q>front) ｛printf(＂队列已满，无法入队\n"）；
｝
Q>dataQ>rear ＝ element;
Q>rear ＝（Q>rear ＋ 1) ％ MAX_SIZE; return 1;
｝
／／出队
int deQueue(Queue Q) ｛
if （Q>front ＝＝ Q>rear) ｛
printf(＂队列为空，无法出队\n"）；return －1;
｝
int element ＝ Q>dataQ>front;
Q>front ＝（Q>front ＋ 1) ％ MAX_SIZE; return element;
｝
int main(）｛
Queue Q;
initQueue(＆Q)；
enQueue(＆Q, 10)；
enQueue(＆Q, 20)；
enQueue(＆Q, 30)；
printf(＂队列元素: ＂）；
int temp;
while （（temp ＝ deQueue(＆Q)）！＝－1) ｛
printf(＂％d ＂， temp)；
｝
printf(＂＼n"）；
return 0;
｝
｀｀｀
实验结果：成功模拟排队过程，展示队列的入队和出队操作。

3、树和二叉树
二叉树的遍历（前序、中序、后序）
定义二叉树的节点结构。

实现二叉树的创建。

实现前序、中序、后序遍历算法，并输出遍历结果。

｀｀｀c
include ＜stdioh>
include ＜stdlibh>
typedef struct TreeNode ｛
int data;
struct TreeNode left;
struct TreeNode right;
｝ TreeNode;
／／创建二叉树节点
TreeNode createNode(int data) ｛
TreeNode newNode ＝（TreeNode ）malloc(sizeof(TreeNode)）；newNode>data ＝ data;
newNode>left ＝ NULL;
newNode>right ＝ NULL;
return newNode;
｝
／／前序遍历
if （root ＝＝ NULL) ｛
return;
｝
printf(＂％d ＂， root>data)；preOrderTraversal(root>left)；preOrderTraversal(root>right)；
｝
／／中序遍历
void inOrderTraversal(TreeNode root) ｛if （root ＝＝ NULL) ｛
return;
｝
inOrderTraversal(root>left)；
printf(＂％d ＂， root>data)；inOrderTraversal(root>right)；
｝
／／后序遍历
if （root ＝＝ NULL) ｛return;
｝
postOrderTraversal(root>left)；postOrderTraversal(root>right)；printf(＂％d ＂， root>data)；
｝
int main(）｛
TreeNode root ＝ createNode(1)；root>left ＝ createNode(2)；root>right ＝ createNode(3)；root>left>left ＝ createNode(4)；root>left>right ＝ createNode(5)；printf(＂前序遍历: ＂）；preOrderTraversal(root)；
printf(＂＼n"）；
printf(＂中序遍历: ＂）；
inOrderTraversal(root)；
printf(＂＼n"）；
printf(＂后序遍历: ＂）；
postOrderTraversal(root)；
printf(＂＼n"）；
return 0;
｝
｀｀｀
实验结果：正确输出二叉树的前序、中序、后序遍历结果。

二叉搜索树的实现与操作
定义二叉搜索树的节点结构。

实现二叉搜索树的插入、删除、查找操作。

测试二叉搜索树的各种操作，输出操作结果。

｀｀｀c
include ＜stdioh>
include ＜stdlibh>
typedef struct BSTNode ｛
int data;
struct BSTNode left;
struct BSTNode right;
｝ BSTNode;
／／创建二叉搜索树节点
BSTNode createBSTNode(int data) ｛
BSTNode newNode ＝（BSTNode ）malloc(sizeof(BSTNode)）；newNode>data ＝ data;
newNode>left ＝ NULL;
newNode>right ＝ NULL;
return newNode;
｝
／／插入节点到二叉搜索树
BSTNode insertBST(BSTNode root, int data) ｛
if （root ＝＝ NULL) ｛
return createBSTNode(data)；
｝
if （data ＜ root>data) ｛
root>left ＝ insertBST(root>left, data)；
｝ else if （data ＞ root>data) ｛
root>right ＝ insertBST(root>right, data)；
｝
return root;
｝
／／查找二叉搜索树中的节点
BSTNode searchBST(BSTNode root, int data) ｛if （root ＝＝ NULL ｜｜ root>data ＝＝ data) ｛return root;
｝
if （data ＜ root>data) ｛
return searchBST(root>left, data)；
｝ else ｛
return searchBST(root>right, data)；
｝
｝
／／找到最小节点
BSTNode findMinimum(BSTNode root) ｛while （root>left!＝ NULL) ｛
root ＝ root>left;
｝
return root;
｝
／／删除二叉搜索树中的节点
BSTNode deleteBST(BSTNode root, int data) ｛if （root ＝＝ NULL) ｛
return root;
｝
if （data ＜ root>data) ｛
root>left ＝ deleteBST(root>left, data)；
｝ else if （data ＞ root>data) ｛
root>right ＝ deleteBST(root>right, data)；
｝ else ｛
if （root>left ＝＝ NULL) ｛
BSTNode temp ＝ root>right;
free(root)；
return temp;
｝ else if （root>right ＝＝ NULL) ｛BSTNode temp ＝ root>left;
free(root)；
return temp;
｝
BSTNode temp ＝ findMinimum(root>right)；root>data ＝ temp>data;
root>right ＝ deleteBST(root>right, temp>data)；｝
return root;
｝。