数据结构2月21日

news2025/1/13 7:34:40

双向链表:

func函数：

#include <stdio.h>                                                                                                                   
#include <stdlib.h>                                                                                                                  
#include "./double.h"                                                                                                                
                                                                                                                                     
//创建一个空的双向链表                                                                                                               
                                                                                                                                     
doubleLinkList* create_doubleLinkList()                                                                                              
{                                                                                                                                    
    doubleLinkList* head = (doubleLinkList*)malloc(sizeof(doubleLinkList));                                                          
    if(NULL==head)                                                                                                                   
    {                                                                                                                                
        printf("创建头结点失败，双向链表创建失败\n");                                                                                
        return NULL;                                                                                                                 
    }                                                                                                                                
                                                                                                                                     
    head->text.len=0;                                                                                                                
    head->next = NULL;                                                                                                               
    head->prev = NULL;                                                                                                               
                                                                                                                                     
    return head;                                                                                                                     
}                                                                                                                                    
                                                                                                                                     
                                                                                                                                     
//头插法                                                                                                                             
void insertHead_doubleLinkList(doubleLinkList* head,dataType num)                                                                    
{                                                                                                                                    
    doubleLinkList* temp=(doubleLinkList*)malloc(sizeof(doubleLinkList));                                                            
    if(NULL==temp)                                                                                                                   
    {                                                                                                                                
        printf("双向链表创建失败\n");                                                                                                
        return ;                                                                                                                     
    }                                                                                                                                
                                                                                                                                     
    temp->text.data = num;                                                                                                           
    temp->next=NULL;                                                                                                                 
    temp->prev=NULL;                                                                                                                 
                                                                                                                                     
    //链表为空，链表中有数据的逻辑不一致                                                                                             
    if(head->next==NULL)                                                                                                             
    {                                                                                                                                
        temp->next = head->next;                                                                                                     
        head->next = temp;                                                                                                           
                                                                                                                                     
        temp->prev = head;                                                                                                           
    }                                                                                                                                
    else                                                                                                                             
    {                                                                                                                                
        temp->next = head->next;                                                                                                     
        head->next = temp;                                                                                                           
                                                                                                                                     
        temp->next->prev = temp;                                                                                                     
        temp->prev = head;                                                                                                           
    }                                                                                                                                
                                                                                                                                     
    //更新头结点中链表的长度                                                                                                         
    head->text.len++;                                                                                                                
                                                                                                                                     
    return;                                                                                                                          
}                                                                                                                                    
                                                                                                                                     
//遍历                                                                                                                               
void show_doubleLinkLit(doubleLinkList* head)                                                                                        
{                                                                                                                                    
    doubleLinkList* p=head;                                                                                                          
    while(p->next != NULL)                                                                                                           
    {                                                                                                                                
        p=p->next;                                                                                                                   
        printf("%d ",p->text.data);                                                                                                  
    }                                                                                                                                
    printf("\n");                                                                                                                    
    return;                                                                                                                          
}                                                                                                                                    
                                                                                                                                     
//判断链表是否为空                                                                                                                   
int isEmpty_doubleLinkList(doubleLinkList* head)                                                                                     
{                                                                                                                                    
    return head->next == NULL? 1:0;                                                                                                  
}                                                                                                                                    
                                                                                                                                     
//尾插法                                                                                                                             
void insertTail_doubleLinkList(doubleLinkList* head,int num)                                                                         
{                                                                                                                                    
    doubleLinkList* temp=(doubleLinkList*)malloc(sizeof(doubleLinkList));                                                            
    if(NULL==temp)                                                                                                                   
    {                                                                                                                                
        printf("双向链表创建失败\n");                                                                                                
        return ;                                                                                                                     
    }                                                                                                                                
                                                                                                                                     
    temp->text.data = num;                                                                                                           
    temp->next=NULL;                                                                                                                 
    temp->prev=NULL;                                                                                                                 
                                                                                                                                     
    doubleLinkList* p =head;                                                                                                         
    while(p->next!=NULL)                                                                                                             
    {                                                                                                                                
        p=p->next;                                                                                                                   
    }                                                                                                                                
//该循环结束后，p指向最后一个结点                                                                                                    
    temp->next=NULL;                                                                                                                 
    p->next=temp;                                                                                                                    
                                                                                                                                     
    temp->prev=p;                                                                                                                    
                                                                                                                                     
    head->text.len++;                                                                                                                
                                                                                                                                     
    return;                                                                                                                          
                                                                                                                                     
}                                                                                                                                    
                                                                                                                                     
