m0_51955470的博客

跳跃表(跳表)简介有序集合在生活中比较常见，例如根据成绩对学生排名，根据得分对玩家排名等。对于有序集合的底层实现，可以用数组、平衡树、链表等。数组不便元素的插入、删除；平衡树或红黑树虽然效率高但结构复杂；链表查询需要遍历所有效率低。Redis采用的是跳跃表。跳跃表效率堪比红黑树，实现远比红黑树简单。实例...

数据：是客观事物的符号表示，指所有能输入到计算机中并被计算机程序处理的符号的总称。如数学计算中用到的整数和实数，文本编辑所用到的字符串，多媒体程序处理的图形、图像、声音、动画等通过特殊编码定义后的数据。数据元素：是数据的基本单位，在计算机中通常作为一个整体进行考虑和处理。在有些情况下，数据元素也称为元素、结点、记录等。数据元素用于完整地描述一个对象，如一个学生记录，树中棋盘的一个格局（状态）、图中的一个顶点等。数据项：是组成数据元素的、有独立含义的、不可分割的最小单位。例如，学生基本信息表中的学号

代码如下:#include<iostream>using namespace std;void Bubble_Sort(int *a, int n){ bool flag; int tmp = 0; for (int i = n - 1; i >= 0; i--) { flag = false; for (int j = 0; j < i; j++) { if (a[j] > a[j + 1]) { swap(a[j], a[j

