北京邮电大学计算机学院大一下计导课链表作业——链表排序、匹配、交换、归并、拆分

已于 2022-04-07 00:31:09 修改
阅读量2.2k 收藏 14
点赞数 6
文章标签： 算法 数据结构 链表 c++
于 2022-04-04 00:00:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59924193/article/details/123947406
版权

写给后来者

亲爱的北京邮电大学计算机学院的学妹/学弟们：


​ 如果你看到了这篇博客，很有可能的是你在做大一下学期的第一次计算机导论作业。没错，以我对学院这个破OJ的了解，这份作业还会存在很多年，祸害造福一代又一代的北邮人。你们中的大部分人也许会和我们中的大部分人一样，苦恼地来csdn上搜索可用的C代码，于是我特地大慈大悲地贡献出我的代码，留待一年或数年后的诸君发掘。

by AryCra_07

免责声明：该项作业会记入最后考核成绩中，因此禁止一切形式的抄袭行为。博主享有本代码的所有著作权，欢迎你采纳我的思路并改写我的烂代码。

题干

A题

B题
C题
D题
E题
F题

代码

//A
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int n, Array[10100];

struct node{ //链表结点
    int data;
    struct node *next;
    int min , max , total;
};

//创建链表（关键函数）
struct node *create(int Array[], int n) {
    struct node *p, *pre, *head; //pre保存当前结点的前驱结点，head是头结点
    head = (struct node *) malloc(sizeof(struct node)); //创建头结点
    head->next = NULL; //头结点不需要数据域，指针域初始为NULL
    head->min = 0x3f3f3f3f;
    head->max = -1;
    head->total = 0;
    pre = head; //记录pre为head
    for (int i = 0; i < n; ++i) {
        p = (struct node *) malloc(sizeof(struct node)); //新建结点
        //将Array[i]赋给新建的结点作为数据域，也可以scanf输入
        p->data = Array[i];
        p->next = NULL; //新结点的指针域设为NULL
        p->max = p->data > pre->max ? p->data : pre->max;
        p->min = p->data < pre->min ? p->data : pre->min;
        p->total = p->data + pre->total;
        pre->next = p; //前驱结点的指针域设为当前结点的地址
        pre = p; //把当前结点赋值给pre，作为下一个结点的前驱结点
    }
    head->max = pre->max;
    head->min = pre->min;
    head->total = pre->total;
    return head; //返回头结点指针
}

int main() {
    int x = 0, i = 0;
    while (1) {
        scanf("%d", &x);
        if (x == -1)
            break;
        Array[i++] = x;
    }
    struct node *L = create(Array, i); //L是头结点

    printf("The maximum,minmum and the total are:%d %d %d ", L->max, L->min, L->total);


    return 0;
}


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

typedef struct node {
    int data;
    struct node *next;
    int cnt;
} Node;

Node *create() {
    Node *head, *cur, *last, *emptyHead = NULL;
    int x = 0, y = 0;
    emptyHead = (Node *) malloc(sizeof(Node));
    head = (Node *) malloc(sizeof(Node));
    emptyHead->data = 0;
    emptyHead->cnt = 0;
    emptyHead->next = head;
    scanf("%d", &x);
    head->data = x;
    last = head;
    while (~scanf("%d", &x)) {
        if (x == -1) {
            break;
        }
        cur = (Node *) malloc(sizeof(Node));
        cur->data = x;
        cur->next = NULL;
        cur->cnt = last->cnt + 1;
        last->next = cur;
        last = cur;
    }
    last->next = NULL;
    emptyHead->cnt = last->cnt;

    return emptyHead;
}

void print(Node *head) {
    int i = 0, j = 0, k = 0;
    Node *p = head;
    printf("The new list is:");
    while (p->next != NULL) {
        printf("%d ", p->next->data);
        p = p->next;
    }
}

void sort(Node *head) {
    Node *cur = NULL, *pre = NULL, *last = NULL, *temp = NULL;
    while (last != head->next) {
        temp = head;
        cur = head->next->next;
        pre = head->next;
        while (pre->next != last) {
            if (pre->data > cur->data) {
                pre->next = cur->next;
                temp->next = cur;
                cur->next = pre;
            } else {
                pre = pre->next;
            }
            cur = pre->next;
            temp = temp->next;
        }
        last = pre;
    }
}