//按位置插入                                                                                                                         
void insertbyPos_doubleLinkList(doubleLinkList* head,int num,int pos)                                                                
{                                                                                                                                    
    doubleLinkList* temp=(doubleLinkList*)malloc(sizeof(doubleLinkList));                                                            
    if(NULL==temp)                                                                                                                   
    {                                                                                                                                
        printf("双向链表创建失败\n");                                                                                                
        return ;                                                                                                                     
    }                                                                                                                                
                                                                                                                                     
    temp->text.data = num;                                                                                                           
    temp->next=NULL;                                                                                                                 
    temp->prev=NULL;                                                                                                                 
                                                                                                                                     
    doubleLinkList* p = head;                                                                                                        
    for(int i=0;i<pos-1;i++)                                                                                                         
    {                                                                                                                                
        p=p->next;                                                                                                                   
    }                                                                                                                                
                                                                                                                                     
    //在中间和在边上是两种插入方法                                                                                                   
    if(p->next!=NULL)                                                                                                                
    {                                                                                                                                
        temp->next=p->next;                                                                                                          
        p->next=temp;                                                                                                                
                                                                                                                                     
        p->next->prev=temp;                                                                                                          
        temp->prev=p;                                                                                                                
    }                                                                                                                                
    else                                                                                                                             
    {                                                                                                                                
        temp->next=NULL;                                                                                                             
        p->next=temp;                                                                                                                
                                                                                                                                     
        temp->prev=p;                                                                                                                
    }                                                                                                                                
                                                                                                                                     
    head->text.len++;                                                                                                                
                                                                                                                                     
    return;                                                                                                                          
}                                                                                                                                    
                                                                                                                                     
//头删法                                                                                                                             
void deletebyhead_doubleLinkList(doubleLinkList* head)                                                                               
{                                                                                                                                    
    if(isEmpty_doubleLinkList(head)==1)                                                                                              
    {                                                                                                                                
        printf("链表为空，不能删除\n");                                                                                              
        return;                                                                                                                      
    }                                                                                                                                
                                                                                                                                     
    //删除有两种情况，一种只有两个，一种很多个                                                                                       
    doubleLinkList* p = head->next;                                                                                                  
    if(p->next!=NULL)                                                                                                                
    {                                                                                                                                
        head->next=p->next;                                                                                                          
                                                                                                                                     
        p->next->prev=head;                                                                                                          
    }                                                                                                                                
    else                                                                                                                             
    {                                                                                                                                
        head->next=p->next;                                                                                                          
    }                                                                                                                                
                                                                                                                                     
    free(p);                                                                                                                         
                                                                                                                                     
    return;                                                                                                                          
}                                                                                                                                    
                                                                                                                                     
//尾删法                                                                                                                             
void deletebyTail_doubleLinkList(doubleLinkList* head)                                                                               
{                                                                                                                                    
    if(isEmpty_doubleLinkList(head)==1)                                                                                              
    {                                                                                                                                
        printf("链表为空，不能删除\n");                                                                                              
        return;                                                                                                                      
    }                                                                                                                                
                                                                                                                                     
    //循环找到尾结点                                                                                                                 
    doubleLinkList* p = head->next;                                                                                                  
    while(p->next!=NULL)//该循环结束后，p指向最后一个结点                                                                            
    {                                                                                                                                
        p=p->next;                                                                                                                   
    }                                                                                                                                
    p->prev->next=NULL;                                                                                                              
    free(p);                                                                                                                         
}                                                                                                                                    
                                                                                                                                     
//按位置删除                                                                                                                         
void deletebyPos_doubleLinkList(doubleLinkList* head,int pos)                                                                        
{                                                                                                                                    
    if(isEmpty_doubleLinkList(head)==1)                                                                                              
    {                                                                                                                                
        printf("链表为空，不能删除\n");                                                                                              
        return;                                                                                                                      
    }                                                                                                                                
                                                                                                                                     
    doubleLinkList* p=head;                                                                                                          
    for(int i =0;i<pos;i++)                                                                                                          
    {                                                                                                                                
        p=p->next;                                                                                                                   
    }                                                                                                                                
                                                                                                                                     
    if(p->next!=NULL)                                                                                                                
    {                                                                                                                                
        p->prev->next=p->next;                                                                                                       
                                                                                                                                     
        p->next->prev=p->prev;                                                                                                       
    }                                                                                                                                
    else                                                                                                                             
    {                                                                                                                                
        p->prev->next=NULL;                                                                                                          
    }                                                                                                                                
                                                                                                                                     
    free(p);                                                                                                                         
                                                                                                                                     
    return;                                                                                                                          
}

