数据结构学习日记三：树

已于 2023-08-10 17:03:26 修改
阅读量62 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 学习
于 2023-08-10 17:00:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63494746/article/details/132213573
版权

五、树

1、静态查找

1.1 顺序查找:O(n)

哨兵的好处是，可以只靠自然的循环顺序进行查找，实现当碰到哨兵自动退出循环的效果。无哨兵的时候，循环的条件需要多一条分支判断，防止数组访问越界。

int Search(List L, ElementType K){
    //在L[1]到L[n]中查找k
    int i;
    L->Data[0] = K;	//建立哨兵
    for(i = L->Length; L->Data[i] != K; i--);
    return i;	//找到返回下标i，否则返回0
}

1.2 二分查找

适用于有序的数组里的查找。

int BinarySearch(List L, ElementType K){
    int left, right, mid, NoFound = -1;
    //初始化左右边界
    left = 1;
    right = L->Length;
    while(left <= right){
        mid = (left + right)/2;	//计算中间坐标
        if(K < L->Data[mid])	right = mid - 1;
        else if(K > L->Data[mid])	left = mid + 1;
        else return mid;	//查找成功
    }
    return NoFound;	//查找不成功，返回-1
}

2、树的性质

  • 子树是不相交的；
  • 除了根结点外，每个结点有且仅有一个父结点；
  • 一棵N个结点的树有N-1条边。

3、二叉树的重要性质

  • 二叉树第 i 层的最大结点数为：2i-1，i >=1。
  • 深度为 k 的二叉树有最大结点总数为：2k-1，k>=1。
  • 对于任何非空二叉树，若 n0 表示叶结点的个数、n2 是度为2的非叶子结点个数，那么两者满足关系 n0 = n2 + 1。

4、二叉树的存储结构

4.1 顺序存储结构

完全二叉树： 它的结点的编号刚好是顺着的，按从上到下，从左到右排列。

完全二叉树

性质：

假设序号从1开始。

  • 非根节点 i 的父结点的序号是【i/2】；
  • i 结点的左孩子结点的序号是【2i】
    • 要保证 2i <= n，否则没有左孩子；
  • i 结点的右孩子结点的序号是【2i+1】
    • 要保证 2i+1<=n，否则没有右孩子。

4.2 链表存储

左右孩子表示法。

typedef struct TreeNode* BinTree;
typedef BinTree Position;
struct TreeNode{
    ElementType Data;
    BinTree Left;
    BinTree Right;
}

5、二叉树的遍历

5.1 先序遍历

//根 左 右
void PreOrderTraversal(BinTree BT){
    if(BT){
        printf("%d",BT->Data);
        PreOrderTraversal(BT->Left);
        PreOrderTraversal(BT->Right);
    }
}

先序遍历

先根，也就是A。然后遍历左子树（先根B，然后遍历左子树（先根D，因为无左右子树，所以回退到B），接着遍历右子树F）。。。同理

先序遍历：A (B D F E) (C G H I)

5.2 中序遍历

//左 根 右
void InOrderTraversal(BinTree BT){
    if(BT){
        InOrderTraversal(BT->Left);
        printf("%d",BT->Data);
        InOrderTraversal(BT->Right);
    }
}

中序遍历

先遍历A的左子树（先遍历B的左子树（遍历D，然后回退到B），遍历根B，遍历右子树（遍历左子树E，回退遍历F）），回退遍历根结点A，然后遍历右子树。。。同理。

中序遍历：（D B E F）A (G H C I)

中序遍历的非递归遍历算法

void InOrderTraversal(BinTree BT){
    BinTree T = BT;
    Stack S = CreateStack(MaxSize);	//创建并初始化堆栈
    while(T || !IsEmpty(S)){
        while(T){	//一直把左孩子压栈
            Push(S,T);
            T = T->Left;
        }
        if(!IsEmpty(S)){
            T = Pop(S);	//弹栈，
            printf("%5d", T->Data);	//打印数据
            T = T->Right;	//转向右结点
        }
    }
}

对于先序、中序、后序，其实遍历路径是一样的，就是输出值的时机不一样。先序是在第一次碰到结点的时候就输出，中序是第二次，后序是第三次。

反映到非递归，使用堆栈实现的时候就是：

第一次碰到结点：压栈的时候。输出放到压栈Push(S)前

第二次碰到结点：弹栈的时候。输出放到Pop(S)后。

