3/12/24交换排序、插入排序、选择排序、归并排序

news2024/11/22 16:31:04

目录

交换排序

冒泡排序

快速排序

插入排序

直接插入排序

选择排序

简单选择排序

堆排序

归并排序

各种排序的时间复杂度、空间复杂度、稳定性和复杂度

快排真题2016

选排真题2022

排序算法分为交换类排序、插入类排序、选择类排序、归并类排序。

交换排序

交换排序分为：冒泡排序、快速排序。

冒泡排序

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef int ElemType;
typedef struct {
    ElemType *elem;//存储元素的起始地址
    int TableLen;//元素个数
} SSTable;

void ST_Init(SSTable &ST, int len) {
    ST.TableLen = len;
    ST.elem = (ElemType *) malloc(sizeof(ElemType) * ST.TableLen);//申请一块堆空间，当数组来使用
    int i;
    srand(time(NULL));//随机数生成，每一次执行代码就会得到随机的10个元素
    for (i = 0; i < ST.TableLen; i++) {
        ST.elem[i] = rand() % 100;//生成的是0-99之间
    }
}

//打印数组中的元素
void ST_print(SSTable ST) {
    for (int i = 0; i < ST.TableLen; i++) {
        printf("%3d", ST.elem[i]);
    }
    printf("\n");
}


//往往都是用两层循环
//优先去写内层循环，再写外层循环
void BubbleSort(ElemType *A, int n) {
    int i, j;
    bool flag;
    for (i = 0; i < n - 1; i++)//控制的是有序数的数目
    {
        flag = false;
        for (j = 0; j < n - 1 - i; j++)//内层控制比较和交换
        {
            if (A[j] > A[j + 1]) {
                //交换两个元素
                A[j] = A[j] ^ A[j + 1];
                A[j + 1] = A[j + 1] ^ A[j];
                A[j] = A[j + 1] ^ A[j];
                flag = true;
            }
        }
        if (false == flag)//如果一趟比较没有发生任何交换，说明数组有序，提前结束排序
        {
            return;
        }
    }
}

int main() {
    SSTable ST;
    ST_Init(ST, 10);
    ST_print(ST);//随机后的结果打印
    BubbleSort(ST.elem, 10);
    ST_print(ST);//排序后再次打印
    return 0;
}

快速排序

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

typedef int ElemType;
typedef struct {
    ElemType *elem;//存储元素的起始地址
    int TableLen;//元素个数
} SSTable;

void ST_Init(SSTable &ST, int len) {
    ST.TableLen = len;
    ST.elem = (ElemType *) malloc(sizeof(ElemType) * ST.TableLen);//申请一块堆空间，当数组来使用
    int i;
    srand(time(NULL));//随机数生成，每一次执行代码就会得到随机的10个元素
    for (i = 0; i < ST.TableLen; i++) {
        ST.elem[i] = rand() % 100;//生成的是0-99之间
    }
}

//打印数组中的元素
void ST_print(SSTable ST) {
    for (int i = 0; i < ST.TableLen; i++) {
        printf("%3d", ST.elem[i]);
    }
    printf("\n");
}

//快排的核心函数
//挖坑法
int partition(ElemType *A, int low, int high) {
    ElemType pivot = A[low];//拿最左边的作为分割值，并存储下来
    while (low < high) {
        while (low < high && A[high] >= pivot)//从后往前遍历，找到一个比分割值小的
            high--;
        A[low] = A[high];//把比分隔值小的那个元素，放到A[low]
        while (low < high && A[low] <= pivot)//从前往后遍历，找到一个比分割值大的
            low++;
        A[high] = A[low];//把比分隔值大的那个元素，放到A[high],因为刚才high位置的元素已经放到了low位置
    }
    A[low] = pivot;//把分割值放到中间位置，因为左边刚好都比它小，右边都比它大
    return low;//返回分隔值所在的下标
}

void QuickSort(ElemType *A, int low, int high) {
    if (low < high) {
        int pivot_pos = partition(A, low, high);//pivot用来存分割值的位置
        QuickSort(A, low, pivot_pos - 1);//前一半继续递归排好
        QuickSort(A, pivot_pos + 1, high);
    }
}

int main() {
    SSTable ST;
    ST_Init(ST, 10);//初始化
    ST_print(ST);
    QuickSort(ST.elem, 0, 9);//注意这个位置是n-1,也就是9，因为函数里取了high位置的值
    ST_print(ST);
    return 0;
}

插入排序