main.c函数：

#include <stdio.h>
#include "./double.h"

int main(int argc, const char *argv[])
{
    doubleLinkList* head = create_doubleLinkList();
    insertHead_doubleLinkList(head,100);
    insertHead_doubleLinkList(head,100);
    insertHead_doubleLinkList(head,100);
    insertHead_doubleLinkList(head,100);
    show_doubleLinkLit(head);

    insertTail_doubleLinkList(head,200);
    insertTail_doubleLinkList(head,300);
    insertTail_doubleLinkList(head,400);
    insertTail_doubleLinkList(head,500);
    show_doubleLinkLit(head);

    insertbyPos_doubleLinkList(head,666,2);
    insertbyPos_doubleLinkList(head,666,6);
    show_doubleLinkLit(head);

    deletebyhead_doubleLinkList(head);
    deletebyhead_doubleLinkList(head);
    deletebyhead_doubleLinkList(head);
    show_doubleLinkLit(head);

    deletebyTail_doubleLinkList(head);
    deletebyTail_doubleLinkList(head);
    show_doubleLinkLit(head);

    deletebyPos_doubleLinkList(head,2);
    deletebyPos_doubleLinkList(head,4);
    show_doubleLinkLit(head);




    return 0;                                          
}

.h函数：

 #ifndef DOUBLE_H_
 #define DOUBLE_H_
 
 typedef int dataType;
 union msg
 {   
     dataType data;
     int len;
 };
 
 typedef struct node
 {   
     union msg text;
     struct node* next;
     struct node* prev;
 }doubleLinkList;
 
 doubleLinkList* create_doubleLinkList();
 void insertHead_doubleLinkList(doubleLinkList* head,dataType num);
 void show_doubleLinkLit(doubleLinkList* head); 
 void insertTail_doubleLinkList(doubleLinkList* head,int num);
 void insertbyPos_doubleLinkList(doubleLinkList* head,int num,int pos);
 void deletebyhead_doubleLinkList(doubleLinkList* head);
 void deletebyTail_doubleLinkList(doubleLinkList* head);
 void deletebyPos_doubleLinkList(doubleLinkList* head,int pos);          
 
 
 #endif

运行结果：

单向循环：

func.c：

#include <stdio.h>
#include <stdlib.h>
#include "./d221.h"
linkList* loop_LinkList()
{
    linkList* head=(linkList*)malloc(sizeof(linkList));

    if(head==NULL)
    {
        printf("头结点创建失败\n");
        return NULL;
    }

    head->text.len=0;
    head->next=head;

    return head;                                                                                                                                                                                                                       
}

//判断链表是否为空
int isEmpty_linkList(linkList* head)
{
    return head->next == head?1:0;
}
//遍历链表
void show_linkList(linkList* head)
{
    linkList* p = head;
    while(p->next != head)
    {
        p=p->next;
        printf("%d ",p->text.data);
    }
    printf("\n");
    return;
}
//头插法
dataType insert_linkList(linkList* head,int num)
{
    linkList* temp = (linkList*)malloc(sizeof(linkList));

    if(temp==NULL)
    {
        printf("结点创建失败\n");
        return -1;
    }

    temp->text.data=num;
    temp->next=NULL;

    temp->next=head->next;
    head->next=temp;

    head->text.len++;

    return 0;
}

//尾插
void insertTail_linkList(linkList* head,int num)
{
    linkList* temp = (linkList*)malloc(sizeof(linkList));

    if(temp==NULL)
    {
        printf("结点创建失败\n");
        return;
    }

    temp->text.data=num;
    temp->next=NULL;

    linkList* p = head;
    while(p->next != head)
    {
        p=p->next;
    }

    temp->next=head;
    p->next=temp;

    head->text.len++;
}