int main() {
    Node *head = create();
    sort(head);
    print(head);
    return 0;
}

//C
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

int n, Array[10100];

typedef struct node{ //链表结点
    int data;
    struct node *next;
    int min , max , total;
}Node;

//创建链表（关键函数）
struct node *create(int Array[], int n) {
    struct node *p, *pre, *head; //pre保存当前结点的前驱结点，head是头结点
    head = (struct node *) malloc(sizeof(struct node)); //创建头结点
    head->next = NULL; //头结点不需要数据域，指针域初始为NULL
    head->min = 0x3f3f3f3f;
    head->max = -1;
    head->total = 0;
    pre = head; //记录pre为head
    for (int i = 0; i < n; ++i) {
        p = (struct node *) malloc(sizeof(struct node)); //新建结点
        //将Array[i]赋给新建的结点作为数据域，也可以scanf输入
        p->data = Array[i];
        p->next = NULL; //新结点的指针域设为NULL
        p->max = p->data > pre->max ? p->data : pre->max;
        p->min = p->data < pre->min ? p->data : pre->min;
        p->total = p->data + pre->total;
        pre->next = p; //前驱结点的指针域设为当前结点的地址
        pre = p; //把当前结点赋值给pre，作为下一个结点的前驱结点
    }
    head->max = pre->max;
    head->min = pre->min;
    head->total = pre->total;
    return head; //返回头结点指针
}
void jg(Node *first, Node *second) {
    Node *nowA = first->next, *nowB = second->next, *hereA = first->next;
    while (hereA!=NULL && nowB != NULL) {
        if(hereA->data == nowB->data) {
            hereA = hereA->next;
            nowB = nowB->next;
        } else{
            nowA = nowA->next;
            hereA = nowA;
            nowB = second->next;
        }
    }
    if(nowB == NULL) {
        printf("ListB is the sub sequence of ListA.");
    } else{
        printf("ListB is not the sub sequence of ListA.");
    }
}

void Del(Node *A) {
    Node* start = NULL, *end = A;
    while (end->next != NULL) {
        start = end;
        end =end->next;
        free(start);
    }
}
void bubbleSort(int a[], int n){
    for(int i = 0; i < n-1; ++i)  //遍历n-1次
        for(int j = 0; j < n-i-1; ++j)  //j小于的就是越来越小的递归边界，不过为什么是n-i-1而不是n-i呢
            if(a[j]>a[j+1]){
                int tmp = a[j];
                a[j] = a[j+1];
                a[j+1] = tmp;  //如果你熟悉c++，可以调用swap函数来交换数字。
            }
}

int main() {
    int x = 0, i = 0;
    while (1) {
        scanf("%d", &x);
        if (x == -1)
            break;
        Array[i++] = x;
    }
    struct node *A = create(Array, i); //L是头结点
    memset(Array, 0, sizeof Array);
    x = 0, i = 0;
    while (1) {
        scanf("%d", &x);
        if (x == -1)
            break;
        Array[i++] = x;
    }
    struct node *B = create(Array, i);
    jg(A, B);
    Del(A);
    Del(B);
    return 0;
}

//D
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

int n, Array[10100];

typedef struct node { //链表结点
    int data;
    struct node *next;
    int min, max, total;
} Node;

//创建链表（关键函数）
struct node *create(int Array[], int n) {
    struct node *p, *pre, *head; //pre保存当前结点的前驱结点，head是头结点
    head = (struct node *) malloc(sizeof(struct node)); //创建头结点
    head->next = NULL; //头结点不需要数据域，指针域初始为NULL
    head->min = 0x3f3f3f3f;
    head->max = -1;
    head->total = 0;
    pre = head; //记录pre为head
    for (int i = 0; i < n; ++i) {
        p = (struct node *) malloc(sizeof(struct node)); //新建结点
        //将Array[i]赋给新建的结点作为数据域，也可以scanf输入
        p->data = Array[i];
        p->next = NULL; //新结点的指针域设为NULL
        p->max = p->data > pre->max ? p->data : pre->max;
        p->min = p->data < pre->min ? p->data : pre->min;
        p->total = p->data + pre->total;
        pre->next = p; //前驱结点的指针域设为当前结点的地址
        pre = p; //把当前结点赋值给pre，作为下一个结点的前驱结点
    }
    head->max = pre->max;
    head->min = pre->min;
    head->total = pre->total;
    return head; //返回头结点指针
}