5.3 后序遍历

//左 右 根
void PostOrderTraversal(BinTree BT){
    if(BT){
        PostOrderTraversal(BT->Left);
        PostOrderTraversal(BT->Right);
        printf("%d",BT->Data);
    }
}

后序遍历

后序遍历：（D E F B） (H G I C) A

后序遍历的非递归算法

实现流程：先把根结点压栈；

  1. 如果有左孩子，就压栈，并移动当前结点为左孩子；

  2. 如果没有左孩子，就考虑有没有右孩子：

    • 如果有右孩子，就把右孩子压栈，并且当前结点指向右孩子，然后从步骤1重复。

    • 如果没有右孩子，就输出该结点，并且考虑是否为下一个栈顶元素的右孩子：

      • 如果是右孩子，说明对于当前栈顶元素，其左右孩子都遍历完了，可以输出该栈顶元素。
      • 如果是左孩子，就还要考虑是否有右孩子，然后从步骤1重复。
void PostOrderTraversal(BinTree BT){
    if(NULL == BT) return;	//空树
    
    Stack S = CreateStack(MaxSize);	//创建和初始化堆栈
    BinTree currentNode = BT;		//存储当前访问结点
    BinTree visitedNode = BT;		//存储上一个访问结点
    
    //当前结点非空，或者栈非空时
    while(currentNode || !IsEmpty(S)){
        //当前结点非空，就沿着左子树方向入栈
        while(currentNode){
            Push(currentNode,S);
            currentNode = currentNode->Left;
        }
        currentNode = Top(S);	//获取当前栈顶元素
        //如果栈顶元素有右子树，且未被访问
        if(currentNode->Right && currentNode->Right != visitedNode){
            currentNode = currentNode->Right;
        }
        else{
            //子树为空或被访问过
            printf("%d ",currentNode->Data);//访问结点数据
            visitedNode = currentNode;	//记录当前访问的结点
            currentNode = NULL;	//当前结点置为NULL，防止重复访问左子树
            Pop(S);//出栈
        }
    }
}

5.4 层序遍历

void LevelOrderTraversal(BinTree BT){
	Queue Q;
    BinTree T;
    if(!BT) return;	//空树直接返回
    Q = CreateQueue(MaxSize);	//创建并初始化队列
    AddQ(Q, BT);
    while(!IsEmptyQ(Q)){
        T = DeleteQ(Q);
        printf("%d\n", T->Data);	//访问结点
        if(T->Left) AddQ(Q, T->Left);	//把左右孩子塞入队列
        if(T->Right) AddQ(Q, T->Right);
    }
}

6、遍历二叉树的应用

输出二叉树中的叶子结点

void fun(BinTree BT){
	if(BT){
        if(!BT->Left && !BT->Right)
        	printf("%d",BT->Data);
        PreOrderTraversal(BT->Left);
        PreOrderTraversal(BT->Right);
    }
}

求二叉树的高度

递归，想象一下就是求 MAX（左子树的高度，右子树的高度）+1。

int PostOrderGetHeight(BinTree BT){
    int  HL,HR,MaxH;
    if(BT){
        HL = PostOrderGetHeight(BT->Left);
        HR = PostOrderGetHeight(BT->Right);
        MaxH = (HL > HR) ? HL : HR;
        return (MaxH + 1);
    }
    else return 0;	//递归的终止条件，空树深度为0
}

二元运算表达式树及其遍历

二元运算树

该树特点： 叶子是运算数，非叶子结点是运算符。

对该树前序遍历得到前缀表达式，中序遍历得到中缀表达式，后序遍历得到后缀表达式。

输出中缀表达式的时候，会受到运算符优先级的影响，所以应该在输出左子树的时候先输出左括号，输出完左子树，加上右括号。

由两种遍历序列确定二叉树

必须要有中序遍历才行。

1. 先序和中序确定二叉树

  • 先序的第一个结点是根结点；
  • 拿着根结点，把中序遍历序列划分成左右两个子序列；
  • 然后在上一个先序序列里数出和左子序列相同数量的结点，就得到当前左子序列对应的先序序列，然后就可以拿着新的左子树的先序序列和中序序列求解。右子序列同样解法。

7、二叉搜索树

二叉搜索树（BST，Binary Search Tree）也称二叉排序树或二叉查找树。