//头删
dataType deleteHead_linkList(linkList* head)
{
    //判断链表是否为空
    if(isEmpty_linkList(head)==1)
    {
        printf("链表为空，无法删除\n");
    }

    linkList* temp = head->next;
    head->next = temp->next;

    dataType num = temp->text.data;
    free(temp);
    temp = NULL;

    head->text.len--;

    return num;
}

//尾删
void deleteTail_linkList(linkList* head)
{
    //判断链表是否为空
    if(isEmpty_linkList(head))
    {
        printf("链表为空，无法删除\n");
    }

    linkList* temp = head;

    while(temp->next->next !=head)
    {
        temp=temp->next;
    }

    free(temp->next);
    temp->next=head;

    head->text.len--;

    return ;
}

//按位置插入 
void insertbyPos_linkList(linkList* head,int num,int pos)
{
    linkList* temp = (linkList*)malloc(sizeof(linkList));

    if(temp==NULL)
    {
        printf("结点创建失败\n");
        return;
    }

    temp->text.data=num;
    temp->next=NULL;

    linkList* p =head;
    for(int i=0;i<pos-1;i++)
    {
        if(p->next==NULL)
        {
            p->next=temp;
            temp->next=head;
        }
        p=p->next;
    }

    temp->next=p->next;
    temp->text.data=num;
    p->next=temp;
    head->text.len++;

    return;
}

//按位置删除
void deletebyPos_linkList(linkList* head,int pos)
{
    //判断链表是否为空
    if(isEmpty_linkList(head))
    {
        printf("链表为空，无法删除\n");
    }

    linkList* p = head;
    for(int i=0;i<pos-1;i++)
    {
        if(p->next==head)
        {
            p->next=head;
        }
        p=p->next;
    }

    linkList* q=p->next;

    p->next=q->next;
    q=NULL;
    free(q);
    head->text.len--;

    return ;
}

main.c：

#include <stdio.h>
#include "./d221.h"

int main(int argc, const char *argv[])
{
    linkList* head =  loop_LinkList();
    insert_linkList(head,10);
    insert_linkList(head,20);
    insert_linkList(head,30);
    show_linkList(head);

    insertTail_linkList(head,3);
    insertTail_linkList(head,4);
    insertTail_linkList(head,5);
    insertTail_linkList(head,6);
    show_linkList(head);

    deleteHead_linkList(head);
    deleteHead_linkList(head);
    deleteHead_linkList(head);
    show_linkList(head);

    deleteTail_linkList(head);
    deleteTail_linkList(head);
    show_linkList(head);
                                         
    insertbyPos_linkList(head,66,1);
    insertbyPos_linkList(head,77,3);
    insertbyPos_linkList(head,88,4);
    show_linkList(head);

    deletebyPos_linkList(head,1);
    show_linkList(head);





    return 0;
}

.h函数：

#ifndef LINK_H_
#define LINK_H_
typedef int dataType;

union msg{
    dataType data;
    int len;
};

typedef struct node{
    union msg text;
    struct node* next;
}linkList;

linkList* loop_LinkList();
dataType insert_linkList(linkList* head,int num);
void show_linkList(linkList* head);
void insertTail_linkList(linkList* head,int num);         
dataType deleteHead_linkList(linkList* head);
void deleteTail_linkList(linkList* head);
void insertbyPos_linkList(linkList* head,int num,int pos);
void deletebyPos_linkList(linkList* head,int pos);


#endif

运行结果：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1471101.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

opengles 绘制图元 ——glDrawArrays() 相关API介绍 (十)

opengles 绘制图元 ——glDrawArrays() 相关API介绍 (十)

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言一、opengles3.0 绘制图元介绍二、绘图图元 API 介绍1. glDrawArrays()1.1 glDrawArrays()函数原型1.2 GL_TRIANGLES, GL_TRIANGLE_STRIP, GL_TRIANGLE_FAN 三者的区别1.3 使用GL_TRIANGLES, G…
阅读更多...
微信小程序 wxs内联与外联的写法

微信小程序 wxs内联与外联的写法

内联写法 <!-- 内联wxs --> <view>大写字母{{m1.toUpper("xmly")}}</view> <wxs module"m1">module.exports.toUpperfunction(str){return str.toUpperCase()} </wxs> 外联写法 新建一个wxs文件 写一个函数&#xff0c;将…
阅读更多...
【k8s】-- 查询 pod 磁盘容量

【k8s】-- 查询 pod 磁盘容量