void jg(Node *first, Node *second) {
    Node *nowA = first->next, *nowB = second->next, *hereA = first->next;
    while (hereA != NULL && nowB != NULL) {
        if (hereA->data == nowB->data) {
            hereA = hereA->next;
            nowB = nowB->next;
        } else {
            nowA = nowA->next;
            hereA = nowA;
            nowB = second->next;
        }
    }
    if (nowB == NULL) {
        printf("ListB is the sub sequence of ListA.");
    } else {
        printf("ListB is not the sub sequence of ListA.");
    }
}

void Del(Node *A) {
    Node *start = NULL, *end = A;
    while (end->next != NULL) {
        start = end;
        end = end->next;
        free(start);
    }
}

void bubbleSort(int a[], int n) {
    for (int i = 0; i < n - 1; ++i)  //遍历n-1次
        for (int j = 0; j < n - i - 1; ++j)  //j小于的就是越来越小的递归边界，不过为什么是n-i-1而不是n-i呢
            if (a[j] > a[j + 1]) {
                int tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;  //如果你熟悉c++，可以调用swap函数来交换数字。
            }
}

void swapList(Node *A, int l1, int r1, int l2, int r2) {
    Node *fL = A, *fR = A, *sL = A, *sR = A;
    while (--l1)
        fL = fL->next;
    while (r1--)
        fR = fR->next;
    while (--l2)
        sL = sL->next;
    while (r2--)
        sR = sR->next;
    Node *tmp = fL->next;
    fL->next = sL->next;
    sL->next = tmp;
    Node *tmp1 = fR->next;
    fR->next = sR->next;
    sR->next = tmp1;
}

void swap(Node *A, Node *B) {
    Node *tmp;
    tmp = A;
    A = B;
    B = tmp;
}

int main() {
    int x = 0, i = 0;
    int l1, r1, l2, r2;
    while (1) {
        scanf("%d", &x);
        if (x == -1)
            break;
        Array[i++] = x;
    }
    scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
    struct node *A = create(Array, i); //L是头结点
    swapList(A, l1, r1, l2, r2);
    printf("The new list is:");
    A = A->next; //从第一个结点开始才有数据域
    while (A != NULL) {
        if (A->next != NULL)
            printf("%d ", A->data);
        else
            printf("%d\n", A->data);
        A = A->next;
    }
    return 0;
}

//E
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "ctype.h"


typedef struct node { //链表结点
    int data;
    struct node *next;
    int cnt;
} Node;

Node *create() {
    int x = 0;
    Node *p, *pre, *head; //pre保存当前结点的前驱结点，head是头结点
    head = (Node *) malloc(sizeof(Node)); //创建头结点
    head->next = NULL; //头结点不需要数据域，指针域初始为NULL
    head->cnt = 0;
    pre = head; //记录pre为head
    while (1) {
        scanf("%d", &x);
        if (x == -1) break;
        p = (Node *) malloc(sizeof(Node));; //新建结点
        //将Array[i]赋给新建的结点作为数据域，也可以scanf输入
        p->data = x;
        p->next = NULL; //新结点的指针域设为NULL
        pre->next = p; //前驱结点的指针域设为当前结点的地址
        pre = p; //把当前结点赋值给pre，作为下一个结点的前驱结点
    }
    return head; //返回头结点指针
}



void sort(Node *headA, Node *headB) {
    Node *temp = headB, *temp2 = headB, *first1 = headA->next, *first2 = headB->next, *pre1 = headA;
    while (first1 != NULL && first2 != NULL) {
        if (first2->data < first1->data) {
            temp2 = first2->next;
            pre1->next = first2;
            pre1 = first2;
            first2->next = first1;
            first2 = temp2;
        } else if (first1->data == first2->data) {
            temp->next = first2;
            temp = first2;
            first2=first2->next;
            pre1 = first1;
            first1 = first1->next;
        } else {
            pre1 = first1;
            first1 = first1->next;
        }
    }
    if (first2 != NULL) {
        pre1->next = first2;
    }
    //headB->next = NULL;
    temp->next = NULL;

}