插入排序分为：直接插入排序、折半插入排序、希尔排序。

直接插入排序

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef int ElemType;
typedef struct {
    ElemType *elem;//整型指针
    int TableLen;
} SSTable;

void ST_Init(SSTable &ST, int len) {
    ST.TableLen = len;//申请10个元素的空间
    ST.elem = (ElemType *) malloc(sizeof(ElemType) * ST.TableLen);
    int i;
    srand(time(NULL));
    for (i = 0; i < ST.TableLen; i++) {
        ST.elem[i] = rand() % 100;//随机了10个数
    }
}

void ST_print(SSTable ST) {
    for (int i = 0; i < ST.TableLen; i++) {
        printf("%3d", ST.elem[i]);
    }
    printf("\n");
}

void InsertSort(ElemType *A, int n) {
    int i, j, insertVal;
    for (i = 1; i < n; i++)//外层控制要插入的数
    {
        insertVal = A[i];//保存要插入的数
        //内层控制比较,j要大于等于0，同时arr[j]大于insertval时，arr[j]位置元素往后覆盖
        for (j = i - 1; j >= 0 && A[j] > insertVal; j--) {
            A[j + 1] = A[j];
        }
        A[j + 1] = insertVal;//把要插入的元素放到对应的位置
    }
}

int main() {
    SSTable ST;
    ST_Init(ST, 10);//申请10个元素空间
    ST_print(ST);//排序前打印
    InsertSort(ST.elem, 10);
    ST_print(ST);//排序后再次打印
    return 0;
}

选择排序

选择排序分为：简单选择排序、堆排序。

简单选择排序

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
typedef int ElemType;
typedef struct{
    ElemType *elem;
    int TableLen;
}SSTable;

void ST_Init(SSTable &ST,int len)//申请空间，并进行随机数生成
{
    ST.TableLen=len;
    ST.elem=(ElemType *)malloc(sizeof(ElemType)*ST.TableLen);
    int i;
    srand(time(NULL));
    for(i=0;i<ST.TableLen;i++)
    {
        ST.elem[i]=rand()%100;
    }
}
void ST_print(SSTable ST)
{
    for(int i=0;i<ST.TableLen;i++)
    {
        printf("%3d",ST.elem[i]);
    }
    printf("\n");
}
void swap(ElemType &a,ElemType &b)
{
    ElemType tmp;
    tmp=a;
    a=b;
    b=tmp;
}

void SelectSort(ElemType* A,int n)
{
    int i,j,min;//min记录最小的元素的下标
    for(i=0;i<n-1;i++)
    {
        min=i;//我们认为i号元素最小
        for(j=i+1;j<n;j++)//找到从i开始到最后的序列的最小值的下标
        {
            if(A[j]<A[min])//当某个元素A[j]小于了最小元素
            {
                min=j;//将下标j赋值给min，min就记录下来了最小值的下标
            }
        }
        if(min!=i)
        {
            //遍历完毕找到最小值的位置后，与A[i]交换，这样最小值被放到了最前面
            swap(A[i],A[min]);
        }
    }
}

int main() {
    SSTable ST;
    ST_Init(ST,10);//初始化
    ST_print(ST);
    SelectSort(ST.elem,10);
    ST_print(ST);
    return 0;
}

堆排序

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

typedef int ElemType;
typedef struct {
    ElemType *elem;
    int TableLen;
} SSTable;

void ST_Init(SSTable &ST, int len)//申请空间，并进行随机数生成
{
    ST.TableLen = len;
    ST.elem = (ElemType *) malloc(sizeof(ElemType) * ST.TableLen);
    int i;
    srand(time(NULL));
    for (i = 0; i < ST.TableLen; i++) {
        ST.elem[i] = rand() % 100;
    }
}

void ST_print(SSTable ST) {
    for (int i = 0; i < ST.TableLen; i++) {
        printf("%3d", ST.elem[i]);
    }
    printf("\n");
}

void swap(ElemType &a, ElemType &b) {
    ElemType tmp;
    tmp = a;
    a = b;
    b = tmp;
}


//调整某个父亲节点，王道书上的
void AdjustDown(ElemType A[], int k, int len) {
    int i;
    A[0] = A[k];
    for (i = 2 * k; i <= len; i *= 2) {
        if (i < len && A[i] < A[i + 1])//左子节点与右子节点比较大小
            i++;
        if (A[0] >= A[i])
            break;
        else {
            A[k] = A[i];
            k = i;
        }
    }
    A[k] = A[0];
}

