数据结构算法大全有代码

合集下载

C程序经典算法50例

C程序经典算法50例1.二分查找算法：在有序数组中查找指定元素。

2.冒泡排序算法：通过不断比较相邻元素并交换位置，将较大的元素向后冒泡。

3.快速排序算法：通过选择一个基准元素，将数组分割为左右两部分，并递归地对两部分进行快速排序。

4.插入排序算法：将数组划分为已排序和未排序两部分，每次从未排序中选择一个元素插入到已排序的合适位置。

5.选择排序算法：遍历数组，每次选择最小元素并放置在已排序部分的末尾。

6.希尔排序算法：将数组按照一定间隔进行分组并分别进行插入排序，然后逐步减小间隔并重复这个过程。

7.归并排序算法：将数组递归地划分为两部分，然后将两个有序的部分进行合并。

8.桶排序算法：将元素根据特定的映射函数映射到不同的桶中，然后对每个桶分别进行排序。

9.计数排序算法：统计每个元素的出现次数，然后根据计数进行排序。

10.基数排序算法：从低位到高位依次对元素进行排序。

11.斐波那契数列算法：计算斐波那契数列的第n项。

12.阶乘算法：计算给定数字的阶乘。

13.排列问题算法：生成给定数组的全排列。

14.组合问题算法：生成给定数组的所有组合。

15.最大连续子序列和算法：找出给定数组中和最大的连续子序列。

16.最长递增子序列算法：找出给定数组中的最长递增子序列。

17.最长公共子序列算法：找出两个给定字符串的最长公共子序列。

18.最短路径算法：计算给定有向图的最短路径。

19.最小生成树算法：构建给定连通图的最小生成树。

20.汉诺塔算法：将n个圆盘从一个柱子移动到另一个柱子的问题。

21.BFS算法：广度优先算法，用于图的遍历和查找最短路径。

22.DFS算法：深度优先算法，用于图的遍历和查找连通分量。

23.KMP算法：字符串匹配算法，用于查找一个字符串是否在另一个字符串中出现。

24.贪心算法：每次都选择当前情况下最优的方案，适用于求解一些最优化问题。

25.动态规划算法：将一个大问题划分为多个子问题，并通过子问题的解求解整个问题，适用于求解一些最优化问题。

数据结构经典题目及c语言代码

数据结构经典题目及c语言代码一、线性表1. 顺序表顺序表是一种利用连续存储空间存储元素的线性表。

以下是一个顺序表的经典题目及C语言代码实现：```c#define MaxSize 50typedef struct {int data[MaxSize]; // 存储元素的数组int length; // 顺序表的当前长度} SeqList;// 初始化顺序表void initList(SeqList *L) {L->length = 0;}// 插入元素到指定位置void insert(SeqList *L, int pos, int elem) {if (pos < 1 || pos > L->length + 1) {printf("插入位置无效\n");return;}if (L->length == MaxSize) {printf("顺序表已满，无法插入\n"); return;}for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1];}L->data[pos - 1] = elem;L->length++;}// 删除指定位置的元素void delete(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("删除位置无效\n");return;}for (int i = pos - 1; i < L->length - 1; i++) {L->data[i] = L->data[i + 1];}L->length--;}// 获取指定位置的元素值int getElement(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("位置无效\n");return -1;}return L->data[pos - 1];}```2. 链表链表是一种利用非连续存储空间存储元素的线性表。

c语言算法100例

c语言算法100例以下是一些经典的C语言算法题目，总共提供100个例子供你练习和学习：1.编写一个程序，计算并输出斐波那契数列的前20个数。

2.编写一个程序，判断一个数是否为素数。

3.编写一个程序，计算并输出一个数的阶乘。

4.编写一个程序，实现两个数的交换（不使用第三个变量）。

5.编写一个程序，找出一个数组中的最大值。

6.编写一个程序，将一个字符串反转。

7.编写一个程序，判断一个字符串是否为回文字符串。

8.编写一个程序，实现冒泡排序算法对一个数组进行排序。

9.编写一个程序，实现二分查找算法在一个有序数组中查找指定的元素。

10.编写一个程序，计算并输出斐波那契数列的第n个数。

11.编写一个程序，将一个二维数组顺时针旋转90度。

12.编写一个程序，计算并输出一个数的平方根。

13.编写一个程序，判断一个字符串中是否包含重复字符。

14.编写一个程序，实现插入排序算法对一个数组进行排序。

15.编写一个程序，将一个有序数组合并为一个有序数组。

16.编写一个程序，判断一个数是否为完全数（即所有因子之和等于该数本身）。

17.编写一个程序，计算并输出一个数的倒数。

18.编写一个程序，判断一个字符串是否是另一个字符串的子串。

19.编写一个程序，实现选择排序算法对一个数组进行排序。

20.编写一个程序，计算并输出两个数的最大公约数。

21.编写一个程序，实现快速排序算法对一个数组进行排序。

22.编写一个程序，将一个字符串中的所有空格替换为指定的字符。

23.编写一个程序，判断一个数是否是回文数。

24.编写一个程序，计算并输出两个数的最小公倍数。

25.编写一个程序，实现归并排序算法对一个数组进行排序。

26.编写一个程序，判断一个字符串是否是有效的括号串。

27.编写一个程序，计算并输出一个数的立方根。

28.编写一个程序，实现堆排序算法对一个数组进行排序。

29.编写一个程序，判断一个数是否是质数。

30.编写一个程序，计算并输出一个数的二进制表示。

C#常用数据结构与算法

C常用数据结构与算法1.数据结构1.1 数组- 定义- 常用操作：访问元素、添加元素、删除元素、查找元素 - 应用场景1.2 链表- 定义- 常用操作：插入节点、删除节点、查找节点- 单链表、双链表、循环链表的区别- 应用场景1.3 栈- 定义- 常用操作：入栈、出栈、查看栈顶元素、判断栈是否为空 - 可使用数组或链表实现- 应用场景1.4 队列- 定义- 常用操作：入队、出队、查看队首元素、查看队尾元素、判断队列是否为空- 可使用数组或链表实现- 应用场景1.5 哈希表- 定义- 常用操作：插入键值对、删除键值对、根据键查找值、计算哈希值- 冲突解决方法：开放寻址法、链地质法- 应用场景2.常用算法2.1 排序算法- 冒泡排序- 插入排序- 选择排序- 快速排序- 归并排序- 堆排序2.2 查找算法- 线性查找- 二分查找- 插值查找- 哈希查找- 树查找（二叉搜索树、平衡二叉树、红黑树）2.3 图算法- 广度优先搜索- 深度优先搜索- 最短路径算法（Dijkstra算法、Floyd-Warshall算法） - 最小树算法（Prim算法、Kruskal算法）2.4 动态规划- 背包问题- 最长公共子序列- 最大子数组和3.附件：无4.法律名词及注释：- C: C是一种通用的、面向对象的编程语言，由微软公司开发。

- 数据结构：数据结构是计算机中组织和存储数据的方式。

- 算法：算法是解决问题的一系列步骤或过程。

- 数组：数组是一种线性数据结构，由一系列元素组成，每个元素都有唯一的索引值。

- 链表：链表是一种线性数据结构，由一系列节点组成，每个节点都包含数据和指向下一个节点的指针。

- 栈：栈是一种后进先出（LIFO）的数据结构，只能在栈顶进行操作。

- 队列：队列是一种先进先出（FIFO）的数据结构，只能在队首和队尾进行操作。

- 哈希表：哈希表是一种使用哈希函数将键映射到值的数据结构。

- 排序算法：排序算法是将一组数据按照特定顺序排列的算法。

C语言常用算法程序汇总

C语言常用算法程序汇总C语言是一门广泛应用于计算机编程的语言，具有较高的效率和灵活性。

在C语言中，常见的算法程序包括排序算法、查找算法、递归算法等等。

以下是一些常用的C语言算法程序的汇总：1.排序算法：-冒泡排序：通过多次迭代比较相邻元素并交换位置，将最大的元素逐渐移动到正确的位置。

-插入排序：将待排序的元素与已排序的部分依次比较并插入到正确的位置。