性质：

  • 非空左子树的所有键值小于其根结点的键值；
  • 非空右子树的所有键值大于其根结点的键值；
  • 左右子树都是二叉搜索树。

二叉搜索树操作的特别函数：

（1、查找任意元素；2、查找最小元素；3、查找最大元素。）并返回地址。4、插入；5、删除。

7.1 查找操作Find

Position Find(ElementType X, BinTree BST){
    if(!BST) return NULL;	//查找失败
    if(X > BST->Data)
        return Find(X, BST->Right);
    else if(X < BST->Data)
        return Find(X, BST->Left);
    else
        return BST;	//查找成功，返回结点地址
}

因为上述递归是“尾递归”，所以可以改成循环，提高效率。

Position Find(ElementType X, BinTree BST){
    while(BST){
        if(X > BST->Data)
            BST = BST->Right;
        else if(X < BST->Data)
            BST = BST->Left;
        else
            return BST;	//查找成功，返回结点地址
    }
    return NULL;
}

7.2 查找最大和最小元素

查找最小元素的递归函数

Position FindMin(BinTree BST){
	if(!BST) return NULL;
    else if(!BST->Left)
        return BST;	//找到最左叶结点并返回
    else
        return FindMin(BST->Left);	//沿着左子树继续查找
}

查找最大元素的迭代函数

Position FindMax(BinTree BST){
	if(BST)
        while(BST->Right)	BST = BST->Right;
    		//找到最右结点
    return BST;
}

7.3 二叉搜索树的插入

BinTree Insert(ElementType X,BinTree BST){
    if(!BST){
        //若原树为空，就生成只有一个结点的二叉搜索树返回
        //第二种情况：找到插入位置了，生成新结点，然后返回地址给父亲结点
        BST = (BinTree)malloc(sizeof(struct TreeNode));
        BST->Data = X;
        BST->Left = BST->Right = NULL;
    } else{
        //寻找插入的位置
        if(X < BST->Data)
            BST->Left = Insert(X,BST->Left);
        else if(X > BST->Data)
            BST->Right = Insert(X,BST->Right);
        //if x已经在树中存在，什么都不做
    }
    return BST;
}

递归太霸道了，少年你把握不住啊！

滑到插入位置，生成新结点，放在其左孩子或右孩子，然后原路返回。

7.4 二叉搜索树的删除

三种情况：

  1. 删除的是叶结点：直接删除叶结点，修改父亲结点的相应指向为NULL；
  2. 删除的是只有一个孩子的结点：将其父结点的指针指向要删除结点的孩子结点；
  3. 删除的是有左右子树的结点：用了一个结点替代被删除结点，右子树的最小元素或者左子树的最大元素。（因为这个结点完美满足搜索树的左小右大原则）
BinTree Delete(ElementType X, BinTree BST){
    Position Tmp;
    if(!BST) printf("未找到要删除的元素");
    else if(X < BST->Data)
        BST->Left = Delete(X, BST->Left);//我滑
    else if(X > BST->Data)
        BST->Right = Delete(X, BST->Right);//我滑
    else{
        //找到要删除的结点
        if(BST->LEft && BST->Right){	//左右子树都有
            Tmp = FindMin(BST->Right);//找右子树最小结点
            BST->Data = Tmp->Data;//替换删除结点的值
            //斩草除根，把右子树上的替换结点删掉
            BST->Right = Delete(BST->Data, BST->Right);
        } else{
            //被删除结点有一个或无子结点
            Tmp = BST;
            if(!BST->Left)	//有右孩子或无孩子
                BST = BST->Right;
            else if(!BST->Right)	//有左孩子或无孩子
                BST = BST->Left;
            free(Tmp);
        }
    }
    return BST;
}

8、平衡二叉树

平衡二叉树首先是个搜索树，满足左小右大。

8.1 概念和性质

“平衡因子”（Balance Factor，简称BF）：BF(T) = hL-hR。

其中hL和hR分别为T的左、右子树的高度。

平衡二叉树（AVL树）

空树，或者任意结点左右子树高度差的绝对值不超过1，即 |BF(T)|<=1

设nh是高度为h的平衡二叉树的最小结点数 => nh = nh-1 + nh-2 + 1

n0 = 1; n1 = 2; …以此类推

或者根据斐波那契数列推导：1 1 2 3 5 8 13…

​ 为 nh = Fh+2 - 1 ， (h>=0)