void print(Node *A, Node *B) {
    if (A->next == NULL) {
        printf("There is no item in A list.\n");
    } else {
        printf("The new list A:");
        A = A->next;
        while (A != NULL) {
            if (A->next != NULL)
                printf("%d ", A->data);
            else
                printf("%d\n", A->data);
            A = A->next;
        }
    }

    if (B->next == NULL) {
        printf("There is no item in B list.\n");
    } else {
        printf("The new list B:");
        B = B->next;
        while (B != NULL) {
            if (B->next != NULL)
                printf("%d ", B->data);
            else
                printf("%d\n", B->data);
            B = B->next;
        }
    }
}

int main() {
    Node *A = create();
    Node *B = create();
    sort(A, B);
    print(A, B);
    return 0;
}

//F
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "ctype.h"


typedef struct node { //链表结点
    char data;
    struct node *next;
    int cnt;
} Node;

//创建链表（关键函数）
struct node *create() {
    struct node *p, *pre, *head; //pre保存当前结点的前驱结点，head是头结点
    head = (struct node *) malloc(sizeof(struct node)); //创建头结点
    head->next = NULL; //头结点不需要数据域，指针域初始为NULL
    head->cnt = 0;
    pre = head; //记录pre为head
    while (1) {
        char x[5];
        scanf(" %s", x);
        if (x[0] == '-' && x[1] == '1') {
            break;
        }
//        printf("%s I fuck you\n",x);
        p = (Node *) malloc(sizeof(Node));
        p->cnt = pre->cnt + 1;
        p->data = x[0];
        p->next = NULL;
//        printf("%c I fuck you\n",p->data);
        pre->next = p;
        pre = p;
    }
    head->cnt = p->cnt;
    return head; //返回头结点指针
}

void SortYourMother(Node *head) {
    Node *current = NULL, *previous = NULL, *last = NULL, *temp = NULL;
    if (head->next == NULL) {
        return;
    }
    while (last != head->next)//保证能正确退出循环，并且每一次都从head开始排序同时避免了成员<2的情况
    {
        temp = head;
        current = head->next->next;
        previous = head->next;
        while (previous->next != last)//这里避免了成员<3的情况
        {
            if (previous->data > current->data) {
                temp->next = current;//这一步相当于把成员一的next指向了成员三的地址
                previous->next = current->next;//这一步可以看做把成员二的next指向了三成员的next所指向的地址（成员四所在的地址）
                current->next = previous;//这把成员三的next指向了成员二所在的地址
            } else {
                previous = previous->next;//这一步没写在下面和上面是为了保证在碰到更大的数之后让pre-next连接着目前最小的数字
            }
            current = previous->next;
            temp = temp->next;
        }
        last = previous;
    }
}