命令&#xff1a;kubectl get pvc -n 你的namespace --context上下文命名 -o wide 举例&#xff1a;kubectl get pvc -n my-bigdata --contextprod-6 -o wide
阅读更多...
HarmonyOS服务卡片开发指导(Stage模型)概述

HarmonyOS服务卡片开发指导(Stage模型)概述

服务卡片概述 服务卡片&#xff08;以下简称“卡片”&#xff09;是一种界面展示形式&#xff0c;可以将应用的重要信息或操作前置到卡片&#xff0c;以达到服务直达、减少体验层级的目的。卡片常用于嵌入到其他应用&#xff08;当前卡片使用方只支持系统应用&#xff0c;如桌…
阅读更多...
多输入分类|WOA-CNN|鲸鱼算法优化的卷积神经网络分类预测(Matlab)

多输入分类|WOA-CNN|鲸鱼算法优化的卷积神经网络分类预测(Matlab)

目录 一、程序及算法内容介绍&#xff1a; 基本内容&#xff1a; 亮点与优势&#xff1a; 二、实际运行效果&#xff1a; 三、部分程序&#xff1a; 四、完整程序数据下载&#xff1a; 一、程序及算法内容介绍&#xff1a; 基本内容&#xff1a; 本代码基于Matlab平台编译&…
阅读更多...
免编程经验，搭建宠物店小程序轻松实现

免编程经验，搭建宠物店小程序轻松实现

在如今的互联网时代&#xff0c;小程序商城已成为各行业推广和销售的热门方式。对于花店来说&#xff0c;搭建一个自己的小程序商城不仅可以提升品牌形象&#xff0c;还可以方便顾客在线选购花卉产品。下面就来教大家如何轻松搭建一个花店小程序商城&#xff0c;并通过引流获得…
阅读更多...
WiFi又演进了，这次是WiFi 7

WiFi又演进了，这次是WiFi 7

现在很多笔记本laptop、电视TV、手机Phone，甚至车机IVI都有了WiFi和蓝牙BT的接入功能。 不管WiFi、蓝牙BlueTooth、NBIoT、ZigBee等等无线的技术、无线通信模块的技术，其本质都是在无线频谱上以某种频段某种调制方式传输某个协议的数据进行通信，所以通信标准的演进就决定着…
阅读更多...
webGL开发的软件项目类型

webGL开发的软件项目类型

WebGL&#xff08;Web Graphics Library&#xff09;作为一种强大的JavaScript API&#xff0c;能够在Web浏览器中实现2D和3D图形的渲染&#xff0c;适用于开发多种类型的软件项目。以下是WebGL可以开发的一些软件项目类型&#xff0c;希望对大家有所帮助。北京木奇移动技术有限…
阅读更多...
QT GUI编程常用控件学习

QT GUI编程常用控件学习

1 GUI编程应该学什么 2 QT常用模块结构 QtCore: 包含了核心的非GUI的功能。主要和时间、文件与文件夹、各种数据、流、URLs、mime类文件、进程与线程一起使用 QtGui: 包含了窗口系统、事件处理、2D图像、基本绘画、字体和文字类 QtWidgets: 包含了一些列创建桌面应用的UI元素…
阅读更多...
k8s笔记26--快速实现prometheus监控harbor

k8s笔记26--快速实现prometheus监控harbor

k8s笔记26--快速实现prometheus监控harbor 简介采集指标&配置grafana面板采集指标配置grafana面板 说明 简介 harbor是当前最流行的开源容器镜像仓库项目&#xff0c;被大量IT团队广泛应用于生产、测试环境的项目中。本文基于Harbor、Prometheus、Grafana介绍快速实现监控…
阅读更多...
【大数据】Flink SQL 语法篇（四）：Group 聚合、Over 聚合

【大数据】Flink SQL 语法篇（四）：Group 聚合、Over 聚合

Flink SQL 语法篇&#xff08;四&#xff09;&#xff1a;Group 聚合、Over 聚合 1.Group 聚合1.1 基础概念1.2 窗口聚合和 Group 聚合1.3 SQL 语义1.4 Group 聚合支持 Grouping sets、Rollup、Cube 2.Over 聚合2.1 时间区间聚合2.2 行数聚合 1.Group 聚合 1.1 基础概念 Grou…
阅读更多...
Java学习笔记------多态

Java学习笔记------多态