//用数组去表示树   类似层次建树  王道书上的
void BuildMaxHeap(ElemType A[], int len) {
    for (int i = len / 2; i > 0; i--) {
        AdjustDown(A, i, len);
    }
}

//王道书上的
void HeapSort(ElemType A[], int len) {
    int i;
    BuildMaxHeap(A, len);//建立大顶堆
    for (i = len; i > 1; i--) {
        swap(A[i], A[1]);
        AdjustDown(A, 1, i - 1);
    }
}


//把某个子树调整为大根堆
void AdjustDown1(ElemType A[], int k, int len) {
    int dad = k;//父亲的下标
    int son = 2 * dad + 1;//左孩子的下标
    while (son < len) {//son可能也是最后一个元素，在下面if中判断
        if (son + 1 < len && A[son] < A[son + 1])//如果左孩子小于右孩子
        {
            son++;//拿右孩子
        }
        if (A[son] > A[dad])//如果孩子大于父亲
        {
            swap(A[son], A[dad]);//交换
            dad = son;//son从新作为dad，去判断下面的子树是否符合大根堆
            son = 2 * dad + 1;
        } else {
            break;
        }
    }
}

void HeapSort1(ElemType A[], int len) {
    int i;
    //就是把堆，调整为大根堆
    for (i = len / 2 - 1; i >= 0; i--) {
        AdjustDown1(A, i, len);
    }
    swap(A[0], A[len - 1]);//交换根部元素和最后一个元素
    for (i = len - 1; i > 1; i--)//i代表的是剩余的无序数的数组的长度
    {
        AdjustDown1(A, 0, i);//调整剩余元素变为大根堆
        swap(A[0], A[i - 1]);//交换根部元素和无序数的数组的最后一个元素
    }
}

int main() {
    SSTable ST;
    ST_Init(ST, 10);//初始化
    ElemType A[10] = {3, 87, 2, 93, 78, 56, 61, 38, 12, 40};
    memcpy(ST.elem, A, sizeof(A));
    ST_print(ST);
    //HeapSort(ST.elem, 9);//王道书零号元素不参与排序，考研考的都是零号元素要参与排序
    HeapSort1(ST.elem, 10);//所有元素参与排序
    ST_print(ST);
    return 0;
    return 0;
}

归并排序

#include <stdio.h>
#include <stdlib.h>

#define N 7
typedef int ElemType;
//合并两个有序数组
void Merge(ElemType A[],int low,int mid,int high)
{
    static ElemType B[N];//加static的目的是无论递归调用多少次，都只有一个B[N]
    int i,j,k;
    for(i=low;i<=high;i++)//把A[i]里的元素都给B[i]
    {
        B[i]=A[i];
    }
    k=low;//k=i+j-mid-1
    for(i=low,j=mid+1;i<=mid&&j<=high;)//合并两个有序数组
    {
        if(B[i]<B[j])
        {
            A[k]=B[i];
            i++;
            k++;
        }else{
            A[k]=B[j];
            j++;
            k++;
        }
    }
    //把某一个有序数组中剩余的元素放进来
    while(i<=mid)//前一半的有剩余的放入
    {
        A[k]=B[i];
        i++;
        k++;
    }
    while(j<=high)//后一半的有剩余的放入
    {
        A[k]=B[j];
        j++;
        k++;
    }
}

//归并排序不限制是两两归并，还是多个归并，考研都是考两两归并
void MergeSort(ElemType A[],int low,int high)//递归分割
{
    if(low<high)
    {
        int mid=(low+high)/2;
        MergeSort(A,low,mid);//排序好前一半
        MergeSort(A,mid+1,high);//排序好后一半
        Merge(A,low,mid,high);//讲两个排序好的数组合并
    }
}

void print(int* a)
{
    for(int i=0;i<N;i++)
    {
        printf("%3d",a[i]);
    }
    printf("\n");
}
//归并排序
int main() {
    int A[N]={49,38,65,97,76,13,27};//数组，7个元素
    MergeSort(A,0,6);
    print(A);
    return 0;
}

各种排序的时间复杂度、空间复杂度、稳定性和复杂度

快排真题2016

#include <stdio.h>