-选择排序：每次从待排序的元素中选择最小的元素并与已排序的部分交换位置。

-快速排序：通过选择一个基准元素，将数组划分为两个子数组进行递归排序。

2.查找算法：-顺序查找：逐个比较数组中的元素，直到找到目标元素或到数组末尾。

-二分查找：通过比较目标元素与数组中间元素的大小，逐步缩小范围，直到找到目标元素。

-哈希查找：通过散列函数将目标元素映射到哈希表的索引位置进行查找。

3.递归算法：-阶乘：通过递归调用自身计算一个正整数的阶乘。

-斐波那契数列：通过递归调用自身计算斐波那契数列的第n个数。

-二叉树遍历：通过递归调用自身遍历二叉树的各个节点。

4.图算法：- 最短路径算法：如Dijkstra算法和Floyd算法，用于计算图中两个节点之间的最短路径。

-拓扑排序：通过对有向无环图进行排序，使得所有的边从排在前面的节点指向排在后面的节点。

- 最小生成树：如Prim算法和Kruskal算法，用于找到图中连接所有节点的最小子树。

5.动态规划：-最长公共子序列：通过寻找两个字符串中的最长公共子序列，解决字符串匹配问题。

-背包问题：通过动态规划解决在给定容量下选取物品使得总价值最大的问题。

-最大子序列和：通过动态规划解决一个数组中选取连续子序列使得和最大的问题。

以上只是一些C语言中常用的算法程序的汇总，实际上，还有很多其他的算法，如逆波兰表达式、霍夫曼编码、最小割等等。

通过学习这些算法，可以更好地理解C语言的应用和开发。

源代码--数据结构与算法(Python版)chap10 排序

20
交换类
（2）快速排序快速排序采用分而治之(Divide and Conquer)
的策略将问题分解成若干个较小的子问题，采用相同的方法一一解决后，再将子问题的结果整合成最终答案。快速排序的每一轮处理其实就是将这一的基准数定位，直到所有的数都排序完成为止。
21
快速排序的基本步骤：
1. 选定一个基准值（通常可选第一个元素）； 2. 将比基准值小的数值移到基准值左边，形
14
• 交换类
交换类排序的基本思想是：通过交换无序序列中的记录得到其中关键字最小或最大的记录，并将其加入到有序子序列中，最终形成有序序列。交换类排序可分为冒泡排序和快速排序等。
15
交换类
（1）冒泡排序两两比较待排序记录的关键字，发现两
个记录的次序相反时即进行交换，直到没有反序的记录为止。因为元素会经由交换慢慢浮到序列顶端，故称之为冒泡排序。
3. 最后对这个组进行插入排序。步长的选法一般为 d1 约为 n/2，d2 为 d1 /2， d3 为 d2/2 ，…， di = 1。
11
【例】给定序列（11，9，84，32，92，26，58，91，35， 27，46，28，75，29，37，12 ），步长设为d1 =5、d2 =3、 d3 =1，希尔排序过程如下：
for i in range(1,len(alist)):
#外循环n-1
for j in range(i,0,-1):
#内循环
if alist[j]<alist[j-1]:
alist[j],alist[j-1]=alist[j-1],alist[j] #交换
li=[59,12,77,64,72,69,46,89,31,9] print('before: ',li) insert_sort(li) print('after: ',li)

二叉树c语言实现完整代码

二叉树c语言实现完整代码二叉树是一种非常常见的数据结构，它由节点和边组成，每个节点最多有两个子节点，分别称为左子节点和右子节点。

在计算机科学中，二叉树被广泛应用于搜索、排序、编译器等领域。

本文将介绍如何使用C语言实现二叉树的完整代码。

我们需要定义二叉树的节点结构体。

每个节点包含三个成员变量：数据、左子节点和右子节点。

代码如下：```struct TreeNode {int val;struct TreeNode *left;struct TreeNode *right;};```接下来，我们需要实现二叉树的基本操作，包括创建节点、插入节点、删除节点、查找节点等。

这些操作可以通过递归实现。

代码如下：```// 创建节点struct TreeNode* createNode(int val) {struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));node->val = val;node->left = NULL;node->right = NULL;return node;}// 插入节点struct TreeNode* insertNode(struct TreeNode* root, int val) {if (root == NULL) {return createNode(val);}if (val < root->val) {root->left = insertNode(root->left, val);} else {root->right = insertNode(root->right, val);}return root;}// 删除节点struct TreeNode* deleteNode(struct TreeNode* root, int val) {if (root == NULL) {return NULL;}if (val < root->val) {root->left = deleteNode(root->left, val);} else if (val > root->val) {root->right = deleteNode(root->right, val);} else {if (root->left == NULL) {struct TreeNode* temp = root->right;free(root);return temp;} else if (root->right == NULL) {struct TreeNode* temp = root->left;free(root);return temp;}struct TreeNode* temp = findMin(root->right); root->val = temp->val;root->right = deleteNode(root->right, temp->val); }return root;}// 查找节点struct TreeNode* searchNode(struct TreeNode* root, int val) {if (root == NULL || root->val == val) {return root;}if (val < root->val) {return searchNode(root->left, val);} else {return searchNode(root->right, val);}}// 查找最小节点struct TreeNode* findMin(struct TreeNode* root) {while (root->left != NULL) {root = root->left;}return root;}```我们需要实现二叉树的遍历操作，包括前序遍历、中序遍历和后序遍历。

《数据结构》的全部代码实现C语言

/* c1.h (程序名) */#include<string.h>#include<ctype.h>#include<malloc.h> /* malloc()等*/#include<limits.h> /* INT_MAX等*/#include<stdio.h> /* EOF(=^Z或F6),NULL */#include<stdlib.h> /* atoi() */#include<io.h> /* eof() */#include<math.h> /* floor(),ceil(),abs() */#include<process.h> /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1/* #define OVERFLOW -2 因为在math.h中已定义OVERFLOW的值为3,故去掉此行*/ typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE *//* algo2-1.c 实现算法2.1的程序*/#include"c1.h"typedef int ElemType;#include"c2-1.h"/*c2-1.h 线性表的动态分配顺序存储结构*/#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量*/#define LISTINCREMENT 2/* 线性表存储空间的分配增量*/typedef struct{ElemType*elem; /* 存储空间基址*/int length; /* 当前长度*/int listsize; /* 当前分配的存储容量(以sizeof(ElemType)为单位) */}SqList;#include"bo2-1.c"/* bo2-1.c 顺序表示的线性表(存储结构由c2-1.h定义)的基本操作(12个) */ Status InitList(SqList*L) /* 算法2.3 */{ /* 操作结果：构造一个空的顺序线性表*/(*L).elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!(*L).elem)exit(OVERFLOW); /* 存储分配失败*/(*L).length=0; /* 空表长度为0 */(*L).listsize=LIST_INIT_SIZE; /* 初始存储容量*/return OK;}Status DestroyList(SqList*L){ /* 初始条件：顺序线性表L已存在。

C语言入门必学—10个经典C语言算法

C语言入门必学—10个经典C语言算法C语言是一种广泛使用的编程语言，具有高效、灵活和易学的特点。

它不仅在软件开发中被广泛应用，也是计算机科学专业的必修课。

在学习C语言的过程中，掌握一些经典的算法是非常重要的。

本文将介绍10个经典C语言算法，帮助读者更好地了解和掌握C语言。

一、冒泡排序算法（Bubble Sort）冒泡排序算法是最简单、也是最经典的排序算法之一。

它通过不断比较相邻的元素并交换位置，将最大（或最小）的元素逐渐“冒泡”到数组的最后（或最前）位置。

二、选择排序算法（Selection Sort）选择排序算法是一种简单但低效的排序算法。

它通过不断选择最小（或最大）的元素，并与未排序部分的第一个元素进行交换，将最小（或最大）的元素逐渐交换到数组的前面（或后面）。

三、插入排序算法（Insertion Sort）插入排序算法是一种简单且高效的排序算法。

它通过将数组分为已排序和未排序两个部分，依次将未排序部分的元素插入到已排序部分的合适位置。

四、快速排序算法（Quick Sort）快速排序算法是一种高效的排序算法。