代码如下:void Swap( ElementType *a, ElementType *b ){ ElementType t = *a; *a = *b; *b = t;} void PercDown( ElementType A[], int p, int N ){ /* 改编代码4.24的PercDown( MaxHeap H, int p ) */ /* 将N个元素的数组中以A[p]为根的子堆调整为最大堆 */ int Parent, Child; E

树、二叉树与森林的相互转换本文只给出树、森林与二叉树之间的转换方法，而详细的证明过程不在本文讨论范围之内。树 → 二叉树在所有兄弟结点之间加一连线。对每个结点，除了保留与其长子的连线外，去掉该结点与其它孩子的连线。二叉树 → 树是树转换为二叉树的逆过程。加线。若某结点X的左孩子结点存在，则将这个左孩子的右孩子结点、右孩子的右孩子结点、右孩子的右孩子的右孩子结点…，都作为结点X的孩子。将结点X与这些右孩子结点用线连接起来。去线。删除原二叉树中所有结点与其右孩子结点的连线。森林 →

代码如下:#include <iostream>#include <stack>using namespace std;const int N = 100;typedef struct Node{ int adj; int w; Node *next;}Node;typedef struct VNode{ int in; int v; Node *first; VNode() { first = nullptr; }}VNode;

前言：这个属于数据结构：树。下面给个例子图解释（根节点、子节点、叶子节点）。上图数字 1、3、7是叶子节点；（因为他们下面没有分叉出子节点，所以称为：叶子节点）【度为0】数字2、8是子节点； （除了根节点、叶子节点之外的，都称为：子节点）【度为1】数字5是根节点；（因为他是最顶部，所以称为：根节点）【度为2】一、根节点（root node）?根节点：树的最顶端的节点。（根节点只有一个）二、子节点（child node）?子节点：除根节点之外，并且本身下面还连接有节点的节点。三、叶.

代码如下:#include <iostream>using namespace std;const int N = 30;typedef char ElemType;const double noEdge = 99999;class Graph{private: double G[N][N]; int vertexN, edgeN; double dist[N]; bool vis[N]; int path[N]; int sv; ElemType data[N]

对于任给的一张无向带权连通图，求出其最小生成树。题目要求:(1)编程创建一幅图(2)输出创建的图(3)编写Prim算法代码，实现图的最小生成树求解，且输出最小生成树(4)编写Kruskal算法代码，实现图的最小生成树求解，且输出最小生成树(5)编写菜单，允许用户选择相应操作代码如下:#include <iostream>#include <queue>#include <algorithm>using namespace std;const int

代码如下：#define MAXN 1000 /* 集合最大元素个数 */typedef int ElementType; /* 默认元素可以用非负整数表示 */typedef int SetName; /* 默认用根结点的下标作为集合名称 */typedef ElementType SetType[MAXN]; /* 假设集合元素下标从0开始 */void Union( SetType S, SetName Ro

代码如下:#include <iostream>#include <string>#include <stack>#include <queue>using namespace std;class Tree{private: class Node { public: char val; Node * left; Node *right; Node(char val):val(val),left(nullptr),rig

代码如下:#include<iostream>#include <queue>#include <stack>using namespace std;class BinTree{private: class TreeNode { public: int data; TreeNode *left; TreeNode *right; TreeNode ():data(0),left(nullptr),right(nullptr){}

代码如下:/* 邻接表存储 - 拓扑排序算法 */bool TopSort( LGraph Graph, Vertex TopOrder[] ){ /* 对Graph进行拓扑排序, TopOrder[]顺序存储排序后的顶点下标 */ int Indegree[MaxVertexNum], cnt; Vertex V; PtrToAdjVNode W; Queue Q = CreateQueue( Graph->Nv ); /* 初始化Inde

prim算法:/* 邻接矩阵存储 - Prim最小生成树算法 */Vertex FindMinDist( MGraph Graph, WeightType dist[] ){ /* 返回未被收录顶点中dist最小者 */ Vertex MinV, V; WeightType MinDist = INFINITY; for (V=0; V<Graph->Nv; V++) { if ( dist[V]!=0 && dist[V]&lt

dijkstra算法:/* 邻接表存储 - 无权图的单源最短路算法 *//* dist[]和path[]全部初始化为-1 */void Unweighted ( LGraph Graph, int dist[], int path[], Vertex S ){ Queue Q; Vertex V; PtrToAdjVNode W; Q = CreateQueue( Graph->Nv ); /* 创建空队列, MaxSize为外部定义的常数 */

邻接表存储的图 - DFS/* 邻接表存储的图 - DFS */void Visit( Vertex V ){ printf("正在访问顶点%d\n", V);}/* Visited[]为全局变量，已经初始化为false */void DFS( LGraph Graph, Vertex V, void (*Visit)(Vertex) ){ /* 以V为出发点对邻接表存储的图Graph进行DFS搜索 */ PtrToAdjVNode W; Visit(

代码如下:package HuffmanTreeArrays;import java.util.ArrayList;import java.util.Scanner;public class HuffmanTree { private class TreeNode { private int val; private int left; private int right; private int parent;

代码如下:package HuffmanTree;import java.util.ArrayList;import java.util.LinkedList;import java.util.Queue;import java.util.Scanner;public class HuffmanTree { private class TreeNode { private int val; private TreeNode left;

代码如下:package AVLTree;import java.util.ArrayList;import java.util.LinkedList;import java.util.Queue;import java.util.Scanner;public class AVLTree { private class TreeNode { private int data; TreeNode left; TreeNode ri

最大堆代码如下:package MaxHeap;import java.util.Scanner;public class Heap { private int data[]; private int size; private int capacity; private final int maxNum = 999999999; public Heap() { data = new int[10+1]; size

代码如下:package BSTree;import java.util.ArrayList;import java.util.LinkedList;import java.util.Queue;import java.util.Scanner;public class BSTree { private class TreeNode { int data; TreeNode left; TreeNode right;

代码如下:/* 图的邻接表表示法 */#define MaxVertexNum 100 /* 最大顶点数设为100 */typedef int Vertex; /* 用顶点下标表示顶点,为整型 */typedef int WeightType; /* 边的权值设为整型 */typedef char DataType; /* 顶点存储的数据类型设为字符型 *//* 边的定义 */typedef struct ENode *PtrToENode

代码如下:/* 图的邻接矩阵表示法 */#define MaxVertexNum 100 /* 最大顶点数设为100 */#define INFINITY 65535 /* ∞设为双字节无符号整数的最大值65535*/typedef int Vertex; /* 用顶点下标表示顶点,为整型 */typedef int WeightType; /* 边的权值设为整型 */typedef char DataType; /* 顶点存储的

#define MAXN 1000 /* 集合最大元素个数 */typedef int ElementType; /* 默认元素可以用非负整数表示 */typedef int SetName; /* 默认用根结点的下标作为集合名称 */typedef ElementType SetType[MAXN]; /* 假设集合元素下标从0开始 */void Union( SetType S, SetName Root1, S

代码如下:typedef struct HNode *Heap; /* 堆的类型定义 */struct HNode { ElementType *Data; /* 存储元素的数组 */ int Size; /* 堆中当前元素个数 */ int Capacity; /* 堆的最大容量 */};typedef Heap MaxHeap; /* 最大堆 */typedef Heap MinHeap; /* 最小堆 */#define MAXDATA

代码如下:typedef struct AVLNode *Position;typedef Position AVLTree; /* AVL树类型 */struct AVLNode{ ElementType Data; /* 结点数据 */ AVLTree Left; /* 指向左子树 */ AVLTree Right; /* 指向右子树 */ int Height; /* 树高 */};int Max ( int a, int b )

代码如下:BinTree Insert( BinTree BST, ElementType X ){ if( !BST ){ /* 若原树为空，生成并返回一个结点的二叉搜索树 */ BST = (BinTree)malloc(sizeof(struct TNode)); BST->Data = X; BST->Left = BST->Right = NULL; } else { /* 开始找要插入元素的位置 */

二叉树:package Tree;import java.util.ArrayList;import java.util.LinkedList;import java.util.Queue;import java.util.Stack;public class BinTree { private class TreeNode { int data; TreeNode left; TreeNode right;

循环队列:package SeqQueue;public class Queue { private int data[]; private int queueSize; private int front,rear; public Queue() { data = new int[100]; queueSize = 100; front = rear = 0; } public Queue(i

顺序栈：package SeqStack;public class Stack { private int top; private int base[]; private int stackSize; public Stack() { stackSize = 100; base = new int[stackSize]; top = -1; } public Stack(int n)

顺序表:package seqTable;import java.util.ArrayList;import java.util.Scanner;public class SeqList { private int data[]; private int len; private int maxSize; public SeqList() { data = new int[100]; maxSize = 100;

代码如下:BinTree Insert( BinTree BST, ElementType X ){ if( !BST ){ /* 若原树为空，生成并返回一个结点的二叉搜索树 */ BST = (BinTree)malloc(sizeof(struct TNode)); BST->Data = X; BST->Left = BST->Right = NULL; } else { /* 开始找要插入元素的位置 */

尾递归：在程序要返回的地方出现递归，从编译的角度来讲，尾递归都可以用循环来实现。例子：二叉搜索树的查找操作Find递归函数可以写成循环的方式实现

二叉树的存储结构:typedef struct TNode *Position;typedef Position BinTree; /* 二叉树类型 */struct TNode{ /* 树结点定义 */ ElementType Data; /* 结点数据 */ BinTree Left; /* 指向左子树 */ BinTree Right; /* 指向右子树 */};二叉树的四种遍历:void InorderTraversal( BinTree BT )

顺序存储：typedef int Position;struct QNode { ElementType *Data; /* 存储元素的数组 */ Position Front, Rear; /* 队列的头、尾指针 */ int MaxSize; /* 队列最大容量 */};typedef struct QNode *Queue;Queue CreateQueue( int MaxSize ){ Queue Q = (Queue)m

顺序存储：typedef int Position;struct SNode { ElementType *Data; /* 存储元素的数组 */ Position Top; /* 栈顶指针 */ int MaxSize; /* 堆栈最大容量 */};typedef struct SNode *Stack;Stack CreateStack( int MaxSize ){ Stack S = (Stack)malloc(sizeof(str

顺序表:typedef int Position;typedef struct LNode *List;struct LNode { ElementType Data[MAXSIZE]; Position Last;};/* 初始化 */List MakeEmpty(){ List L; L = (List)malloc(sizeof(struct LNode)); L->Last = -1; return L;}/* 查找 *