//考研初试只需要完成setPartition即可
int setPartition(int a[], int n) {
    int pivotkey, low = 0, low0 = 0, high = n - 1, high0 = n - 1, flag = 1, k = n / 2, i;
    int s1 = 0, s2 = 0;
    while (flag)//当low等于k-1，也就是n/2-1时，分割结束
    {
        pivotkey = a[low]; //选择枢轴
        while (low < high) { //基于枢轴对数据进行划分
            while (low < high && a[high] >= pivotkey)
                --high;
            if (low != high)
                a[low] = a[high];
            while (low < high && a[low] <= pivotkey)
                ++low;
            if (low != high)
                a[high] = a[low];
        } //end of while(low<high)
        a[low] = pivotkey;//把分割值放到对应的位置
        if (low == k - 1)//如果枢轴是第 n/2 小元素，划分成功
        {
            flag = 0;
        } else {//是否继续划分
            if (low < k - 1) {
                low0 = ++low;//low0只是做暂存，为下次使用准备，这里我们++low后，low比分割值大1
                high = high0;//把上次暂存的high0拿过来
            } else {
                low = low0;//把上次暂存的low0拿过来
                high0 = --high;//high0只是做暂存，为下次使用准备
            }
        }
    }
    for (i = 0; i < k; i++) {
        s1 += a[i];
    }
    for (i = k; i < n; i++) {
        s2 += a[i];
    }
    return s2 - s1;
}


int main() {
    int A[10] = {4, 1, 12, 18, 7, 13, 18, 16, 2, 15};
    int difference;
    difference = setPartition(A, 10);//考研初试只需要完成setPartition即可，无需编写这个main函数
    printf("%d\n", difference);
    return 0;
}

选排真题2022

 

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef int ElemType;
typedef struct{
    ElemType *elem;
    int TableLen;
}SSTable;

void ST_Init(SSTable &ST,int len)//申请空间，并进行随机数生成
{
    ST.TableLen=len;
    ST.elem=(ElemType *)malloc(sizeof(ElemType)*ST.TableLen);
    int i;
    srand(time(NULL));
    for(i=0;i<ST.TableLen;i++)
    {
        ST.elem[i]=rand();
    }
}
void ST_print(SSTable ST)
{
    for(int i=0;i<10;i++)
    {
        printf("%3d\n",ST.elem[i]);
    }
    printf("\n");
}
void swap(ElemType &a,ElemType &b)
{
    ElemType tmp;
    tmp=a;
    a=b;
    b=tmp;
}

//调整子树
void AdjustDown(ElemType A[], int k, int len)
{
    int dad = k;
    int son = 2 * dad + 1; //左孩子下标
    while (son<=len)
    {
        if (son + 1 <= len && A[son] < A[son + 1])//看下有没有右孩子，比较左右孩子选大的
        {
            son++;
        }
        if (A[son] > A[dad])//比较孩子和父亲，如果孩子大于父亲，那么进行交换
        {
            swap(A[son], A[dad]);
            dad = son;//孩子重新作为父亲，判断下一颗子树是否符合大根堆
            son = 2 * dad + 1;
        }
        else {
            break;
        }
    }
}
void HeapSort(ElemType A[], int len)
{
    int i;
    //先对前10个元素建立大根堆
    for (i = len/2; i >= 0; i--)
    {
        AdjustDown(A, i, len);
    }
    //比较剩余的A[10]到A[99999]元素，小于堆顶，就放入A[0],继续调整10个元素为大根堆
    for (i = 10; i < 100000; i++)
    {
        if (A[i] < A[0])
        {
            A[0] = A[i];
            AdjustDown(A, 0, 9);//继续调整为大根堆
        }
    }
}

int main()
{
    SSTable ST;
    ST_Init(ST,100000);//初始化
    HeapSort(ST.elem,9);
    ST_print(ST);
    return 0;
}

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

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

相关文章

【智能算法】哈里斯鹰算法（HHO)原理及实现

【智能算法】哈里斯鹰算法（HHO)原理及实现

目录 1.背景2.算法原理2.1算法思想2.2算法过程 3.代码实现4.参考文献 1.背景 2019年&#xff0c;Heidari 等人受到哈里斯鹰捕食行为启发&#xff0c;提出了哈里斯鹰算法(Harris Hawk Optimization, HHO)。 2.算法原理 2.1算法思想 根据哈里斯鹰特性&#xff0c;HHO分为探索-…
阅读更多...
新智元 | Stable Diffusion 3技术报告流出，Sora构架再立大功！生图圈开源暴打Midjourney和DALL·E 3？

新智元 | Stable Diffusion 3技术报告流出，Sora构架再立大功！生图圈开源暴打Midjourney和DALL·E 3？