它采用了分治的思想，通过将数组分为较小和较大两部分，并递归地对两部分进行排序，最终达到整个数组有序的目的。

五、归并排序算法（Merge Sort）归并排序算法是一种高效的排序算法。

它采用了分治的思想，将数组一分为二，递归地对两个子数组进行排序，并将结果合并，最终得到有序的数组。

六、二分查找算法（Binary Search）二分查找算法是一种高效的查找算法。

它通过不断将查找范围折半，根据中间元素与目标值的大小关系，缩小查找范围，最终找到目标值所在的位置。

七、递归算法（Recursive Algorithm）递归算法是一种通过自我调用的方式解决问题的算法。

在C语言中，递归算法常用于解决树的遍历、问题分解等情况。

八、斐波那契数列算法（Fibonacci Sequence）斐波那契数列是一列数字，其中每个数字都是前两个数字的和。

C语言常用算法大全

C语言常用算法大全1.排序算法-冒泡排序：依次比较相邻的两个元素，如果顺序不对则交换，每轮找出一个最大或最小的元素-选择排序：从未排序的元素中选择最小或最大的放到已排序的最后，以此类推-插入排序：将未排序的元素插入到已排序的合适位置，从后向前进行比较和交换-快速排序：选择一个基准元素，将小于基准元素的放在左边，大于基准元素的放在右边，然后对左右两边递归地进行快速排序-归并排序：将待排序的序列不断划分为左右两部分，分别排序后再将排序好的左右两部分按顺序合并-堆排序：构建大顶堆，将堆顶元素与末尾元素交换，然后重新调整堆，重复这个过程直到排序完成2.查找算法-顺序查找：从给定的元素序列中逐个比较，直到找到目标元素或遍历完整个序列-二分查找：对于有序序列，在序列的中间位置比较目标元素和中间元素的大小关系，通过每次缩小一半的范围来查找目标元素-插值查找：根据目标元素与有序序列的最小值和最大值的比例推测目标元素所在的位置，然后递归地进行查找-斐波那契查找：根据斐波那契数列的性质来确定目标元素所在的位置，然后递归地进行查找3.图算法-深度优先（DFS）：从图的一些顶点出发，依次访问其未被访问过的邻接顶点，直到所有顶点都被访问过为止-广度优先（BFS）：从图的一些顶点出发，逐层遍历图的顶点，直到所有顶点都被访问过为止- 最小生成树算法：Prim算法和Kruskal算法，用于找到连接图中所有顶点的最小权值边，构成一棵包含所有顶点的生成树- 最短路径算法：Dijkstra算法和Floyd-Warshall算法，用于找到图中两个顶点之间的最短路径-拓扑排序：用于有向无环图（DAG）中的顶点排序，确保排序后的顶点满足所有依赖关系-关键路径算法：找出网络中的关键路径，即使整个工程完成的最短时间4.字符串算法- KMP算法：通过预处理模式串构建next数组，利用next数组在匹配过程中跳过一部分不可能匹配的子串- Boyer-Moore算法：从模式串的末尾开始匹配，利用坏字符和好后缀规则进行跳跃匹配- Rabin-Karp算法：利用哈希函数对主串和匹配串的子串进行哈希计算，然后比较哈希值是否相等- 字符串匹配算法：BM算法、Shift-And算法、Sunday算法等，用于寻找模式串在主串中的出现位置5.动态规划算法-最长公共子序列（LCS）：用于寻找两个序列中最长的公共子序列-最长递增子序列（LIS）：用于寻找给定序列中最长的递增子序列-0-1背包问题：将有限的物品放入容量为C的背包中，使得物品的总价值最大-最大子数组和：用于求解给定数组中连续子数组的最大和-最大正方形：在给定的0-1矩阵中，找出只包含1的最大正方形的边长这些算法是在C语言中常用的算法，它们涵盖了排序、查找、图、字符串和动态规划等多个领域。

数据结构常考的5个算法

数据结构常考的5个算法1. 递归算法递归是一种将问题分解为相同或相似的子问题解决的方法。

在递归算法中，一个函数可以调用自己来解决更小规模的问题，直到遇到基本情况，然后递归返回并解决整个问题。

递归算法通常用于解决需要重复执行相同操作的问题，例如计算斐波那契数列、计算阶乘、树和图的遍历等。

递归算法的主要特点是简洁、易理解，但在大规模问题上可能效率较低。

以下是一个使用递归算法计算斐波那契数列的示例代码：def fibonacci(n):if n <= 1:return nelse:return fibonacci(n-1) + fibonacci(n-2)2. 排序算法排序算法用于将一组数据按照一定顺序进行排列。

常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。

•冒泡排序逐渐交换相邻的元素，将较大的元素逐渐“冒泡”到最后的位置。

•选择排序每次选择最小（或最大）的元素，并将其放置在已排序部分的末尾。

•插入排序通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

•快速排序通过选择一个基准元素，将数组分割为左右两部分，对左右两部分分别递归地进行快速排序。

•归并排序将数组分成两个子数组，分别对两个子数组进行排序，然后将两个有序子数组合并为一个有序数组。