给定结点数为 n 的AVL树的最大高度为 O(log2n)。

8.2 平衡二叉树的调整

调整应该调整最开始导致不平衡的地方，这样上层的不平衡自然就解决了。

选择解决方式关键是：找出被破坏者和破坏者，然后分析关系是左左，右右，左右还是右左。

8.2.1 RR旋转（右单旋）

RR旋转

如上图所示，本身平衡的树，因为右子树的右子树插入结点，导致不平衡。

不平衡的“发现者”是 A ，“麻烦结点” BR 在发现者右子树的右子树上，所以叫RR插入，需要RR旋转（右单旋）。

此时把B 提高，把A当做B的左孩子，麻烦结点降低，发现者升高，解决了不平衡，然后因为搜索树左小右大，BL比B小，比A大，所以刚好放在A的右边。

8.2.2 LL旋转（左单旋）

LL旋转

如上图所示，本身平衡的树，因为左子树的左子树插入结点，导致不平衡。

不平衡的“发现者”是 A ，“麻烦结点” BL 在发现者左子树的左子树上，所以叫LL插入，需要LL旋转（左单旋）。

此时把B 提高，把A当做B的右孩子，麻烦结点降低，发现者升高，解决了不平衡，然后因为搜索树左小右大，BR比B大，比A小，所以刚好放在A的左边。

8.2.3 LR旋转

LR旋转

如上图所示，本身平衡的树，因为左子树的右子树插入结点，导致不平衡。

不平衡的“发现者”是 A ，“麻烦结点” C 在发现者左子树的右子树上，所以叫LR插入，需要LR旋转。

此时把ABC变成CBA，B不动，C变最顶上，A变成C的右孩子，C的孩子左边归B，右边归A。

8.2.4 RL旋转

RL旋转

六、堆

1、优先队列

特殊的队列，元素是按照优先权大小排序，不是按照进入队列的先后顺序。

需要新的数据结构，实现快捷对最大或最小值删除操作的结构，也就是堆。

2、堆

2.1 堆的特性

结构性：用数组表示的完全二叉树。

有序性：任一结点的关键字是其自述所有结点的最大值（或最小值）。

  • 最大堆(MaxHeap)，大顶堆；
  • 最小堆(MinHeap)，小顶堆。

2.2 最大堆的实现

typedef struct HeapStruct* MaxHeap;
struct HeapStruct{
    ElementType* Elements;	//存储堆元素的数组
    int Size;				//堆的当前元素个数
    int Capacity;		//堆的最大容量
};

//最大堆的创建
MaxHeap Create(int MaxSize){
    MaxHeap H = malloc(sizeof(struct HeapStruct));
    H->Elements = malloc((MaxSize+1) * sizeof(ElementType));
    H->Size = 0;
    H->Capacity = MaxSize;
    H->Elements[0] = MaxData;
    	//定义哨兵为大于堆中所有可能元素的值，便于以后更快操作
    return H;
}

//最大堆的插入
void Insert(MaxHeap H, ElementType item){
    int i;
    if(IsFull(H)){
        printf("最大堆已满");
        return;
    }
    i = ++H->Size;	//i指向插入后堆中的最后一个元素的位置
    for(; H->Elements[i/2] < item; i/=2)
        H->Elements[i] = H->Elements[i/2];	
    		//已知如果结点序号从1开始，那么i结点的父亲结点是i/2
    		//堆的处理是自下而上的，最开始假设数组末尾值是item
    		//每次循环都是i结点和父亲作比较，也就是item和父亲值比较
    		//假设i结点插入的值是item，比父亲大，就往上爬。
    		//直到所有比i小的都下移，就空出了item应该插入的位置
    		//为什么不怕越界，因为哨兵啊，o(￣▽￣)ｄ
    		//当然你要是怕的话，就加一句i>1
    H->Elements[i] = item;	//将item插入空出来的位置
}