本文来源公众号“新智元”&#xff0c;仅用于学术分享&#xff0c;侵权删&#xff0c;干货满满。 原文链接&#xff1a;Stable Diffusion 3技术报告流出&#xff0c;Sora构架再立大功&#xff01;生图圈开源暴打Midjourney和DALLE 3&#xff1f; 【新智元导读】Stability AI放…
阅读更多...
chrome浏览器插件content.js和background.js还有popup都是什么，怎么通讯

chrome浏览器插件content.js和background.js还有popup都是什么，怎么通讯

popup 在用户点击扩展程序图标时&#xff08;下图中的下载图标&#xff09;&#xff0c;都可以设置弹出一个popup页面。而这个页面中自然是可以包含运行的js脚本的&#xff08;比如就叫popup.js&#xff09;。它会在每次点击插件图标——popup页面弹出时&#xff0c;重新载入。…
阅读更多...
如何阅读“计算机界三大神书”之一 ——SICP

如何阅读“计算机界三大神书”之一 ——SICP

《计算机程序的构造和解释》&#xff08;Structure and Interpretation of Computer Programs&#xff0c;简记为SICP&#xff09;是MIT的基础课教材&#xff0c;出版后引起计算机教育界的广泛关注&#xff0c;对推动全世界大学计算机科学技术教育的发展和成熟产生了很大影响。…
阅读更多...
plantUML使用指南之序列图

plantUML使用指南之序列图

文章目录 前言一、序列图1.1 语法规则1.1.1 参与者1.1.2 生命线1.1.3 消息1.1.4 自动编号1.1.5 注释1.1.6 其它1.1.7 例子 1.2 如何画好 参考 前言 在软件开发、系统设计和架构文档编写过程中&#xff0c;图形化建模工具扮演着重要的角色。而 PlantUML 作为一种强大且简洁的开…
阅读更多...
springboot265基于Spring Boot的库存管理系统

springboot265基于Spring Boot的库存管理系统

基于Spring Boot库存管理系统 Inventory Meanagement System based on Spring Boot 摘 要 当下&#xff0c;如果还依然使用纸质文档来记录并且管理相关信息&#xff0c;可能会出现很多问题&#xff0c;比如原始文件的丢失&#xff0c;因为采用纸质文档&#xff0c;很容易受潮…
阅读更多...
《vtk9 book》 官方web版 第3章 - 计算机图形基础 （3 / 5）

《vtk9 book》 官方web版 第3章 - 计算机图形基础 （3 / 5）

3.8 演员几何 我们已经看到了光照属性如何控制演员的外观&#xff0c;以及相机如何结合变换矩阵将演员投影到图像平面上。剩下的是定义演员的几何形状&#xff0c;以及如何将其定位在世界坐标系中。 建模 计算机图形学研究中的一个重要主题是建模或表示物体的几何形状。…
阅读更多...
二分查找【详解】

二分查找【详解】

本期介绍&#x1f356; 主要介绍&#xff1a;二分查找的简单思路&#xff0c;为什么必须在有序的前提下才能使用二分查找&#xff0c;该怎么用C程序来实现二分查找&#xff0c;二分查找的局限性&#x1f440;。 文章目录 1. 题目2. 思路3. 前提条件4. 编写程序 1. 题目 在一个有…
阅读更多...
Android Studio开发项目——记账簿应用

Android Studio开发项目——记账簿应用

项目资源&#xff1a; 百度网盘链接&#xff1a;https://pan.baidu.com/s/1zN9lrIypi1t_QpuoBcdBNQ?pwdxj5h 提取码&#xff1a;xj5h 项目设计内容 1.基本功能描述 电子记账本是一种在线财务管理工具&#xff0c;用于帮助用户记录和管理他们的收入与支出。以下是电…
阅读更多...
基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的水果新鲜程度检测系统（深度学习模型+UI界面代码+训练数据集）

基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的水果新鲜程度检测系统（深度学习模型+UI界面代码+训练数据集）

摘要&#xff1a;开发水果新鲜程度检测系统对于提高农业产量和食品加工效率具有重大意义。本篇博客详细介绍了如何利用深度学习构建一个水果新鲜程度检测系统&#xff0c;并提供了完整的实现代码。该系统基于强大的YOLOv8算法&#xff0c;并结合了YOLOv7、YOLOv6、YOLOv5的对比…
阅读更多...
ChatGPT 结合实际地图实现问答式地图检索功能基于Function calling

ChatGPT 结合实际地图实现问答式地图检索功能基于Function calling

