精华内容
下载资源
问答
  • 在一个长度为n的单链表
    2022-03-17 13:52:54

    import java.util.*;

    /*
     * public class ListNode {
     *   int val;
     *   ListNode next = null;
     * }
     */

    public class Solution {
        /**
         * 
         * @param head ListNode类 
         * @param x int整型 
         * @return ListNode类
         */
        
        public ListNode partition(ListNode head, int x) {
            // write code here
            if (head == null) {
                return null;
            }
            if (head.next == null) {
                return head;
            }
            ListNode node = head;
            ListNode nodes = new ListNode(-1);
            ListNode nodeb = new ListNode(-1);
            ListNode firstnode = nodes;
            ListNode lastnode = nodeb;
            while (node != null) {
                if (node.val < x) {
                    ListNode node1 = node;
                    nodes.next = node1;
                    nodes = nodes.next;
                } else {
                    ListNode node2 = node;
                    nodeb.next = node2;
                    nodeb = nodeb.next;
                }
                node = node.next;
            }
            nodeb.next = null;
            nodes.next = lastnode.next;
            head = firstnode.next;
            return head;
        }

    }

    更多相关内容
  • 链表基础1(超简单)--创建一个长度为n单链表

    千次阅读 多人点赞 2020-10-30 11:00:55
    那么每个铁环就可以叫做一个节点,如果我们再每个铁环上面系上两个个小盒子,那么这两个小盒子一个叫做数据域就是存放每个节点数据的地方一个叫做指针域这个就是存放下一个节点(铁环)地址的地方。可能这样说还...

    首先我们来了解一下什么是链表?
    通俗的来说链表就是一种链式存储结构,大家可以抽象理解一下把他想象成一个铁链,铁链不是由一个个铁环,环环相扣组成的嘛!那么每个铁环就可以叫做一个节点,如果我们再在每个铁环上面系上两个个小盒子,那么这两个小盒子一个叫做数据域就是存放每个节点数据的地方一个叫做指针域这个就是存放下一个节点铁环)地址的地方。可能这样说还有点抽象,直接上图。
    在44444这里插入图片描述
    这就是链表里面一个节点的样子,下面我们给多个节点串起来形成链表!
    在这里插入图片描述
    我给每个节点的地址设为A,B,C。注意看第一个节点的指针域存放的是第二个节点的地址B,第二个节点的指针域存放的是第三个节点的地址。这样就把每个节点就穿一起咯,这就是最简单的链表,单链表。
    下面我们看一下代码实现
    先看一个节点的表示:

    typedef struct lianbiao
    {
            int date;//数据域
            struct lianbiao *pnext;//地址域
    }link;
    

    然后我们要做的就是像铁环一样给串起来,上代码:

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct lianbiao
    {
            int date;
            struct lianbiao *pnext;
    }link;
    link *pnew;//新节点
    link *phead;//头节点
    link *ptemp;//临时节点
    int count=1;
    void creat(void);
    void add(void);
    int main()
    {
        int n,i;
        printf("请输入所需要创建的链表长度,不可为0\n");
        scanf("%d", &n);
        creat();
        for(i=0;i<n-1;i++)
        {
            add();
        }
      printf("链表创建完毕,输出链表所有数据\n");
    
      //printf("%d ", phead->date);
      for(ptemp=phead;ptemp!=NULL;ptemp=ptemp->pnext)
       {
           printf("%d ", ptemp->date);
       }
       return 0;
    }
    void creat(void)//创建头节点
    {
        phead=(link*)malloc(sizeof(link));
        phead->pnext=NULL;
        phead->date=0;
        //memset(link,0,sizeof(link));
    }
    void add(void)//添加节点
    {
        pnew=(link*)malloc(sizeof(link));
        pnew->date=count;
        pnew->pnext=0;
        ptemp=phead;
        while(ptemp->pnext!=NULL)
        {
            ptemp=ptemp->pnext;
        }
        ptemp->pnext=pnew;
        //pnew=NULL;
        count++;
    }
    
    

    运行结果:
    在这里插入图片描述
    如有问题可以在评论区或者私信我!感谢评阅,欢迎指正交流。
    链表基础2(超简单)–单链表的插入和删除
    链表基础3(超简单)–单链表的逆序

    展开全文
  • #include<iostream> using namespace std; typedef struct lnode { int data; struct lnode *next;...L,int n) { lnode *r; L=new lnode; L->next=NULL; r=L; for(int i=0;i<n;i++)
    #include<iostream>
    using namespace std;
    
    typedef struct lnode
    {
        int data;
        struct lnode *next;
    }lnode,*LinkList;
    
    void CreateList(LinkList &L,int n)
    {
        lnode *r;
        L=new lnode;
        L->next=NULL;
        r=L;
        for(int i=0;i<n;i++)
        {
            lnode *p;
            p=new lnode;
            cin>>p->data;
            p->next=NULL;
            r->next=p;
            r=p;
        }
    }
    void maxLnode(LinkList &L)
    {
            int maxNumber=L->next->data;
            lnode *p;
            p=L->next;
            while(p)
            {
                if(p->data>maxNumber)
                {
                    maxNumber=p->data;
                }else{
                p=p->next;
                }
            }
            cout<<maxNumber;
    }
    
    int main()
    {
        LinkList LA;
        int n;
        cout<<"请输入链表LA的长度:";
        cin>>n;
        cout<<"请输入链表LA的元素:";
        CreateList(LA,n);
        cout<<"单链表中最大的结点是:";
        maxLnode(LA);
        return 0;
    }
    
    
    展开全文
  • 通过趟遍历确定长度为n单链表中值最大的节点(用C语言实现)

    此题为课本p51页,算法题第6题

    目录

    一、定义结构体

    二、用尾插法创建单链表

    三、遍历单链表,找出最大的值得节点得位置,并输出该节点保存得数据

    四、设计一下,实现一下这个遍历和输出最大的节点

    五、完整代码

    六、运行测试一下


    一、定义结构体

    typedef struct LNode
    {
        int data;
        struct LNode* next;
    } LNode;

    二、用尾插法创建单链表

    LNode* CreateAtTail(int a[], int n)
    {
        int i;
        LNode* first, * s, * r;
        first = (LNode*)malloc(sizeof(LNode));
        first->next = NULL;
        r = first;
        for (i = 0; i < 5; i++)
        {
            s = (LNode*)malloc(sizeof(LNode));
            s->data = a[i];
            r->next = s;
            r = s;
        }
        r->next = NULL;
        return first;
    }

    三、遍历单链表,找出最大的值得节点得位置,并输出该节点保存得数据

    void COMList(LNode* first)
    {
        LNode *p;
        int max = 0;
        int count = 1;
        int i = 0;
        int biaoji = 1;
        p = first->next;
        max = p->data;
        while (p != NULL)
        {
            i++;
            if (p->data > max)
            {
                max = p->data;
                count = count + i - biaoji;
                biaoji = i;
            }  
            p = p->next;
        }
        printf("单链表中值最大的节点为第 %d 个值为 %d ", count, max);
    }

     还有就是p=p->next为什么放到if条件句下面,如果放到,上面的话,比较到最后,p成为了NULL,而这时,再用p->data和max比较时,就没有这个节点了,怎么比较。

    还有我这个代码,其实把第一个元素也比较了一遍,其实这一步没有必要,因为肯定不会比初始max,也就是第一个本身大吧。(但是目前我没想出来怎么改)

    yes!

    想到了

    代码如下,就是把循环条件改了一下(这里不改的话,只改if的话,p->next又会出现上面空指针的情况),if条件句的条件改了一下,max的值改了一下。大家可以理解一下。

    不会的留言问我呀~

    void COMList(LNode* first)
    {
        LNode *p;
        int max = 0;
        int count = 1;
        int i = 1;
        int biaoji = 1;
        p = first->next;
        max = p->data;
        while (p->next != NULL)
        {
            i++;
            if (p->next->data > max)
            {
                max = p->next->data;
                count = count + i - biaoji;
                biaoji = i;
            }
            
            p = p->next;
        }
        printf("单链表中值最大的节点为第 %d 个值为 %d ", count, max);
    }

     

    其中这里还有比较难理解的一点就是那个count的运算:

    常见的错误就是,直接count++,这样的算出来的结果肯定是不对的,就比如输入五个数(这里我测试的是链表长度为5,都为整型),1 3 2 5 4,这里,if条件句,会把2隔过去,这样count就会少加1,等等,类似的情况,看表长和表的数据,少加2,3....等等。

    正解就是,用i来记录比较到第几个数,再用biaoji这个变量记录上次p->data大于max的情况时的第biaoji个位置,再用i-biaoji加到count上即可,比如,上个例子,1 3 2 5 4,3的位置为2,5的位置为4,这样4-2=2,count+2即可,就不会少加一个,把位置给算错了。

    再举一个例子比如,1 2 2 2 5,第一次进入时是第一个2的位置为2,第2个2,第三个2都进不去,到5,位置为5,相差5-2=3,这样count+3就行了,就不会少加了。

    如果不理解,再举一个例子,1 2 3 4 5,1进不去,第一个进入的是2,位置为2,3进去,位置为3,count+3-2,就是count+1就行了。

    四、设计一下,实现一下这个遍历和输出最大的节点

    int main()
    {
        LNode* first;
        int a[5];
        int i = 0;
        int count = 0;
        printf("请输入5个数,进行初始化链表:\n");
        for (i = 0; i < 5; i++)
        {
            scanf_s("%d", &a[i]);
        }
        first = CreateAtTail(a, 5);
        COMList(first);
        return 0;
    }

    五、完整代码

    #define _CRT_SECURE_NO_WARNINGS 1
    #include <stdio.h>
    
    typedef struct LNode
    {
        int data;
        struct LNode* next;
    } LNode;
    
    
    void COMList(LNode* first)
    {
        LNode *p;
        int max = 0;
        int count = 1;
        int i = 0;
        int biaoji = 1;
        p = first->next;
        max = p->data;
        while (p != NULL)
        {
            i++;
            if (p->data > max)
            {
                max = p->data;
                count = count + i - biaoji;
                biaoji = i;
            }
            
            p = p->next;
        }
        printf("单链表中值最大的节点为第 %d 个值为 %d ", count, max);
    }
    LNode* CreateAtTail(int a[], int n)
    {
        int i;
        LNode* first, * s, * r;
        first = (LNode*)malloc(sizeof(LNode));
        first->next = NULL;
        r = first;
        for (i = 0; i < 5; i++)
        {
            s = (LNode*)malloc(sizeof(LNode));
            s->data = a[i];
            r->next = s;
            r = s;
        }
        r->next = NULL;
        return first;
    }
    int main()
    {
        LNode* first;
        int a[5];
        int i = 0;
        int count = 0;
        printf("请输入5个数,进行初始化链表:\n");
        for (i = 0; i < 5; i++)
        {
            scanf_s("%d", &a[i]);
        }
        first = CreateAtTail(a, 5);
        COMList(first);
        return 0;
    }

    六、运行测试一下

     

     

     有错误请指正~

    不会的不理解的评论留言问我呀~

    大家快去试一下这个代码!

    展开全文
  • #include <iostream> using namespace std; typedef int ElemType; typedef struct LNode { ElemType data; //结点的数据域 struct LNode *next; //结点的指针域 }LNode,*LinkList; //LinkList...
  • //遍历查找长度为n单链表的最大值的结点 #include<iostream> using namespace std; typedef int Status; typedef int elemtype; #define OK 1 #define ERROR 0 typedef struct LNode { elemtype data; ...
  • 单链表元素最大值max 通过遍历元素,与最大值max作比较,将较大值附给max 输出最大值max 算法: /* *title:P53页程序设计第6题 *writer:weiyuexin *data:2020-9-26 */ #include<iostream> using ...
  • 建立长度为n单链表n>0,删除单链表中等于给定值的元素。数据类型指定整型。 c语言作业题,这里学的不太清楚,请各位家人指点指点~
  • 链表基础1(超简单)–创建一个长度为n单链表 链表基础2(超简单)–单链表的插入和删除 链表基础3(超简单)–单链表的逆序 首先我们来理解一下什么是双向链表,话不多说上图: head是头节点地址,a1、a2分别是...
  • 在长度为n的( )上,删除第一个结点,其算法的时间复杂度O(n)。 A.只有表头指针的不带表头结点的循环单链表。B.只有表尾指针的不带表头结点的循环单链表。C.只有表尾指针的带表头结点的循环单链表。D.只有表头...
  • 什么带有尾节点的链表删除最后一个元素的时间复杂度是o(n)
  • #include <stdio.h> #include <malloc.h> typedef struct SNode { // 数据域 int data; // 指针域 ...// 初始化一个链表 PNode init_list(); // 插入元素 bool insert(PNode, int, int); /
  • int n = 1; while (head != null) { ListNode node1 = new ListNode(head.val); if (n ) { node.next = node1; n++; } else { node1.next = node.next; node.next = node1; } head = head.next; } head = node.next...
  • 输入格式: 第行为链表长度n; 第二行为链表中的n数据元素的值; 第三行为需要删除的元素值。 输出格式: 输出删除后的链表中的所有数据元素的值。 输入样例: 4 45 12 34 8 34 输出样例: 45 12 8
  • 在长度为n的()上,删除第一个元素,其算法的时间复杂度O(n) A.只有表头指针的不带表头结点的循环单链表 B.只有表尾指针的不带表头结点的循环单链表 C.只有表尾指针的带表头结点的循环单链表 D.只有表头指针的带...
  • 单链表长度的操作很简单,其实初始化赋值或遍历那块就可以实现,但是为了让结构层次独立清楚,我还是把求长度写成了一个函数。 单链表插入的关键部分如下:(本质上还是遍历) int seqlistlength(Link head)
  • 单链表长度(C语言)

    千次阅读 2022-05-03 22:03:55
    // 求链表长度 // 定义链表类型 typedef struct Node { int data; struct Node *next; }Node,*LinkList; // 初始化 LinkList initList () { LinkList L = (Node *) malloc (sizeof(Node)); L->next = NULL;...
  • printf(" (3) 计算链表长度并输出单链表\n"); printf(" (4) 查找值x的直接前驱结点并输出其值\n"); printf(" (5) 删除节点值x的结点\n"); printf(" (6) 逆置单链表结点\n"); printf(" (7) 单链表奇偶...
  • C++创建一个简单的单链表

    千次阅读 2021-02-28 14:40:21
    创建一个节点的类模板头文件 #pragma once //节点类模板 //节点类模板的数据成员包括数据域和指针域 template<class datatype> class node { public : datatype data;//数据域 node<datatype>* next;/...
  • 问题描述:已知两个长度分别m 和 n 的升序链表,若将它们合并为一个长度为 m+n 的降序链表,则最坏情况下的时间复杂度是(D) A.O(n) B.O(m*n) C.O(min(m,n)) D.O(max(m,n)) 解题思路: 首先,无论是什么样子...
  • 单链表长度

    万次阅读 多人点赞 2017-05-18 17:34:58
    #include #include typedef struct linknode { int data; linknode *next; } Node,*Linklist;...Linklist CreateList_end(int n);//尾插法建立链表 void ShowList(Linklist L);//输出链表内容 int Link
  • 将两个有序单链表合并为一个有序单链表

    千次阅读 多人点赞 2019-08-01 14:45:28
    将两个有序单链表合并为一个有序单链表 //完整代码段 #include<stdio.h> #include<stdlib.h> typedef struct LNode{ int data; struct LNode* next; }LNode; LNode* Createlist(int length)//尾插法...
  • #include <iostream> using namespace std; //定义存储 typedef struct LNode { int date; struct LNode *next; } Lnode, *Linklist; //链表初始化 ... //头节点置空 } //输出数据 void output(Li
  • 一个带头结点的单链表 L,设计一个算法使其元素递增有序。
  • 数据结构:求单链表(有头节点)长度

    万次阅读 2019-03-13 15:29:26
    - 单链表长度求法与顺序表不同(顺序表有现成的函数length()),下面是求单链表长度的两种方法。 方法: Status Length_L(LinkList L,int &amp;e) { LinkList p=L-&gt;next;//定义头指针 int j=1;//...
  • typedef struct { Elemtype data[Max]; int length; }SqList; typedef struct LNode { Elemtype data; struct LNode *next; }LNode,*LinkList; LinkList convert(SqList L) { LinkList A=(LNode*)...n;i++) { .
  • 2个单链表的合并

    千次阅读 2022-04-09 13:43:50
    1、已知L1和L2分别指向两个单链表的头结点,其长度分别m和n。试写算法将这两链表连接一起形成L3,请分析你的算法的时间复杂度。(要求将长的单链表短的后面,并且要求空间复杂度o(1)。) 函数接口定义...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 50,921
精华内容 20,368
热门标签
关键字:

在一个长度为n的单链表

友情链接: moni.zip