void fuckYouCProgram(Node *L) {
    if (L->cnt == 0) {
        printf("There is no item in A list.");
        printf("There is no item in B list.");
        printf("There is no item in C list.");
        return;
    } else {
        Node *A, *B, *C, *preA, *pA, *preB, *pB, *preC, *pC;
        int cntA, cntB, cntC;
        A = (Node *) malloc(sizeof(Node));
        B = (Node *) malloc(sizeof(Node));
        C = (Node *) malloc(sizeof(Node));
        A->next = NULL;
        B->next = NULL;
        C->next = NULL;
        A->cnt = B->cnt = C->cnt = 0;
        preA = A;
        preB = B;
        preC = C;
        while (L->next != NULL) {
            L = L->next;
            char c = L->data;
            if (isalpha(c)) {
                pA = (Node *) malloc(sizeof(Node));
                pA->data = L->data;
                pA->cnt = preA->cnt + 1;
                pA->next = NULL;
                preA->next = pA;
                preA = pA;
            } else if (isdigit(c)) {
                pB = (Node *) malloc(sizeof(Node));
                pB->data = L->data;
                pB->cnt = preB->cnt + 1;
                pB->next = NULL;
                preB->next = pB;
                preB = pB;
            } else {
                pC = (Node *) malloc(sizeof(Node));
                pC->data = L->data;
                pC->cnt = preC->cnt + 1;
                pC->next = NULL;
                preC->next = pC;
                preC = pC;
            }
        }
        int sbA = preA->cnt;
        int sbB = preB->cnt;
        int sbC = preC->cnt;
        SortYourMother(A);
        SortYourMother(B);
        SortYourMother(C);
        if (sbA) {
            printf("The list A is: ");
            A = A->next;
            while (A != NULL) {
                if (A->next != NULL)
                    printf("%c ", A->data);
                else
                    printf("%c\n", A->data);
                A = A->next;
            }
        } else {
            printf("There is no item in A list.\n");
        }
        if (sbB) {
            printf("The list B is: ");
            B = B->next;
            while (B != NULL) {
                if (B->next != NULL)
                    printf("%c ", B->data);
                else
                    printf("%c\n", B->data);
                B = B->next;
            }
        } else {
            printf("There is no item in B list.\n");
        }
        if (sbC) {
            printf("The list C is: ");
            C = C->next;
            while (C != NULL) {
                if (C->next != NULL)
                    printf("%c ", C->data);
                else
                    printf("%c\n", C->data);
                C = C->next;
            }
        } else {
            printf("There is no item in C list.\n");
        }
    }
}


void Del(Node *A) {
    Node *start = NULL, *end = A;
    while (end->next != NULL) {
        start = end;
        end = end->next;
        free(start);
    }
}


int main() {
    Node *L = create();
    fuckYouCProgram(L);
    return 0;
}

向前，向前，向前。