ChatGPT 结合实际地图实现问答式地图检索功能基于Function calling ChatGPT结合实际业务&#xff0c;主要是研发多函数调用&#xff08;Function Calling&#xff09;功能模块&#xff0c;将自定义函数通过ChatGPT 问答结果&#xff0c;实现对应函数执行&#xff0c;再次将结果…
阅读更多...
打卡学习kubernetes——了解kubernetes组成及架构

打卡学习kubernetes——了解kubernetes组成及架构

目录 1 什么是kubernetes 2 kubernetes组件 3 kubernetes架构 1 什么是kubernetes kubernetes是一个旨在自动部署、扩展和运行应用容器的开源平台。目标是构建一个生态系统&#xff0c;提供组件和工具以减轻在公共和私有云中运行应用程序的负担。 kubernetes是&#xff1a…
阅读更多...
基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的跌倒检测系统详解（深度学习模型+UI界面代码+训练数据集）

基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的跌倒检测系统详解（深度学习模型+UI界面代码+训练数据集）

摘要&#xff1a;本研究介绍了一个基于深度学习和YOLOv8算法的跌倒检测系统&#xff0c;并对比分析了包括YOLOv7、YOLOv6、YOLOv5在内的早期版本性能。该系统可在多种媒介如图像、视频文件、实时视频流中准确识别跌倒事件。文内详解了YOLOv8的工作机制&#xff0c;并提供了相应…
阅读更多...
一套plm系统大约多少钱？彩虹PLM系统

一套plm系统大约多少钱？彩虹PLM系统

一套PLM&#xff08;产品生命周期管理&#xff09;系统的价格因多个因素而异&#xff0c;包括企业规模、需求复杂性、系统功能、技术支持和厂商选择等。一般来说&#xff0c;面向小型和微型企业的PLM产品&#xff0c;其价位在5万元~15万元左右&#xff1b;面向中型企业的中端PL…
阅读更多...
STM32---通用定时器（二）相关实验

STM32---通用定时器（二）相关实验

写在前面&#xff1a;前面我们学习了基本定时器、通用定时器的相关理论部分&#xff0c;了解到通用定时器的结构框图&#xff0c;总共包含六大模块&#xff1a;时钟源、控制器、时基单元、输入捕获、公共部分以及输出捕获。对相关模块的使用也做详细的讲解。本节我们主要是对上…
阅读更多...
力扣刷题日记——L724. 寻找数组的中心下标

力扣刷题日记——L724. 寻找数组的中心下标

1. 前言 今天是力扣刷题日记的第二天&#xff0c;今天依旧是一道简单题啊&#xff0c;慢慢来&#xff0c;先看看题目是什么吧。 2. 题目描述 给你一个整数数组 nums &#xff0c;请计算数组的 中心下标。 数组 中心下标 是数组的一个下标&#xff0c;其左侧所有元素相加的和…
阅读更多...
数据结构入门（3）顺序表和链表

数据结构入门（3）顺序表和链表

1.线性表 线性表&#xff08;linear list&#xff09;是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使 用的数据结构&#xff0c;常见的线性表&#xff1a;顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构&#xff0c;也就说是连续的一条直…
阅读更多...
汤唯短发造型：保留经典和适合自己的风格，也许才是最重要的

汤唯短发造型：保留经典和适合自己的风格，也许才是最重要的

汤唯短发造型&#xff1a;保留经典和适合自己的风格&#xff0c;也许才是最重要的 汤唯短发造型登上Vogue四月刊封面&#xff0c;引发网友热议。#李秘书讲写作#说说是怎么回事&#xff1f; 这次Vogue四月刊的封面大片&#xff0c;汤唯以一头短发亮相&#xff0c;身穿五颜六色的…
阅读更多...
Python笔记：函数

Python笔记：函数

Python函数定义规则&#xff1a; 函数代码块以def关键词开头&#xff0c;后接函数标识符名称和圆括号()。任何传入参数和自变量必须放在圆括号中间&#xff0c;圆括号之间可以用于定义参数。return [表达式] 结束函数&#xff0c;选择性地返回一个值给调用方&#xff0c;不带表…
阅读更多...
力扣（LeetCode）142.环形链表 II

力扣（LeetCode）142.环形链表 II

本博客讲解一道以前大厂面试常考的链表oj题 ——————————————————————— 题目介绍&#xff1a; 给定一个链表的头节点 head &#xff0c;返回链表开始入环的第一个节点。 如果链表无环&#xff0c;则返回 null。 如果链表中有某个节点&#xff0c;可以通…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023