//最大堆删除
ElementType DeleteMax(MaxHeap H){
    //堆的最大值是根结点，所以删除根结点
    int Parent,Child;
    ElementType MaxItem, temp;
    if(IsEmpty(H)){
        printf("最大堆已空");
        return;
    }
    MaxItem = H->Elements[1];	//取出根结点的最大值
    //用最大堆中最后一个元素从根结点开始向上过滤下层结点。
    temp = H->Elements[H->Size--];
    //跟插入相反，这里假设末尾值是最大值，所以从根结点开始考虑
    //自上而下
    for(Parent = 1; Parent*2 <= H->Size; Parent = Child){
        Child = Parent * 2;
        if((Child != H->Size)&&
          	(H->Elements[Child] < H->Elements[Child+1]))
            Child++;	//Child指向左右子结点的较大者
        				//因为这是最大堆，只要和大的比较
        if(temp >= H->Elements[Child]) break;
        else	//大的排上面
            H->Elements[Parent] = H->Elements[Child];
    }
    H->Elements[Parent] = temp;
    return MaxItem;
}

2.3 最大堆的建立

将N个元素按最大堆的要求存放在一维数组里。

方法一：通过插入操作，将N个元素插入初始为空的堆中。时间复杂度是O(NlogN)。

方法二：线性时间复杂度下建立最大堆。

  1. 将N个元素按输入顺序存入，先满足完全二叉树的结构特性；
  2. 调整各个结点位置，来满足最大堆的有序特性。