以下是一个使用快速排序算法对数组进行排序的示例代码：def quick_sort(arr):if len(arr) <= 1:return arrpivot = arr[len(arr)//2]left = [x for x in arr if x < pivot]middle = [x for x in arr if x == pivot]right = [x for x in arr if x > pivot]return quick_sort(left) + middle + quick_sort(right)3. 查找算法查找算法用于在数据集合中查找特定元素的位置或存在性。

数据结构源代码(全)

/*顺序表的操作#include<iostream>#include<stdlib.h>using namespace std;Release 13.12 rev 9501 (2013/12/25 19:25:45) gcc 4.7.1 Windows/unicode - 32 bit #define MAX_SIZE 100typedef struct{int *emel;int lenth;}Sq;void init(Sq &l);void create(Sq &l);void trval(Sq &l);void find_value(Sq &l);void find_position(Sq &l);void insert(Sq &l);void dele(Sq &l);int main(){Sq l;init(l);create(l);trval(l);find_value(l);find_position(l);insert(l);trval(l);dele(l);trval(l);return 0;}void init(Sq &l){l.emel =new int[MAX_SIZE];if(l.emel ==NULL){cout<<"\t申请空间失败！"<<endl;exit(1);}l.lenth=0;cout<<"\t成功申请空间！该顺序表的长度目前为:"<<l.lenth<<endl; }void create(Sq &l){cout<<"\t请输入你想输入元素的个数：";int x;cin>>x;if((x<1)&&(x>MAX_SIZE)){cout<<"\t你说输入的数不在范围里"<<endl;return;}int i;for(i=0;i<x;i++){cin>>l.emel[i];}l.lenth=x;cout<<"\t成功赋值！"<<endl;}void trval(Sq &l){int i;cout<<"l(";for(i=0;i<l.lenth;i++){cout<<l.emel[i]<<" ";}cout<<")"<<" 该顺序表现在的长度为："<<l.lenth<<endl;}void find_value(Sq &l){int x,t=0;cout<<"\t请输入你要查找的值：";cin>>x;int i;for(i=0;i<l.lenth;i++){if(l.emel[i]==x){t=1;cout<<"\t成功找到该元素，它是顺序表的第"<<i+1<<"个元素！"<<endl;}}if(t==0){cout<<"\t无该元素！"<<endl;}}void find_position(Sq &l){int x;cout<<"\t请输入你要查找的位置：";cin>>x;int i;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内！"<<endl;return;}for(i=1;i<=l.lenth;i++){if(i==x){cout<<"\t成功找到该元素，该值是"<<l.emel[i-1]<<endl;}}}void insert(Sq &l){int i,x,y;cout<<"\t请输入你要插入的位置";cin>>x;cout<<"\t请输入你要插入的值";cin>>y;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内！"<<endl;return;}if(x==l.lenth){l.emel[l.lenth]=y;l.lenth=l.lenth+1;return;}for(i=l.lenth;i>=x;i--){l.emel[i]=l.emel[i-1];}l.emel[x-1]=y;l.lenth=l.lenth+1;}void dele(Sq &l){int i,x;cout<<"\t请输入你要删除位置：";cin>>x;if((x<1)||(x>l.lenth)){cout<<"\t输入的值不在范围内！"<<endl;return;}for(i=x-1;i<=l.lenth;i++){l.emel[i]=l.emel[i+1];}l.lenth=l.lenth-1;}成功申请空间！该顺序表的长度目前为:0请输入你想输入元素的个数：3852成功赋值！l(8 5 2 ) 该顺序表现在的长度为：3请输入你要查找的值：5成功找到该元素，它是顺序表的第2个元素！请输入你要查找的位置：3成功找到该元素，该值是2请输入你要插入的位置3请输入你要插入的值10l(8 5 2 10 ) 该顺序表现在的长度为：4请输入你要删除位置：3l(8 5 10 ) 该顺序表现在的长度为：3--------------------------------Process exited with return value 0Press any key to continue . . .*//*#include<stdio.h>#include<stdlib.h>typedef struct Link{int num;struct Link *next;}L;L* creat(L* head){head=(L *)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败！\n");exit(-1);}head->next=NULL;return head;}void insert(L* head){int x,i;printf("请输入你想输入数据的个数：");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败！\n");exit(-1);}printf("请输入值：");scanf("%d",&q->num);q->next=NULL;p->next=q;p=q;}}void print(L* head){L *p;p=head->next;while(p!=NULL){printf("值为：%d\n",p->num);p=p->next;}}int main(){L *head;head=creat(head);printf("成功创建头节点！！！\n");insert(head);printf("成功输入数据！！！\n");print(head);return 0;}*//*线性表的操作#include<stdio.h>#include<stdlib.h>typedef struct Link{int num;struct Link *next;}L;L* creat(L* head){head=(L *)malloc(sizeof(L));if(head==NULL){printf("头节点申请失败！\n");exit(-1);}head->next=NULL;return head;}void init(L* head){int x,i;printf("请输入你想输入数据的个数：");scanf("%d",&x);L *p,*q;p=head;for(i=0;i<x;i++){q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败！\n");exit(-1);}printf("请输入值：");scanf("%d",&q->num);q->next=p->next;p->next=q;}}int print(L* head){L *p;int lenth=0;p=head->next;printf("\t\tL(");while(p!=NULL){lenth++;printf("%d ",p->num);p=p->next;}printf(")\n");return lenth;}int insert(L *head,int lenth){printf("\t\t请输入你要插入的元素的位置:");int in;scanf("%d",&in);if(in<1 || in>lenth){printf("\t\t输入值不在范围内！");return -1;}L *p,*q;p=head->next;q=(L *)malloc(sizeof(L));if(q==NULL){printf("新点申请失败！\n");return -1;}printf("\t\t请为新节点输入值：");scanf("%d",&q->num);int i=0;while(p!=NULL){i++;if(i==in-1){q->next=p->next;p->next=q;}p=p->next;}lenth++;return lenth;}int dele(L *head,int lenth){printf("\t\t请输入你要删除的元素的位置:");int out;scanf("%d",&out);if(out<1 || out>lenth){printf("\t\t输入值不在范围内！");return -1;}L *p,*q;p=head->next;q=head;int i=0;while(p!=NULL){i++;if(i==out){q->next=p->next;}q=p;p=p->next;}lenth--;return lenth;}void find(L *head,int lenth){printf("\t\t请输入你要查找的元素的位置:");int finder;scanf("%d",&finder);if(finder<1 || finder>lenth){printf("\t\t输入值不在范围内！");return ;}L *p;p=head->next;int i=0;while(p!=NULL){i++;if(i==finder){printf("\t\t你要找的该位置所对应的值为：%d\n",p->num);}p=p->next;}}int main(){L *head;head=creat(head);printf("成功创建头节点！！！\n");init(head);printf("成功输入数据！！！\n");int len;len=print(head);printf("\t\t该线性表的长度为:%d\n",len);len=insert(head,len);len=print(head);printf("\t\t插入后线性表的长度为:%d\n",len);len=dele(head,len);len=print(head);printf("\t\t删除后该线性表的长度为:%d\n",len);find(head,len);return 0;}*//*顺序表的合并#include<iostream>using namespace std;struct LA{int *pa;int lenth;};struct LB{int *pb;int lenth;};struct LC{int *pc;int lenth;};void mergelist(LA la,LB lb,LC &lc);int main(){int x,y;LA la;LB lb;cout<<"\t\t请给线性表LA和LB指定长度：";cin>>x>>y;la.pa =new int(sizeof(int)*x);lb.pb =new int(sizeof(int)*y);int i;for(i=0;i<x;i++){cout<<"请输入表LA的值:";cin>>la.pa[i];}cout<<endl;la.lenth=x;for(i=0;i<y;i++){cout<<"请输入表LB的值:";cin>>lb.pb[i];}lb.lenth=y;cout<<"LA(";for(i=0;i<x;i++){cout<<la.pa[i]<<" ";}cout<<")"<<endl;cout<<"LB(";for(i=0;i<y;i++){cout<<lb.pb[i]<<" ";}cout<<")"<<endl;LC lc;mergelist(la,lb,lc);return 0;}void mergelist(LA la,LB lb,LC &lc){lc.lenth=la.lenth+lb.lenth;lc.pc=new int(sizeof(int)*lc.lenth);int *pa=la.pa,*pb=lb.pb,*pc=lc.pc;int *pa_last=la.pa+la.lenth-1;int *pb_last=lb.pb+lb.lenth-1;while(pa<=pa_last && pb<=pb_last){if(*pa <= *pb){*pc++=*pa++;}else{*pc++=*pb++;}}while(pa<=pa_last){*pc++=*pa++;}while(pb<=pb_last){*pc++=*pb++;}cout<<"LC(";int i=0;for(i=0;i<lc.lenth;i++){cout<<lc.pc[i]<<" ";}cout<<")"<<endl;}*///栈/*#include<iostream>using namespace std;#include<stdlib.h>#define MAXSIZE 100typedef struct{int *base;int *top;int stacksize;}Sqstack;int Initstack(Sqstack &s);void Push(Sqstack &s,int e);void StackTraverse(Sqstack &s);void Gettop(Sqstack &s);void Pop(Sqstack &s);int main(){Sqstack s;Initstack(s);cout<<"\t\t初始化栈成功！"<<endl;Push(s,2);cout<<"\t\t2入栈成功！"<<endl;Push(s,4);cout<<"\t\t4入栈成功！"<<endl;Push(s,6);cout<<"\t\t6入栈成功！"<<endl;Push(s,8);cout<<"\t\t8入栈成功！"<<endl;cout<<"\n由栈底至栈顶的元素为：";StackTraverse(s);Gettop(s);Pop(s);Gettop(s);return 0;}int Initstack(Sqstack &s){s.base=new int[MAXSIZE];if(s.base==NULL){exit(1);}s.top=s.base;s.stacksize=MAXSIZE;}void Push(Sqstack &s,int e){if(s.top-s.base==s.stacksize){exit(1);}*s.top++=e;}void StackTraverse(Sqstack &s){int *p=s.base,i=0;while(p<s.top){i++;cout<<*p++<<" ";}cout<<"\t\t栈的长度是"<<i<<endl;}void Gettop(Sqstack &s){if(s.base==s.top){exit(1);}cout<<"栈顶元素是："<<*(s.top-1)<<endl; }void Pop(Sqstack &s){if(s.top==s.base){exit(1);}cout<<"出栈的第一个元素是:";cout<<*--s.top<<" "<<endl;}*///队列例题：/*#include<iostream>#include<stdlib.h>using namespace std;#define MAXQSIZE 100typedef struct{int *base;int front;int rear;}SqQueue;int InitQueue(SqQueue &q);int EnQueue(SqQueue &q,int x);int DeQueue(SqQueue &q);int main(){SqQueue q;InitQueue(q);EnQueue(q,1);EnQueue(q,3);EnQueue(q,5);EnQueue(q,7);DeQueue(q);DeQueue(q);DeQueue(q);DeQueue(q);return 0;}int InitQueue(SqQueue &q){q.base=new int[MAXQSIZE];if(q.base==NULL){exit(1);}q.front=0;q.rear=0;return 0;}int EnQueue(SqQueue &q,int x){if((q.rear+1)%MAXQSIZE==q.front){exit(0);}q.base[q.rear]=x;q.rear=(q.rear+1)%MAXQSIZE;return 0;}int DeQueue(SqQueue &q){if(q.front==q.rear){exit(0);}int x=q.base[q.front];q.front=(q.front+1)%MAXQSIZE;cout<<x<<endl;}*//*#include<iostream>#include<stdlib.h>using namespace std;typedef struct Qnode{int date;struct Qnode *next;}Qnode,*Queueptr;typedef struct{Queueptr front; //队头指针Queueptr rear; //队尾指针}LinkQueue;int InitQueue(LinkQueue &Q);void EnQueue(LinkQueue &Q,int e);void TrvalQueue(LinkQueue Q);void DeQueue(LinkQueue &Q);int main(){LinkQueue Q;InitQueue(Q);EnQueue(Q,1);cout<<"\t元素1入队成功！"<<endl;EnQueue(Q,3);cout<<"\t元素3入队成功！"<<endl;EnQueue(Q,5);cout<<"\t元素5入队成功！"<<endl;EnQueue(Q,7);cout<<"\t元素7入队成功！"<<endl;cout<<"\t队列的元素分别是："<<endl;TrvalQueue(Q);cout<<"\t第一个出队的元素是："<<endl;DeQueue(Q);cout<<"\n\t第一个元素出队完成之后队列中从队头至队尾的元素为：";TrvalQueue(Q);return 0;}int InitQueue(LinkQueue &Q){Q.rear=new Qnode;Q.front=Q.rear;if(Q.front==NULL){exit(0);}Q.front->next=NULL;return 0;}void EnQueue(LinkQueue &Q,int e){Qnode *p=new Qnode;if(!p){exit(1);}p->date=e;p->next=NULL;Q.rear->next=p; //连接Q.rear=p; //修改队尾指针}void TrvalQueue(LinkQueue Q){Qnode *p=Q.front->next;//队头元素while(Q.front!=Q.rear){cout <<p->date<<" ";Q.front=p;p=p->next;}cout<<endl;}void DeQueue(LinkQueue &Q){if(Q.front==Q.rear){return;}Qnode *p=Q.front->next;cout<<"\t"<<p->date<<endl;Q.front->next=p->next;if(Q.rear==p){Q.rear=Q.front;delete p;}}*//*//表达式求值#include<iostream>#include<stdlib.h>#include<stdio.h>using namespace std;#define MAXSIZE 100typedef struct{char *base;char *top;char num;}OPND; //数据栈typedef struct{char *base;char *top;char c;}OPTR; //符号栈int Initstack(OPND &op_n,OPTR &op_t);void Pushstack(OPND &op_n,char ch);void Pushstack(OPTR &op_t,char ch);char Popstack(OPND &op_n,char ch);char Popstack(OPTR &op_t,char ch);char Gettop(OPTR op_t);char Gettop(OPND op_n);int In(char ch);char Precede(char x,char y);char operate(char z,char x,char y);int main(){OPND op_n;OPTR op_t;Initstack(op_n,op_t);Pushstack(op_t,'#');char ch;char p;cin>>ch;while(ch!='#' || Gettop(op_t)!='#'){if(!In(ch)){Pushstack(op_n,ch);cin>>ch;}else{switch( Precede(Gettop(op_t),ch) ){case '<':Pushstack(op_t,ch);cin>>ch;break;case '>':char x,y,z;x=Popstack(op_t,x);y=Popstack(op_n,y);z=Popstack(op_n,z);Pushstack(op_n,operate(z,x,y));break;case '=':p=Popstack(op_t,p);cin>>ch;break;}}}cout<<"\t表达式结果是："<<Gettop(op_n)<<endl;return 0;}int Initstack(OPND &op_n,OPTR &op_t){op_n.base=new char[MAXSIZE];op_t.base=new char[MAXSIZE];if((op_n.base==NULL) || (op_t.base==NULL)){exit(1);}op_n.top=op_n.base;op_t.top=op_t.base;op_n.num=MAXSIZE;op_t.c=MAXSIZE;return 0;}void Pushstack(OPND &op_n,char ch){if(op_n.top-op_n.base==op_n.num){return;}*op_n.top++=ch;cout<<ch<<" 入数字栈"<<endl;}void Pushstack(OPTR &op_t,char ch){if(op_t.top-op_t.base==op_t.c){return;}*op_t.top++=ch;cout<<ch<<" 入操作符"<<endl;}char Popstack(OPND &op_n,char ch)if(op_n.top==op_n.base){exit(1);}ch=*--op_n.top;cout<<ch<<" 出数字栈"<<endl;return ch;}char Popstack(OPTR &op_t,char ch){if(op_t.top==op_t.base){exit(1);}ch=*--op_t.top;cout<<ch<<" 出字符栈"<<endl;return ch;}char Gettop(OPTR op_t){char x;if(op_t.top==op_t.base){exit(1);}x=*(op_t.top-1);cout<<"得到操作符栈顶"<<x<<endl;return x;}char Gettop(OPND op_n){char x;if(op_n.top==op_n.base){exit(1);}x=*(op_n.top-1);cout<<"得到操作数栈顶"<<x<<endl;return x;}int In(char ch)if(ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='('||ch==')'||ch=='#') {return 1;}else{return 0;}}char Precede(char x,char y){if(x=='+' || x=='-'){if(y=='+' || y=='-' || y==')' || y=='#'){return '>';}else{return '<';}}if(x=='*'||x=='/'){if(y=='('){return '<';}else{return '>';}}if(x=='('){if(y==')'){return '=';}else if(y=='+'||y=='-'||y=='*'||y=='/'||y=='('){return '<';}}if(x==')'){if(y!='('){return '>';}}if(x=='#'){if(y=='#'){return '=';}else if(y!=')'){return '<';}}}char operate(char z,char x,char y) {if(x=='+'){return (z-'0') + (y-'0')+48;}if(x=='-'){return (z-'0') - (y-'0')+48;}if(x=='*'){return (z-'0')* (y-'0')+48;}if(x=='/'){return (z-'0')/ (y-'0')+48;}}*//*#include<iostream>using namespace std;int main(){char a[10];char *b[10];char **c[10];return 0;}*//*#include<iostream>using namespace std;char f(char x,char y){return (x-'0') * (y-'0')+48;}int main(){char a='3',b='5';char p=f(a,b);cout<<p<<endl;return 0;}*///数列出队/*#include<iostream>#include<stdlib.h>using namespace std;typedef struct Qnode{int num;struct Qnode *next;}Qnode,*Queueptr;typedef struct{Queueptr front;Queueptr rear;}LinkQueue;int InitQueue(LinkQueue &Q);void EnQueue(LinkQueue &Q,int x); int DeQueue(LinkQueue &Q,int p); int main(){LinkQueue Q;InitQueue(Q);int x,i,y,num=0,e;cout<<"请输入总人数:";cin>>x;for(i=1;i<=x;i++){EnQueue(Q,i);}cout<<"请输入第几个数淘汰:";cin>>y;{for(i=0;i<y;i++){if(i!=y-1){e=DeQueue(Q,e);EnQueue(Q,e);}else{DeQueue(Q,e);num++;}}if(num==x-1){break;}}e=DeQueue(Q,e);cout<<"最后剩下的是："<<e<<endl;return 0;}int InitQueue(LinkQueue &Q){Q.front=new Qnode;Q.rear=Q.front;if(Q.front==NULL){exit(1);}Q.front->next=NULL;}void EnQueue(LinkQueue &Q,int x){Qnode *p=new Qnode;if(!p){exit(1);}p->num=x;p->next=NULL;Q.rear->next=p;}int DeQueue(LinkQueue &Q,int e) {Qnode *p;if(Q.rear==Q.front){exit(0);}p=Q.front->next;e=p->num;Q.front->next=p->next;if(Q.rear==p){Q.front=Q.rear;}delete p;return e;}*//*二叉树#include<iostream>#include<stdlib.h>using namespace std;typedef struct BiTNode{char date;struct BiTNode *lchild,*rchild; }BiTNode,*BiTree;void CreateBiTree(BiTree &T);int Depth(BiTree T);int NodeCount(BiTree T);int LeavesNodeCount(BiTree T);int PreOrderTraverse(BiTree T);int InOrderTraverse(BiTree T);int PostOrderTraverse(BiTree T); int main(){BiTree T;CreateBiTree(T);cout<<"二叉树的深度为："<<Depth(T)<<endl;cout<<"二叉树中结点个数为："<<NodeCount(T)<<endl;cout<<"二叉树中叶子结点个数为："<<LeavesNodeCount(T)<<endl;cout<<"先序遍历：";PreOrderTraverse(T);cout<<"\n中序遍历：";InOrderTraverse(T);cout<<"\n后序遍历：";PostOrderTraverse(T);cout<<endl;return 0;}void CreateBiTree(BiTree &T){cout<<"请为该节点赋值:";char ch;cin>>ch;if(ch=='#'){T=NULL;}else{T =new BiTNode;T->date=ch;CreateBiTree(T->lchild);CreateBiTree(T->rchild);}}int Depth(BiTree T){int m,n;if(T==NULL){return 0;}else{m=Depth(T->lchild);n=Depth(T->rchild);if(m>n){return m+1;}else{return n+1;}}}int NodeCount(BiTree T){if(T==NULL){return 0;}else{return NodeCount(T->lchild)+NodeCount(T->rchild)+1;}}int LeavesNodeCount(BiTree T){if(T==NULL){return 0;}else if(T->lchild==NULL && T->rchild==NULL){return 1;}else{return LeavesNodeCount(T->lchild)+LeavesNodeCount(T->rchild);}}int PreOrderTraverse(BiTree T){if(T!=NULL){cout<<T->date;PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}int InOrderTraverse(BiTree T){if(T!=NULL){InOrderTraverse(T->lchild);cout<<T->date;InOrderTraverse(T->rchild);}}int PostOrderTraverse(BiTree T){if(T!=NULL){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);cout<<T->date;}}请为该节点赋值:-请为该节点赋值:+请为该节点赋值:a请为该节点赋值:#请为该节点赋值:#请为该节点赋值:*请为该节点赋值:b请为该节点赋值:#请为该节点赋值:#请为该节点赋值:-请为该节点赋值:c请为该节点赋值:#请为该节点赋值:#请为该节点赋值:d请为该节点赋值:#请为该节点赋值:#请为该节点赋值:/请为该节点赋值:e请为该节点赋值:#请为该节点赋值:#请为该节点赋值:f请为该节点赋值:#请为该节点赋值:#二叉树的深度为：5二叉树中结点个数为：11二叉树中叶子结点个数为：6先序遍历：-+a*b-cd/ef中序遍历：a+b*c-d-e/f后序遍历：abcd-*+ef/-Process returned 0 (0x0) execution time : 76.214 s Press any key to continue.*//*#include<iostream>#include<stdlib.h>#include<string.h>using namespace std;typedef struct{int weiget;int parent,lchild,rchild;}HTNode,*HuffmanTree;typedef char** HuffmanCode;void creat(HuffmanTree &HT,int n);void Select(HuffmanTree HT,int k,int &min1,int &min2); void creatcode(HuffmanTree HT,HuffmanCode &HC,int n); int min(HuffmanTree HT,int k);int main(){int n;cout<<"请输入叶子节点的个数:";cin>>n;HuffmanTree HT;creat(HT,n);HuffmanCode HC;creatcode(HT,HC,n);return 0;}void creat(HuffmanTree &HT,int n){if(n<1){exit(1);}int m=2*n-1,i;HT=new HTNode[m+1];for( i=1;i<=m;i++){HT[i].parent=0;HT[i].lchild=0;HT[i].rchild=0;}for(i=1;i<=n;i++){cout<<"请输入权值:";cin>>HT[i].weiget;}int s1,s2;for(i=n+1;i<=m;i++) //通过n-1次选择来合并创建{Select(HT,i-1,s1,s2);HT[s1].parent=i; //赋值，作为删除的标记HT[s2].parent=i;cout<<"s1:"<<s1<<" s2:"<<s2<<endl;HT[i].lchild=s1; //生成新节点HT[i].rchild=s2;HT[i].weiget=HT[s1].weiget+HT[s2].weiget;}}void Select(HuffmanTree HT,int k,int &min1,int &min2){min1=min(HT,k);min2=min(HT,k);}int min(HuffmanTree HT,int k){int i=0;int min;//存放weight最小且parent为-1的元素的序号int min_wei;//存放权值while(HT[i].parent!=0){i++;}min_wei=HT[i].weiget;min=i;for(;i<=k;i++){if(HT[i].weiget<min_wei && HT[i].parent==0){min_wei=HT[i].weiget;min=i;}}HT[min].parent=1;return min;}void creatcode(HuffmanTree HT,HuffmanCode &HC,int n){HC =new char *[n+1];char *cd=new char[n];cd[n-1]='\0';int i,start;//start指向最后，即编码结束符的位置int current,father;for(i=1;i<=n;i++){start=n-1;current=i;father=HT[i].parent;while(father!=0){--start;if(HT[father].lchild==current){cd[start]='0';}else{cd[start]='1';}current=father;father=HT[father].parent;}HC[i]=new char[n-start];strcpy(HC[i],&cd[start]);cout<<HT[i].weiget<<"对应的编码是："<<HC[i]<<endl;}delete cd;}请输入叶子节点的个数:5请输入权值:1请输入权值:2请输入权值:3请输入权值:4请输入权值:5s1:1 s2:2s1:3 s2:6s1:4 s2:5s1:7 s2:81对应的编码是：0102对应的编码是：0113对应的编码是：004对应的编码是：105对应的编码是：11Process returned 0 (0x0) execution time : 4.003 s Press any key to continue.*///折半查找#include<iostream>#include<stdio.h>using namespace std;#define ENDFLAG 10000typedef int KeyType;typedef char* InfoType;typedef struct{KeyType key;InfoType otherinfo;}ElemType;typedef struct{ElemType *R;int length;}SSTable;void CreateSTable(SSTable &ST,int n){int i;ST.R=new ElemType[n+1];for(i=1;i<=n;i++){cout<<"请输入"<<i<<"个测试数据：";cin>>ST.R[i].key;}ST.length=n;}int Search_Bin1(SSTable ST,KeyType key){int low,high,mid;low=1;high=ST.length;while(low<=high){mid=(low+high)/2;if(key==ST.R[mid].key){return mid;}else if(key<ST.R[mid].key){high=mid-1;}else{low=mid+1;}}return 0;}int Search_Bin2(SSTable ST,int low,int high,KeyType key) {int mid;if(low>high){return 0;}mid=(low+high)/2;printf("%d+++++",key==ST.R[mid].key);if(key==ST.R[mid].key){return mid;}else if(key<ST.R[mid].key){return Search_Bin2(ST,low,mid-1,key);}else{return Search_Bin2(ST,mid+1,high,key);}}int main(){int n;KeyType key;SSTable ST;cout<<"请输入静态查找表长：";cin>>n;CreateSTable(ST,n);cout<<"请输入待查记录的关键字：";cin>>key;cout<<"Search_Bin1算法计算的位置为："<<Search_Bin1(ST,key)<<endl;cout<<"Search_Bin2算法计算的位置为："<<Search_Bin2(ST,1,ST.length,key)<<endl;return 0;}/*请输入静态查找表长：5请输入1个测试数据：1请输入2个测试数据：2请输入3个测试数据：3请输入4个测试数据：4请输入5个测试数据：5请输入待查记录的关键字：3Search_Bin1算法计算的位置为：3Search_Bin2算法计算的位置为：3Process returned 0 (0x0) execution time : 8.620 sPress any key to continue.*//*#include<iostream>using namespace std;typedef struct{int key;}ElemType;typedef struct BSTNode{ElemType date;struct BSTNode *lchild,*rchild;}BSTNode,*BSTree;void Create(BSTree &T);void Insert(BSTree &T,ElemType e);int InOrderTraverse(BSTree T);int main(){BSTree T;Create(T);InOrderTraverse(T);cout<<"\n中序遍历：";return 0;}void Create(BSTree &T){T=NULL;ElemType e;cout<<"请为节点赋值:(0为结束条件)";cin>>e.key;while(e.key!=0){Insert(T,e);cout<<"请为节点赋值:(0为结束条件)";cin>>e.key;}}void Insert(BSTree &T,ElemType e){if(!T){BSTree S;S=new BSTNode;S->date=e;S->lchild=NULL;S->rchild=NULL;T=S;}else if(e.key<T->date.key){Insert(T->lchild,e);}else{Insert(T->rchild,e);}}int InOrderTraverse(BSTree T){if(T!=NULL){InOrderTraverse(T->lchild);cout<<T->date.key<<" ";InOrderTraverse(T->rchild);}return 0;}请为节点赋值:(0为结束条件)12请为节点赋值:(0为结束条件)7请为节点赋值:(0为结束条件)17请为节点赋值:(0为结束条件)11请为节点赋值:(0为结束条件)16请为节点赋值:(0为结束条件)2请为节点赋值:(0为结束条件)13请为节点赋值:(0为结束条件)9请为节点赋值:(0为结束条件)21请为节点赋值:(0为结束条件)4请为节点赋值:(0为结束条件)02 4 7 9 11 12 13 16 17 21中序遍历：Process returned 0 (0x0) execution time : 23.808 s Press any key to continue.*/。

C语言经典算法大全

C语言经典算法大全1. 冒泡排序（Bubble Sort）：比较相邻的元素，如果顺序错误就交换位置，直到整个序列有序。

2. 快速排序（Quick Sort）：选择一个中间元素作为基准，将序列分成两部分，左边的元素都小于等于基准，右边的元素都大于等于基准，然后递归地对两个子序列进行排序。

3. 插入排序（Insertion Sort）：将元素逐个插入到已经排序的序列中，直到整个序列有序。

4. 选择排序（Selection Sort）：每次选择一个最小（或最大）的元素放到有序序列的末尾（或开头），直到整个序列有序。

5. 归并排序（Merge Sort）：将序列分成若干个子序列，对每个子序列进行排序，然后再将已排好序的子序列合并成一个有序序列。

6. 希尔排序（Shell Sort）：将序列划分成若干个小的子序列分别进行直接插入排序，然后逐渐减小子序列的间隔直到整个序列有序。

7. 堆排序（Heap Sort）：利用堆这种数据结构进行排序，构建一个大（或小）根堆，依次将根节点（最大或最小值）和最后一个节点交换位置，然后重新调整堆。

8. 计数排序（Counting Sort）：统计每个元素的出现次数，然后根据统计结果，将元素按照顺序放入相应位置，从而实现排序。

9. 桶排序（Bucket Sort）：将元素分到不同的桶中，桶内元素进行排序，然后按照桶的顺序将元素取出，从而实现排序。

10.基数排序（Radix Sort）：根据元素的位数进行排序，首先排个位，然后排十位，以此类推，直到排完最高位。

除了上述排序算法之外，C语言中还有许多其他经典算法，例如二分查找、递归、深度优先、广度优先、贪心算法、动态规划等等。

这些算法都有各自的特点和应用场景，对于提高编程水平和解决实际问题都有很大的帮助。

总结起来，掌握C语言的经典算法对于编程爱好者来说是非常重要的。

它们可以帮助我们更好地理解计算机科学的基本原理和数据结构，提高我们编写程序的能力和效率。

(完整版)数据结构经典题目及c语言代码

《数据结构》课程设计题目(程序实现采用C语言)题目1：猴子选王(学时:3）一堆猴子都有编号，编号是1，2,3 .。

.m，这群猴子（m个)按照1-m的顺序围坐一圈，从第1开始数，每数到第n个,该猴子就要离开此圈，这样依次下来，直到圈中只剩下最后一只猴子，则该猴子为大王.要求:m及n要求从键盘输入,存储方式采用向量及链表两种方式实现该问题求解.//链表#include 〈stdio.h〉＃include 〈stdlib.h>// 链表节点typedef struct _RingNode｛int pos；struct _RingNode ＊next;}RingNode， *RingNodePtr；// 创建约瑟夫环，pHead:链表头指针,count：链表元素个数void CreateRing(RingNodePtr pHead, int count)｛RingNodePtr pCurr = NULL， pPrev = NULL；int i = 1;pPrev = pHead；while（——count 〉 0）｛pCurr = (RingNodePtr）malloc（sizeof（RingNode））;i++;pCurr—〉pos = i；pPrev-〉next = pCurr；pPrev = pCurr;}pCurr-〉next = pHead; // 构成环状链表｝void KickFromRing(RingNodePtr pHead， int n){RingNodePtr pCurr, pPrev；int i = 1； // 计数pCurr = pPrev = pHead；while(pCurr != NULL){if （i == n）｛// 踢出环printf（"\n％d"， pCurr->pos); // 显示出圈循序pPrev—>next = pCurr->next；free（pCurr)；pCurr = pPrev—>next；i = 1;}pPrev = pCurr；pCurr = pCurr—〉next;if （pPrev == pCurr)｛// 最后一个printf("\nKing is %d", pCurr—〉pos）; // 显示出圈循序 free（pCurr)；break；}i++;｝}int main（）｛int n = 0, m = 0；RingNodePtr pHead = NULL;printf("M（person count）= ”）;scanf(”％d”, &m);printf("N（out number) = "）;scanf(”％d”， &n）;if(m 〈= 0 |｜ n <= 0）｛printf("Input Error\n”)；return 0;}// 建立链表pHead = (RingNodePtr)malloc（sizeof（RingNode））； pHead->pos = 1;pHead->next = NULL;CreateRing(pHead， m);// 开始出圈printf("\nKick Order： ")；KickFromRing(pHead， n）；printf(”\n"）;system(”pause”）；return 0；}//数组做：#include<stdio。

数据结构必看算法

数据结构算法背诵一、线性表1. 逆转顺序表中的所有元素算法思想：第一个元素和最后一个元素对调，第二个元素和倒数第二个元素对调，……，依此类推。

void Reverse(int A[], int n){int i, t;for (i=0; i < n/2; i++){t = A[i];A[i] = A[n-i-1];A[n-i-1] = t;}}2. 删除线性链表中数据域为item 的所有结点算法思想：先从链表的第2 个结点开始，从前往后依次判断链表中的所有结点是否满足条件，若某个结点的数据域为item，则删除该结点。

最后再回过头来判断链表中的第1 个结点是否满足条件，若满足则将其删除。

void PurgeItem(LinkList &list){LinkList p, q = list;p = list->next;while (p != NULL){if (p->data == item) {q->next = p->next;free(p);p = q->next;} else {q = p;p = p->next;}}if (list->data == item){q = list;list = list->next;free(q);}}3. 逆转线性链表void Reverse(LinkList &list){LinkList p, q, r;p = list;q = NULL;while (p != NULL){r = q;q = p;p = p->next;q->next = r;}list = q;}4. 复制线性链表（递归）LinkList Copy(LinkList lista){LinkList listb;if (lista == NULL)return NULL;else {listb = (LinkList)malloc(sizeof(LNode));listb->data = lista->data;listb->next = Copy(lista->next);return listb;}}5. 将两个按值有序排列的非空线性链表合并为一个按值有序的线性链表LinkList MergeList(LinkList lista, LinkList listb){LinkList listc, p = lista, q = listb, r;// listc 指向lista 和listb 所指结点中较小者if (lista->data <= listb->data) {listc = lista;r = lista;p = lista->next;} else {listc = listb;r = listb;q = listb->next;}while (p != NULL && q != NULL)if (p->data <= q->data) {r->next = p;r = p;p = p->next;} else {r->next = q;r = q;q = q->next;}}// 将剩余结点（即未参加比较的且已按升序排列的结点）链接到整个链表后面r->next = (p != NULL) ? p : q;return listc;}3二、树1. 二叉树的先序遍历（非递归算法）算法思想：若p 所指结点不为空，则访问该结点，然后将该结点的地址入栈，然后再将p 指向其左孩子结点；若p 所指向的结点为空，则从堆栈中退出栈顶元素（某个结点的地址），将p 指向其右孩子结点。

C数据结构实例代码

C数据结构实例代码C语言是一种通用的高级程序设计语言，也是实现数据结构的一种常用语言。

下面是一些常见的数据结构的示例代码，供参考。

1. 数组（Array）```c#include <stdio.h>int maiint arr[5] = {1, 2, 3, 4, 5}; // 创建一个有5个元素的整数数组for(int i=0; i<5; i++)printf("%d ", arr[i]); // 遍历并输出数组的所有元素}return 0;```2. 链表（Linked List）```c#include <stdio.h>#include <stdlib.h>struct Nodeint data;struct Node* next;};void printList(struct Node* head)struct Node* curr = head;while(curr != NULL)printf("%d ", curr->data);curr = curr->next;}void insert(struct Node** head, int data)struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;newNode->next = (*head);(*head) = newNode;int maistruct Node* head = NULL;insert(&head, 5);insert(&head, 4);insert(&head, 3);insert(&head, 2);insert(&head, 1);printList(head); // 输出链表的所有元素return 0;```3. 栈（Stack）```c#include <stdio.h>#define SIZE 5int stack[SIZE];int top = -1;int isEmptreturn top == -1;int isFulreturn top == SIZE - 1;void push(int item)if(isFull()printf("Stack is full.\n");} elsestack[++top] = item;printf("Pushed %d\n", item);}void poif(isEmpty()printf("Stack is empty.\n");} elseprintf("Popped %d\n", stack[top--]); }int maipush(1);push(2);push(3);pop(;push(4);push(5);push(6);pop(;return 0;```4. 队列（Queue）```c#include <stdio.h>#define SIZE 5int queue[SIZE];int front = -1; // 队头指针int rear = -1; // 队尾指针int isEmptreturn front == -1 && rear == -1; int isFulreturn rear == SIZE - 1;void enqueue(int item)if(isFull()printf("Queue is full.\n");} elseif(isEmpty()front = rear = 0;} elserear++;}queue[rear] = item;printf("Enqueued %d\n", item);}void dequeuif(isEmpty()printf("Queue is empty.\n");} elseprintf("Dequeued %d\n", queue[front]); if(front == rear)front = rear = -1;} elsefront++;}}int maienqueue(1);enqueue(2);enqueue(3);dequeue(;enqueue(4);enqueue(5);enqueue(6);dequeue(;return 0;```5. 树（Tree）```c#include <stdio.h>#include <stdlib.h>struct Nodeint data;struct Node* left;struct Node* right;};struct Node* create(int data)struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;newNode->left = NULL;newNode->right = NULL;return newNode;void inorder(struct Node* root)if(root != NULL)inorder(root->left);printf("%d ", root->data);inorder(root->right);}int maistruct Node* root = create(1);root->left = create(2);root->right = create(3);root->left->left = create(4);root->left->right = create(5);root->right->left = create(6);root->right->right = create(7);printf("Inorder traversal of the tree: "); inorder(root); // 中序遍历树return 0;```。

C语言中的数据结构与算法实现

C语言中的数据结构与算法实现在计算机科学中，数据结构和算法是构建程序的基础。

C语言作为一种强大而广泛使用的编程语言，提供了丰富的库函数和语法特性来支持数据结构和算法的实现。

本文将讨论C语言中常见的数据结构和算法，并通过示例代码来展示其实现方法。

一、线性数据结构1. 数组(Array)数组是C语言中最基本的数据结构之一，能够存储相同类型的数据元素。

通过索引，可以快速访问数组中的任意元素。

以下是一个简单的数组示例：```c#include <stdio.h>int main() {int arr[5] = {1, 2, 3, 4, 5};for(int i=0; i<5; i++) {printf("%d ", arr[i]);}return 0;}```2. 链表(Linked List)链表是一种动态数据结构，由节点组成，并通过指针相互连接。

链表具有灵活性，能够高效地插入和删除节点。

以下是一个简单的链表示例：```c#include <stdio.h>#include <stdlib.h>typedef struct Node {int data;struct Node* next;} Node;int main() {Node* head = NULL;Node* second = NULL;Node* third = NULL;// 分配内存并赋值head = (Node*)malloc(sizeof(Node));second = (Node*)malloc(sizeof(Node));third = (Node*)malloc(sizeof(Node)); head->data = 1;head->next = second;second->data = 2;second->next = third;third->data = 3;third->next = NULL;// 遍历链表Node* ptr = head;while (ptr != NULL) {printf("%d ", ptr->data);ptr = ptr->next;}return 0;}```二、非线性数据结构1. 栈(Stack)栈是一种后进先出（LIFO）的数据结构，只允许在栈的顶部进行插入和删除操作。

C语言经典算法C语言代码大全

C语言经典算法C语言代码大全一、排序算法1、冒泡排序它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。

设数组为a[0…n-1]C语言实现如下：//冒泡排序void bubbleSort(int arr[], int n)int i, j, temp;bool flag;//表示n次排序过程for(i = 0; i < n - 1; i++)//每次排序将最大的数放到最右边flag = false;for(j= 0; j< n-1-i; j++)if(arr[j] > arr[j+1])temp = arr[j];arr[j] = arr[j+1];arr[j+1] = temp;flag = true;}}//如果趟排序没有进行数据交换，说明数据已经有序if (flag == false)break;}}2、快速排序它采用了分治法的思想，基于快速排序的思想，可以对数组进行非常快速的排序。

设数组为a[0…n-1]C语言实现如下：//快速排序// arr[left] 为起始值，arr[right] 为末尾值void quickSort(int arr[], int left, int right)int i, j, base;if (left > right)return;}i = left;j = right;base = arr[left];//定义基准值，可以是数组的第一个值while (i != j)// 因为基准值是 arr[left],所以左边右移，直到找到小于基准值的值while (arr[j] >= base && i < j)j--;}// 因为基准值是 arr[left],所以右边左移while (arr[i] <= base && i < j)i++;}//如果i<j，表示找到了，交换位置if (i < j)int temp = arr[i];arr[i] = arr[j];arr[j] = temp;}}//将基准值放到i位置arr[left] = arr[i];。

数据结构代码汇总

数据结构代码汇总数据结构代码汇总一、线性结构1.数组（Array）：●定义和初始化数组●插入、删除元素●查找元素●数组的遍历●数组排序算法（如冒泡排序、快速排序）2.链表（Linked List）：●单链表的定义和初始化●插入、删除节点●链表的遍历●双向链表的定义和初始化●插入、删除节点●双向链表的遍历●栈的定义和初始化●入栈、出栈操作●获取栈顶元素、判断栈是否为空●栈的应用（如括号匹配、逆波兰表达式求值）4.队列（Queue）：●队列的定义和初始化●入队、出队操作●获取队头元素、判断队列是否为空●队列的应用（如循环队列、优先级队列）二、非线性结构1.树（Tree）：●二叉树的定义和初始化●二叉树的遍历（前序、中序、后序）●二叉搜索树的实现和应用●平衡二叉树（AVL树）的实现和应用●哈夫曼树的实现和应用●图的存储结构（邻接矩阵、邻接表）●深度优先搜索（DFS）●广度优先搜索（BFS）●最小树算法（如Prim算法、Kruskal算法）●最短路径算法（如Dijkstra算法、Floyd算法）附件：本文档中所涉及的代码示例可以在附件中找到，包括各种数据结构的实现和相关算法。

法律名词及注释：1.数组：计算机科学中的一种数据结构，用于存储一系列相同类型的元素。

2.链表：一种动态数据结构，由一系列节点组成，每个节点包含一个数据元素和指向下一个节点的指针。

3.栈：一种特殊的线性数据结构，遵循先进后出（Last In First Out，LIFO）的原则。

4.队列：一种特殊的线性数据结构，遵循先进先出（First In First Out，FIFO）的原则。

5.二叉树：一种特殊的树形结构，每个节点最多有两个子节点。

6.图：由节点（顶点）和连接节点的边构成的数据结构，用于描述事物之间的关系。