AryCra_07
关注
  • 6
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
北邮计算机导论实验.rar
08-02
2015北邮计算导论与程序设计实验要求，计算机学院专用，总计十一个实验，C语言入门实验
java课程作业+北邮+OJ+已通过+黑杰克
06-02
北邮java课程作业OJ黑杰克，已AC
北邮java oj
linkcoder的博客
05-31 291
oj作业
校外如何登陆北邮oj
热门推荐
我是一块小石头
11-27 1万+
由于北邮oj不对外开放，准备复试的我需要进入北邮oj；其他小朋友也有这个想法。故写此博客。 先找北邮土著借北邮账号，包括一些认识的同学，直系学长学姐，他们都很乐意帮助的~ 下面是校外进北邮校内网的方法，做到第三步就可以了。（有些关键词屏蔽了，我发不出来） https://nic.bupt.edu.cn/content/content.php?p=5_13_337 然后右上角url填写再进入...
北邮java oj 1052 问题 B: 复数
linkcoder的博客
05-20 269
后边为n行，每行均为4个用空格分隔的浮点数，依次参与运算的两个复数c1、c2。第一个数代表c1的实部，第二个数代表c1的虚部，第三个数代表c2的实部，第四个数代表c2的虚部。编写ComplexDivException类，该类继承Exception类，且至少包含两个数据成员，一个为错误代码，一个为错误信息。前边的1001为错误代码，后边Divide by zero. 为错误信息。编写复数类，该类至少包括计算复数的加法、减法、乘法、除法的方法。第二行为一个整数n(0<n<100)，代表共n组测试用例。
北邮2019计导下 链表二 A. 实验11_9_链表归并
A land whole of flowers.
03-21 3121
这题有些奇怪，前8组很顺利，第9组数据死活过不了，提示运行时错误。找老师拿来了测试数据，不论是手动输入、freopen重定向还是geeksforgeeks的ide，结果都没有任何问题，不知道怎么回事。 如果有学习过归并排序的朋友应该会对这个操作有些熟悉。类似于merge，但是相同的元素保留在原来的线性表中。 思路 设计lowerBound函数，其用途是，对于一个给定的数key，找出链表A中不大于k...
JavaScript实现链表插入排序和链表归并排序
10-21
主要介绍了JavaScript实现链表插入排序和链表归并排序,较为详细的分析了插入排序和归并排序,对于学习JavaScript数据结构具有一定参考借鉴价值,需要的朋友可以参考下。
C语言数据结构 链表与归并排序实例详解
08-31
主要介绍了C语言数据结构 链表与归并排序实例详解的相关资料,需要的朋友可以参考下
C语言中数据结构之链表归并排序实例代码
08-30
主要介绍了C语言中数据结构之链表归并排序实例代码的相关资料,需要的朋友可以参考下
山东建筑大学 计算机科学与技术学院《数据结构》实验一：单循环链表的基本操作
03-31
1、定义单循环链表类型并动态创建使用tail指向尾结点的单循环链表（有头结点）； 2、实现单循环链表的取元素、插入、删除、索引元素位置号等操作以及迭代器； 3、实现输出单循环链表中各元素值的操作； 4、将单循环...
[BUPT]北京邮电大学计算机导论课件.zip
04-09
北京邮电大学计算机导论与程序设计基础的课件，涵盖一学期内课程知识点，仅供各位学习交流使用，请勿私自打印外传，严禁用作商业用途
北邮计算机18级《计算机导论》ppt.rar
01-05
北邮 18级 计算机学院，计算机导论 课件ppt
计算机导论与程序设计：第12章 链表.ppt
09-17
计算机导论与程序设计：第12章 链表.ppt
北邮计导大作业外卖订单派送系统.rar
08-08
北邮计导大作业2019年 由北邮大一的三人小组完成，是一个非常简陋的外卖订单派送系统。具体的要求在压缩文件中有一个PPT做具体说明。除此之外还有写代码时参考到的一些PPT学习资源。 虽然写得非常非常菜，但是对于三个小白来说（不是谦虚），能拿到95分的成绩也实属不易。或许可以给学弟学妹们做一些参考？（误。 若是有什么问题可联系作者，微信号：liushi32992 github地址：https://github.com/liushiliushi/BUPT1
北京邮电大学大一计导复习精华 .pdf
04-11
仅供各位交流学习使用，严禁用作商业用途，严禁发生抄袭等学术不端行为！
北邮java oj作业1
Rosie___的博客
09-04 649
记录java选修课作业
北邮计算机导论与程序设计——大一下——大作业——模拟快递问题（待解决）；
qq_43665101的博客
04-13 1994
老师给我们布置了这么一个问题，要求用C实现。大家有什么好的策略吗（虽然老师提示了一些，但还是想问问大家有没有更好的解决办法）？ 小菜鸡给大家鞠一躬了！ /* 小组里就我和另外俩妹子，感觉有点悬，所以大佬能说一下大致的思路吗？效率高的那一种； 谢谢啦！ */ 课程要求 • 你运行一家外卖快递服务店,负责一个区域内的外卖订单接收和餐食快递.你有一笔启动资金,可以招募外卖骑手帮你送餐,来赚取快...
北邮2021计导大作业丨C语言实现冯诺依曼式计算机CPU模拟器（二）：多核版
yufanwenshu的博客
06-18 979
北邮2021计导大作业的第二部分，多核版cpu模拟器。
北邮oj题库刷题计划（更新ing）
cherish的技术博
01-15 2884
北邮oj题库刷题计划（更新ing）83. A + B Problem84 Single Number 83. A + B Problem Calculate the sum of two given integers A and B. 输入格式 The input consists of a line with A and B. (−104≤A,B≤104). 输出格式 Output the on...
链表自底向上归并排序
最新发布
02-23
链表自底向上归并排序是一种排序算法，用于对链表进行排序。它的基本思想是将链表拆分成多个长度为1的子链表，然后两两合并这些子链表，再将合并后的链表继续两两合并，直到最终得到一个有序的链表。 具体步骤如下： 1. 将原始链表拆分成多个长度为1的子链表。 2. 两两合并相邻的子链表，得到新的有序链表。 3. 重复步骤2，直到只剩下一个链表。 在每一次合并的过程中，可以利用归并排序的思想，比较两个子链表的节点值，并按照从小到大的顺序进行合并。最终得到的链表就是排好序的结果。 链表自底向上归并排序的时间复杂度为O(nlogn)，其中n是链表的长度。这是因为每次合并操作都需要遍历整个链表，而总共需要进行logn次合并操作。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AryCra_07

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值