void PercDown( MaxHeap H, int p )
{ 
    /* 下滤：将H中以H->Data[p]为根的子堆调整为最大堆 */
    int Parent, Child;
    ElementType X;

    X = H->Data[p]; /* 取出根结点存放的值 */
    for( Parent=p; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
}

void BuildHeap( MaxHeap H )
{ 
    int i;

    //只要保证堆的每一个小堆，满足最大堆性质。
    //自下而上，自然就得到整体的最大堆。
    for( i = H->Size/2; i>0; i-- )
        PercDown( H, i );
}

3、哈夫曼树与哈夫曼编码

3.1 哈夫曼树

哈夫曼树的理念降低加权路径和。

typedef struct TreeNode* HuffmanTree;
struct TreeNode{
    int weight;
    HuffmanTree Left, Right;
};
HuffmanTree Huffman(MinHeap H){
    int i;	HuffmanTree T;
    BuildMinHeap(H);	//将堆按权值大小调整成最小堆
    for(i = 1; i < H->Size; i++){	//需要size-1次合并
        T = malloc(sizeof(struct TreeNode));//建立新的结点
        	//选两个最小的结点拼成一个哈夫曼
        T->Left = DeleteMin(H);
        T->Right = DeleteMin(H);
        T->Weight = T->Left->Weight + T->Right->Weight;
        
        Insert(H,T);	//将新结点插入最小堆
    }
    T = DeleteMin(H);	//堆顶的元素就是最终的哈夫曼树
    return T;
}

哈夫曼树的特点：

  • 没有度为1的结点；
  • n 个叶子结点的哈夫曼树共有2n-1个结点；
  • 哈夫曼树的任意非叶结点的左右子树交换后仍是哈夫曼树。
  • 同一份权值，可能有多颗哈夫曼树，但是加权路径和是一样的。

3.2 哈夫曼编码

利用哈夫曼树实现，编码左0右1，符合前缀码，实现不等长编码，从而节省空间。

4、集合

把集合想象成树结构。

4.1 并查集

可以合并集合；可以查看某元素属于什么集合。

并查集

双亲表示法：孩子指向双亲。

采用数组存储：
并查集的数组存储方式

Data存数据，Parent存父亲结点在数组中的下标，父亲结点的Parent为-1。

typedef struct{
    ElementType Data;
    int Parent;
}SetType;

//查找某个元素所在的集合
int Find(SetType S[], ElementType X){
    int i;
    for(i = 0; i < MaxSize && S[i].Data != X; i++);
    		//查找X
    if(i >= MaxSize) return -1;	//未找到X，返回-1
    for( ; S[i].Parent >=0; i = S[i].Parent);
    		//顺着X，向上爬，找到最终的集合根
    return i;	//返回树根结点在数组中下标
}

//集合的合并
void Union(SetType S[], ElementType X1, ElementType X2){
    int Root1, Root2;
    Root1 = Find(S, X1);
    Root2 = Find(S, X2);
    if(Root1 != Root2)
        S[Root2].Parent = Root1;
    		//合并的意思，就是强迫其中一位认父，o(￣▽￣)ｄ
}

更简化版集合，集合的下标是数据，集合的内容是集合根结点的下标。

按秩归并和路径压缩，加倍快乐！！！！！

typedef int ElementType;	//默认元素用非负整数表示
typedef int SetName;		//默认用根结点的下标作为集合名称
typedef ElementType SetType[MaxSize];//集合

SetName Find(SetType S, ElementType X){
    if(S[X] < 0)	//找到集合的根
        return X;
    else
        return S[X] = Find(S, S[X]);
    //Find函数：找到根结点下标，并返回
 	//Find函数的效果，会导致，查找路径上的集合元素的父亲直接变成根结点
    //完成了路径压缩，而不是每次都从最底下往上找
    //最后才是返回根结点
    //传说中的第一次没啥区别，第2次开始超级快。
}

//按秩归并
//集合树型结构，如果只是简单的合并，会导致树的高度变高，查找路径变得很长
//但如果通过按秩归并，来降低树的高度。
//增强合并，加强查找效率
void Union(SetType S, SetName Root1, SetName Root2){
    //默认Root1和Root2是不同集合的根结点
    //实际需要判断两个根结点的大小，小的集合并到大的集合，
    //集合的根结点保存的是负数，数值代表集合元素的个数。
    if ( S[Root2] < S[Root1] ) {//集合2大
        S[Root2] += S[Root1];    
        S[Root1] = Root2;
    }
    else {						//集合1大
        S[Root1] += S[Root2];   
        S[Root2] = Root1;
    }
}
明々天
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构学习日记（一）
weixin_46600208的博客
02-13 372
一， 1，数据元素是数据的基本单位，一个数据元素由若干数据项组成 2，数据结构：相互之间有关系的数据元素集合 ， 数据对象：相同性质的数据数据元素的集合 二， 1，逻辑结构 集合：各元素同属一个集合，无其他关系 线性结构：一对一关系，除了第一和最后，唯一前驱，唯一后继 树形结构：一对多关系 图状结构：多对多关系 2,物理结构 顺序存储：逻辑上相邻的元素存储在物理位置上也相邻的存储单元中。 链式存储：可以不相邻，用指针表示下一个数据元素的存储地址。 索引存储：建立附加的索引...
数据结构学习日记（四）
weixin_46600208的博客
02-16 526
一，双链表 单链表只包含后继节点的指针，从一个节点出发只能找到后继的各个节点 双链表又添加一个指针域，指向前驱节点，表头节点的prior指向null，表尾节点的next指向null。 （1）双链表的初始化 （2）双链表的插入 （3）双链表的删除 （4）双链表的遍历 二，循环链表 （1）循环单链表，从一个节点出发可以找到其他任何一个节点 （2）循环双链表，表头节点的prior指向表尾节点，表尾节点的next指向头结点。 三，单链表的基本操作代码示意：1-12 #include <
树的基本内容
Running ╯的博客
08-12 316
二叉树的存储结构 ： 顺序存储结构 : 完全二叉树：按从上至下、从左到右顺序存储 n个结点的完全二叉树的结点父子关系： 非根结点（序号 i > 1）的父结点的序号是 i / 2; 结点（序号为 i ）的左孩子结点的序号是 2i，（若2 i <= n，否则没有左孩子）; 结点（序号为 i ）的右孩子结点的序号是 2i+1，（若2 i +1<= n，否则没有右孩子...
数据结构学习日记四：图
qq_63494746的博客
08-26 68
邻接矩阵、邻接表、图的遍历、最短路径、Dijkstra算法、Floyd算法、最小生成树、Prim算法、Kruskal算法、拓扑排序、关键路径
数据结构学习日记六：查找
qq_63494746的博客
09-06 61
顺序查找 O(N)二分查找（静态查找） O(logN)二叉搜索树 O(h) h 为二叉查找树的高度平衡二叉树 O(logN)散列查找 几乎是O(1)，以空间换时间。
DAY 8 学习日记 and CSP-J初赛知识3：树形数据结构
taoyiwei17_QFOI的博客
08-27 133
每个结点的子结点均不超过两个的树称之为二叉树。
学习日记：线段树基本操作
emnsj的博客
05-18 504
4.查询(如果没有全包含在查询区间内，则继续将懒惰标记下发给子结点，并修改结点值)3.添加懒惰标记(如果没有全包含在修改区间内，则继续将懒惰标记下发给子结点)2.建树(没啥特别注意的)
数据结构（java）——学习日记（树）
weixin_64836042的博客
05-19 73
树是一种非线性数据结构：每一个结点可以有零个或多个后继结点，但是有且仅有一个前驱结点（根节点除外）。数据元素之间存在的关系的一对多的关系。n>0时，有且仅有一个根节点（root），其余结点可分为m个互不相交的有限集，其中每个子集本身又是一棵符合本定义的树，称为根节点的子树。树是由n个结点组成的有限集合。（n=0时，是一棵空树），
[数据结构学习日记]PTA-树1 树的同构
LazyHan的博客
04-21 78
给定两棵树T1和T2。如果T1可以通过若干次左右孩子互换就变成T2，则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的，因为我们把其中一棵树的结点A、B、G的左右孩子互换后，就得到另外一棵树。而图2就不是同构的。 图1 图2 现给定两棵树，请你判断它们是否是同构的。 输入格式: 输入给出2棵二叉树树的信息。对于每棵树，首先在一行中给出一个非负整数N(≤10)，即该树的结点数（此时假设结点从0到N−1编号）；随后N行，第i行对应编号第i个结点，给出该结点中存储的1个英文大写字...
vue学习日记17：scoped样式冲突
03-21
vue学习日记17：scoped样式冲突
vue学习日记19：记事本-组件版
03-26
记事本组件版本
Python3学习日记：基础语法
12-22
标识符 第一个字符必须是字母表中字母或下划线 _ 。 标识符的其他的部分由字母、数字和下划线组成。 标识符对大小写敏感。 不能使用关键字作为标识符 Python关键字 [‘False’, ‘None’, ‘True’, ‘and’, ...
部编三年级上册语文习作：写日记.pdf
03-04
部编三年级上册语文习作：写日记
部编三年级上册习作：写日记.docx
03-04
今天我们就来读一篇和你们一样大的学生写的一篇日记，看一看文中的这位小朋友是怎么捉鱼的？看一看他最后捉到鱼了吗？ 3.教师范读日记，学生看课件。 4.（课件出示2） 2017年7月25日 星期一 天气晴 　今天吃完...
数据结构堆排序（c语言版）
z6665454的博客
05-18 1179
在构建好堆之后,堆排序会进行反复的交换和调整操作,将堆顶元素(最大值或最小值)与堆的最后一个元素交换,然后缩小堆的规模。堆排序的优势是能够在一个数组上就地完成排序,不需要额外的空间。堆排序是一种原地排序算法,不需要额外的内存空间来辅助排序,而是直接在原数组上进行操作。大顶堆的根节点是数组中的最大值,小顶堆的根节点是数组中的最小值。堆排序的主要功能是对一个给定的数组进行升序或降序排序。大顶堆的特点是根节点的值大于或等于其左右子节点的值。堆排序的时间复杂度为O(nlogn),这使它成为高效的通用排序算法之一。
OpenHarmony 实战开发——内核IPC机制数据结构解析
maniuT的博客
05-21 597
队列控制块：管理具体消息队列的数据块，内核初始化时调用OsQueueInit()创建，并依次挂载到双向环形链表g_freeQueueList中，此时控制块状态为OS_QUEUE_UNUSED，队列控制块用来保存队列的状态，队列长度、消息长度、队列ID、队列头尾位置和等待读写的任务列表，内核就是根据这些信息来管理消息队列和任务完成对消息读写等操作。任意时刻互斥锁的状态只有开锁或闭锁，当有任务持有时，互斥锁处于闭锁状态，任务获得该互斥锁的所有权；当该任务释放它时，互斥锁被开锁，任务失去该互斥锁的所有权；
二叉树
最新发布
xkroy的博客
05-22 471
二叉树
刷题篇--数据结构--链表
hyldzbg的博客
05-18 425
如果我们有一个链表是1-->2-->3-->4-->5这样的，那我们反转后就是5-->4-->3-->2-->1这样的，那么要如果对链表操作呢？我们可以发现在反转后的链表里1-->2,变成2-->1那么我们就顺着这个思路，直接将下一个节点插到头节点前不就好了！！看起来好像不是很难，但是实现起来却很简单😉👌，嘿嘿！(^0^)我们可以再思考一下，将一个节点插到头节点前不就是头插嘛对不对，所以我们可以直接利用头插的方法来解决问题。
R学习日记——分解时间序列（季节性数据）
06-08
关于R学习日记——分解时间序列（季节性数据），我可以给你一些指导。 首先，对于季节性数据的分解，我们可以使用R中的`decompose()`函数。该函数可以将时间序列分解为趋势、季节性和随机三个部分。 以下是一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值