什么是多态 同类型的对象&#xff0c;表现出的不同形态 多态的表现形式 父类类型 对象名称子类对象&#xff1b; 多态的前提 有继承关系 有父类引用指向子类对象 有方法重写 多态调用成员的特点 变量调用&#xff1a;编译看左边&#xff0c;运行也看左边 方法调用&am…
阅读更多...
力扣LCR 140. 训练计划 II（顺序遍历，快慢指针）

力扣LCR 140. 训练计划 II（顺序遍历，快慢指针）

Problem: LCR 140. 训练计划 II 文章目录 题目描述思路复杂度Code 题目描述 思路 思路1&#xff1a;顺序遍历 欲返回倒数第cnt个节点则需要顺序遍历到len-cnt&#xff08;其中len为链表的长度&#xff09; 思路2&#xff1a;快慢指针 让一个快指针fast指向cnt 1个节点&#x…
阅读更多...
Spring ReflectionUtils 反射工具介绍和使用

Spring ReflectionUtils 反射工具介绍和使用

一、ReflectionUtils 在 Java 中&#xff0c;反射&#xff08;Reflection&#xff09;是一种强大的机制&#xff0c;允许程序在运行时动态地检查类、获取类的信息、调用类的方法、访问或修改类的属性等。Java 的反射机制提供了一组类和接口&#xff0c;位于 java.lang.reflect…
阅读更多...
python爬取网站内容写入xls

python爬取网站内容写入xls

目标 现需要对下面网站资源进行爬取&#xff0c;文学人物-名人明星网 获取人物名字获取人物头像获取人物简介 资源获取 通过requests库&#xff0c;我们可以让 Python 程序向浏览器一样向 Web 服务器发起请求&#xff0c;并接收服务器返回的响应&#xff0c;从响应中我们就…
阅读更多...
Python爬虫-爬取B站番剧封面

Python爬虫-爬取B站番剧封面

本文是本人最近学习Python爬虫所做的小练习。如有侵权&#xff0c;请联系删除。 页面获取url 代码 import requests import os import re# 创建文件夹 path os.getcwd() /images if not os.path.exists(path):os.mkdir(path)# 当前页数 page 1 # 总页数 total_page 2# 自动…
阅读更多...
【文生视频】Diffusion Transformer：OpenAI Sora 原理、Stable Diffusion 3 同源技术

【文生视频】Diffusion Transformer：OpenAI Sora 原理、Stable Diffusion 3 同源技术

文生视频 Diffusion Transformer&#xff1a;Sora 核心架构、Stable Diffusion 3 同源技术 提出背景输入输出生成流程变换器的引入Diffusion Transformer (DiT)架构Diffusion Transformer (DiT)总结 OpenAI Sora 设计思路阶段1: 数据准备和预处理阶段2: 架构设计阶段3: 输入数据…
阅读更多...
sql-labs第46关（order by盲注脚本）

sql-labs第46关（order by盲注脚本）

一、环境 网上有自己找 二、解释 order by 注入我们看他的true和false来进行注入出来 二、实操 让我们用sort 看看源码 最终我们的id是放到order by后面了 如果我们直接用列去排序 ?sortusername/password username&#xff1a; password&#xff1a; 可以看到顺序是不…
阅读更多...
云原生之容器编排实践-ruoyi-cloud项目部署到K8S：MySQL8

云原生之容器编排实践-ruoyi-cloud项目部署到K8S：MySQL8

背景 前面搭建好了 Kubernetes 集群与私有镜像仓库&#xff0c;终于要进入服务编排的实践环节了。本系列拿 ruoyi-cloud 项目进行练手&#xff0c;按照 MySQL &#xff0c; Nacos &#xff0c; Redis &#xff0c; Nginx &#xff0c; Gateway &#xff0c; Auth &#xff0c;…
阅读更多...
【数据库】MySQL视图 | 用户管理

【数据库】MySQL视图 | 用户管理

文章目录 1 :peach:视图:peach:1.1 :apple:基本使用:apple:1.1.1 :lemon:创建视图:lemon:1.1.2 :lemon:案例:lemon:1.1.3 :lemon:删除视图:lemon: 1.2 :apple:视图规则和限制:apple: 2 :peach:用户管理:peach:2.1 :apple:用户信息:apple:2.2 :apple:创建用户:apple:2.3 :apple:…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023