精华内容
下载资源
问答
  • 从倒数第一到正数第一
    2021-05-25 07:18:36

    【申明:本文仅限于自我归纳总结和相互交流,有纰漏还望各位指出。 联系邮箱:Mr_chenping@163.com】

    题目:输入一个单向链表,输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针。 链表结点定义如下:

    typedef struct _list_node

    {

    int key;

    struct _list_node *next;

    }list_node;

    题目分析:

    解法一、先计算链表中总节点个数N,然后循环遍历N-k+1次(排除带头结点的情况)。

    解法二、两个指针p,q同时指向头结点,让一个指针p先走k步,然后两个指针同时循环遍历链表,当p到达尾节点的时候,返回q即可。

    算法实现:(解法二)

    #include

    #include

    typedef struct _list_node

    {

    int key;

    struct _list_node *next;

    }list_node;

    void *list_insert(list_node *head, int key)

    {

    list_node *p = head;

    while(p->next != NULL)

    p = p->next;

    list_node *node = calloc(1, sizeof(list_node));

    node->key = key;

    node->next = NULL;

    p->next = node;

    }

    list_node * list_return_node_by_key(list_node *head, int index)

    {

    list_node * re = head->next;

    list_node * p = head;

    /*让返回节点指针先走index步*/

    int i=0;

    for(; i

    p = p->next;

    /*遍历链表,当@l为NULL的时候@re刚好指向倒数第K个节点*/

    while(p->next != NULL)

    {

    p = p->next;

    re = re->next;

    }

    return re;

    }

    int main(int argc, char *argv[])

    {

    list_node *head = calloc(1, sizeof(list_node));

    head->key = 0;

    head->next = NULL;

    list_insert(head, 1);

    list_insert(head, 2);

    list_insert(head, 3);

    list_insert(head, 4);

    list_insert(head, 5);

    list_node *node = list_return_node_by_key(head, 3);

    printf("node->key = %d\n", node->key);

    return 0;

    }

    更多相关内容
  • JAVA获得某个数字的最后几位是什么的方法,比如,1234567890,则获得最后三位,则返回8/*** 获得数字(正数倒数)几位是什么的方法。** @author 老紫竹研究室(laozizhu.com)**/public class Test {// 字典,...

    JAVA获得某个数字的最后第几位是什么的方法,比如,1234567890,则获得最后第三位,则返回8

    /**

    * 获得数字(正数和倒数)第几位是什么的方法。

    *

    * @author 老紫竹研究室(laozizhu.com)

    *

    */

    public class Test {

    // 字典,里面保存的是1,10,100,1000..直到long的最大允许位数

    private static final long[] NUMBERS = new long[19];

    static {

    NUMBERS[0] = 1;

    for (int i = 1; i < 19; i++) {

    NUMBERS[i] = NUMBERS[i - 1] * 10;

    }

    }

    public static void main(String[] args) {

    long number = 1234567890123456789L;

    System.out.println("测试取得倒数第几位");

    System.out.println(getNumberAtLast(number, 3));

    System.out.println(getNumberAtLast2(number, 3));

    System.out.println(getNumberAtLast3(number, 3));

    int total = 1000000;

    long begin = System.nanoTime();

    for (int i = 0; i < total; i++) {

    getNumberAtLast(number, 3);

    }

    System.out.println("getNumberAtLast =" + (System.nanoTime() - begin));

    begin = System.nanoTime();

    for (int i = 0; i < total; i++) {

    getNumberAtLast2(number, 3);

    }

    System.out.println("getNumberAtLast2=" + (System.nanoTime() - begin));

    begin = System.nanoTime();

    for (int i = 0; i < total; i++) {

    getNumberAtLast3(number, 3);

    }

    System.out.println("getNumberAtLast3=" + (System.nanoTime() - begin));

    System.out.println("测试取得正数第几位");

    System.out.println(getNumberAtFirst(number, 3));

    System.out.println(getNumberAtFirst2(number, 3));

    begin = System.nanoTime();

    for (int i = 0; i < total; i++) {

    getNumberAtFirst(number, 3);

    }

    System.out.println("getNumberAtFirst =" + (System.nanoTime() - begin));

    begin = System.nanoTime();

    for (int i = 0; i < total; i++) {

    getNumberAtFirst2(number, 3);

    }

    System.out.println("getNumberAtFirst2=" + (System.nanoTime() - begin));

    }

    /**

    * 获得数字的倒数第几位是什么

    *

    * @param number

    * 数字

    * @param index

    * 位置

    * @return 位置上的数字,如果超过了则返回0

    */

    public static int getNumberAtLast(long number, int index) {

    for (; index > 1; index--) {

    number /= 10;

    }

    return (int) (number % 10);

    }

    /**

    * 用字符串的方式进行获得。

    *

    * @param number

    * 数字

    * @param index

    * 位置

    * @return 位置上的数字,如果超过了则返回0

    */

    public static int getNumberAtLast2(long number, int index) {

    String str = Long.toString(number);

    if (str.length() < index) {

    return 0;

    }

    return str.charAt(str.length() - index) - 0x30; // 数字0的字符形式

    }

    /**

    * 通过字典查找倒数第几个数字

    *

    * @param number

    * 数字

    * @param index

    * 位置

    * @return 位置上的数字,如果超过了则返回0

    */

    public static int getNumberAtLast3(long number, int index) {

    return (int) ((number / (NUMBERS[index - 1])) % 10);

    }

    /**

    * 通过字典获得数字的正数第几位是什么

    *

    * @param number

    * 数字

    * @param index

    * 位置

    * @return 位置上的数字,如果超过了则返回0

    */

    public static int getNumberAtFirst(long number, int index) {

    int place = getNumberIndex(number);

    number /= NUMBERS[place - index + 1];

    return (int) (number % 10);

    }

    /**

    * 通过字符串获得数字的正数第几位是什么

    *

    * @param number

    * 数字

    * @param index

    * 位置

    * @return 位置上的数字,如果超过了则返回0

    */

    public static int getNumberAtFirst2(long number, int index) {

    String str = Long.toString(number);

    return str.charAt(index - 1) - 0x30; // 数字0的字符形式

    }

    /**

    * 根据字典得到某个数字在long范围内的位置。

    * 比如0-9就在第0位

    * 10-99 就在第1位。

    *

    * @param number

    * 数字

    * @return 位置

    */

    private static final int getNumberIndex(long number) {

    return getNumberIndexR(number, 0, 19);

    }

    /**

    * 简单的二分查找法,查找某个数字在字典中的位置

    *

    * @param number

    * @param left

    * @param right

    * @return

    */

    private static final int getNumberIndexR(long number, int left, int right) {

    if (right <= left + 1) {

    return left;

    }

    int mid = (right - left) / 2 + left;

    if (NUMBERS[mid] > number) {

    return getNumberIndexR(number, left, mid);

    } else {

    return getNumberIndexR(number, mid, right);

    }

    }

    }

    运行结果:

    测试取得倒数第几位

    7

    7

    7

    getNumberAtLast =74142943

    getNumberAtLast2=379321953

    getNumberAtLast3=37117566

    测试取得正数第几位

    3

    3

    getNumberAtFirst =136200830

    getNumberAtFirst2=375250207

    展开全文
  • 输出单链表的倒数第K个结点 分析: 首先如果链表为空,则不存在第K个结点;如果K小于0,则也不存在倒数第K个...等到快的走尾结点的时候,这个时候慢的就走倒数第K个结点。 程序如下: public Node FindKthToT...

    输出单链表的倒数第K个结点

    分析:
    首先如果链表为空,则不存在第K个结点;如果K小于0,则也不存在倒数第K个结点。对于K大于数组长度的也不存在第K个结点。
    接下来是定义两个结点,一个fast,一个slow。既然是求倒数第K个 结点,那么先让快的走K-1步,然后快的和慢的一起走。等到快的走到尾结点的时候,这个时候慢的就走到了倒数第K个结点。
    在这里插入图片描述
    程序如下:

    public Node FindKthToTail(int k) {
            if (this.head == null || k <= 0) {    //k>getLength(),之所以不想把这个判断条件放在if语句里面,原因是不想多遍历一次单链表。在后面按进行判断
                return null;  //倒数第0个结点,就是null
            }
            Node fast = this.head;
            Node slow = this.head;
            while (k - 1 > 0) {  //在此处对k>getLength()进行判断。(隐含的对getLength进行判断)
                if (fast.next != null) {
                    fast = fast.next;
                    k--;
                } else {
                    System.out.println("没有这结点");
                    return null;
                }
            }
            //前提条件是fast.next不为空,这样slow和fast才能一起走
            while (fast.next != null) {
                slow = slow.next;
                fast = fast.next;
            }
            return slow;
        }
    
    展开全文
  • 求单链表倒数第N个数

    2020-12-09 21:51:05
    标尺是一段距离可以用线段的两个端点来衡量,我们能够判断倒数第一个节点,因为他的next==NULL。如果我们用两个指针,并保持他们的距离为n,那么当这个线段的右端指向末尾节点时,左端节点就指向倒数第n个节点。所以...

    昨天我们解决了单链表逆序的问题,同时给出了三种解决方案。今天我们解决另外一个常见面试题:求单链表倒数第N个数。这个问题很有代表性。

    不管是顺数n个还是倒数n个,其实都是距离-标尺问题。标尺是一段距离可以用线段的两个端点来衡量,我们能够判断倒数第一个节点,因为他的next==NULL。如果我们用两个指针,并保持他们的距离为n,那么当这个线段的右端指向末尾节点时,左端节点就指向倒数第n个节点。

    所以思路出来了:建立两个指针,第一个先走n步,然后第2个指针也开始走,两个指针步伐(前进速度)一致。当第一个结点走到链表末尾时,第二个节点的位置就是我们需要的倒数第n个节点的值。

    先让第一个工作结点 firstNode 往前走,走到第 n 步就停下:

    while (i < n && firstNode->next != NULL)

    {

    //正数N个节点,firstNode指向正的第N个节点

    i++;

    firstNode = firstNode->next;

    printf("%d\n", i);

    }

    然后两个节点都开始走。 firstNode 从停下的地方继续走,而 secNode 则是从表头开始走。很明显,当 firstNode 走到表尾的时候,secNode 就正好走到表的倒数第 n 个数了。

    while (firstNode != NULL)

    {

    //查找倒数第N个元素

    secNode = secNode->next;

    firstNode = firstNode->next;

    //printf("secNode:%d\n", secNode->data);

    //printf("firstNode:%d\n", firstNode->data);

    }

    这个是“距离 - 标尺”的典型例子。求整数第 n 个数呢?这个。。。直接看前些天的文章,在同一个专题里。就是查找嘛。

    附完整代码(完整函数在代码里):

    #include "stdio.h"

    #define OK 1

    #define ERROR 0

    #define TRUE 1

    #define FALSE 0

    #define MAXSIZE 20 /* 存储空间初始分配量 */

    typedef int Status;/* Status是函数的类型,其值是函数结果状态代码,如OK等 */

    typedef int ElemType;/* ElemType类型根据实际情况而定,这里假设为int */

    typedef struct Node

    {

    ElemType data;

    struct Node *next;

    }Node;

    /* 定义LinkList */

    typedef struct Node *LinkList;

    /* 初始化顺序线性表 */

    Status InitList(LinkList *L)

    {

    *L=(LinkList)malloc(sizeof(Node)); /* 产生头结点,并使L指向此头结点 */

    if(!(*L)) /* 存储分配失败 */

    {

    return ERROR;

    }

    (*L)->next=NULL; /* 指针域为空 */

    return OK;

    }

    /* 初始条件:顺序线性表L已存在。操作结果:返回L中数据元素个数 */

    int ListLength(LinkList L)

    {

    int i=0;

    LinkList p=L->next; /* p指向第一个结点 */

    while(p)

    {

    i++;

    p=p->next;

    }

    return i;

    }

    /* 初始条件:顺序线性表L已存在。操作结果:将L重置为空表 */

    Status ClearList(LinkList *L)

    {

    LinkList p,q;

    p=(*L)->next; /* p指向第一个结点 */

    while(p) /* 没到表尾 */

    {

    q=p->next;

    free(p);

    p=q;

    }

    (*L)->next=NULL; /* 头结点指针域为空 */

    return OK;

    }

    /* 初始条件:顺序线性表L已存在 */

    /* 操作结果:依次对L的每个数据元素输出 */

    Status ListTraverse(LinkList L)

    {

    LinkList p=L->next;

    while(p)

    {

    visit(p->data);

    p=p->next;

    }

    printf("\n");

    return OK;

    }

    Status visit(ElemType c)

    {

    printf("-> %d ",c);

    return OK;

    }

    /* 初始条件:顺序线性表L已存在,1≤i≤ListLength(L) */

    /* 操作结果:用e返回L中第i个数据元素的值 */

    Status GetElem(LinkList L,int i,ElemType *e)

    {

    int j;

    LinkList p;/* 声明一结点p */

    p = L->next;/* 让p指向链表L的第一个结点 */

    j = 1;/* j为计数器 */

    while (p && j < i) /* p不为空或者计数器j还没有等于i时,循环继续 */

    {

    p = p->next; /* 让p指向下一个结点 */

    ++j;

    }

    if ( !p || j>i )

    return ERROR; /* 第i个元素不存在 */

    *e = p->data; /* 取第i个元素的数据 */

    return OK;

    }

    /* 初始条件:顺序线性表L已存在 */

    /* 操作结果:返回L中第1个与e满足关系的数据元素的位序。 */

    /* 若这样的数据元素不存在,则返回值为0 */

    int LocateElem(LinkList L,ElemType e)

    {

    int i=0;

    LinkList p=L->next;

    while(p)

    {

    i++;

    if(p->data==e) /* 找到这样的数据元素 */

    return i;

    p=p->next;

    }

    return 0;

    }

    /* 随机产生n个元素的值,建立带表头结点的单链线性表L(头插法) */

    void CreateListHead(LinkList *L, int n)

    {

    LinkList p;

    int i;

    srand(time(0)); /* 初始化随机数种子 */

    *L = (LinkList)malloc(sizeof(Node));

    (*L)->next = NULL; /* 先建立一个带头结点的单链表 */

    for (i=0; i < n; i++)

    {

    p = (LinkList)malloc(sizeof(Node)); /* 生成新结点 */

    p->data = rand()%100+1; /* 随机生成100以内的数字 */

    p->next = (*L)->next;

    (*L)->next = p;/* 插入到表头 */

    }

    }

    /* 随机产生n个元素的值,建立带表头结点的单链线性表L(尾插法) */

    void CreateListTail(LinkList *L, int n)

    {

    LinkList p,r;

    int i;

    srand(time(0)); /* 初始化随机数种子 */

    *L = (LinkList)malloc(sizeof(Node)); /* L为整个线性表 */

    r=*L; /* r为指向尾部的结点 */

    for (i=0; i < n; i++)

    {

    p = (Node *)malloc(sizeof(Node)); /* 生成新结点 */

    p->data = rand()%100+1; /* 随机生成100以内的数字 */

    r->next=p; /* 将表尾终端结点的指针指向新结点 */

    r = p; /* 将当前的新结点定义为表尾终端结点 */

    }

    r->next = NULL; /* 表示当前链表结束 */

    }

    /* 初始条件:顺序线性表L已存在,1≤i≤ListLength(L), */

    /* 操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1 */

    Status ListInsert(LinkList *L,int i,ElemType e)

    {

    int j;

    LinkList p,s;

    p = *L; /* 声明一个结点 p,指向头结点 */

    j = 1;

    while (p && j < i) /* 寻找第i个结点 */

    {

    p = p->next;

    ++j;

    }

    if (!p || j > i)

    return ERROR; /* 第i个元素不存在 */

    s = (LinkList)malloc(sizeof(Node)); /* 生成新结点(C语言标准函数) */

    s->data = e;

    s->next = p->next; /* 将p的后继结点赋值给s的后继 */

    p->next = s; /* 将s赋值给p的后继 */

    return OK;

    }

    /* 初始条件:顺序线性表L已存在,1≤i≤ListLength(L) */

    /* 操作结果:删除L的第i个数据元素,并用e返回其值,L的长度减1 */

    Status ListDelete(LinkList *L,int i,ElemType *e)

    {

    int j;

    LinkList p,q;

    p = *L;

    j = 1;

    while (p->next && j < i)/* 遍历寻找第i个元素 */

    {

    p = p->next;

    ++j;

    }

    if (!(p->next) || j > i)

    return ERROR; /* 第i个元素不存在 */

    q = p->next;

    p->next = q->next;/* 将q的后继赋值给p的后继 */

    *e = q->data; /* 将q结点中的数据给e */

    free(q); /* 让系统回收此结点,释放内存 */

    return OK;

    }

    /* 单链表反转/逆序 */

    Status ListReverse(LinkList L)

    {

    LinkList current,pnext,prev;

    if(L == NULL || L->next == NULL)

    return L;

    current = L->next; /* p1指向链表头节点的下一个节点 */

    pnext = current->next;

    current->next = NULL;

    while(pnext)

    {

    prev = pnext->next;

    pnext->next = current;

    current = pnext;

    pnext = prev;

    }

    //printf("current = %d,next = %d \n",current->data,current->next->data);

    L->next = current; /* 将链表头节点指向p1 */

    return L;

    }

    Status ListReverse2(LinkList L)

    {

    LinkList current, p;

    if (L == NULL)

    {

    return NULL;

    }

    current = L->next;

    while (current->next != NULL)

    {

    p = current->next;

    current->next = p->next;

    p->next = L->next;

    L->next = p;

    ListTraverse(L);

    printf("current = %d, \n", current -> data);

    }

    return L;

    }

    Status ListReverse3(LinkList L)

    {

    LinkList newList; //新链表的头结点

    LinkList tmp; //指向L的第一个结点,也就是要摘除的结点

    //参数为空或者内存分配失败则返回NULL

    if (L == NULL || (newList = (LinkList)malloc(sizeof(Node))) == NULL)

    {

    return NULL;

    }

    //初始化newList

    newList->data = L->data;

    newList->next = NULL;

    //依次将L的第一个结点放到newList的第一个结点位置

    while (L->next != NULL)

    {

    tmp = newList->next; //保存newList中的后续结点

    newList->next = L->next; //将L的第一个结点放到newList中

    L->next = L->next->next; //从L中摘除这个结点

    newList->next->next = tmp; //恢复newList中后续结点的指针

    }

    //原头结点应该释放掉,并返回新头结点的指针

    free(L);

    return newList;

    }

    // 获取单链表倒数第N个结点值

    Status GetNthNodeFromBack(LinkList L, int n, ElemType *e)

    {

    int i = 0;

    LinkList firstNode = L;

    while (i < n && firstNode->next != NULL)

    {

    //正数N个节点,firstNode指向正的第N个节点

    i++;

    firstNode = firstNode->next;

    printf("%d\n", i);

    }

    if (firstNode->next == NULL && i < n - 1)

    {

    //当节点数量少于N个时,返回NULL

    printf("超出链表长度\n");

    return ERROR;

    }

    LinkList secNode = L;

    while (firstNode != NULL)

    {

    //查找倒数第N个元素

    secNode = secNode->next;

    firstNode = firstNode->next;

    //printf("secNode:%d\n", secNode->data);

    //printf("firstNode:%d\n", firstNode->data);

    }

    *e = secNode->data;

    return OK;

    }

    int main()

    {

    LinkList L;

    Status i;

    int j,k,pos,value;

    int opp;

    ElemType e;

    i=InitList(&L);

    printf("链表L初始化完毕,ListLength(L)=%d\n",ListLength(L));

    printf("\n1.整表创建(头插法) \n2.整表创建(尾插法) \n3.遍历操作 \n4.插入操作");

    printf("\n5.删除操作 \n6.获取结点数据 \n7.查找某个数是否在链表中 \n8.置空链表");

    printf("\n9.链表反转逆序 \n10.求链表倒数第N个数");

    printf("\n0.退出 \n请选择你的操作:\n");

    while(opp != '0'){

    scanf("%d",&opp);

    switch(opp){

    case 1:

    CreateListHead(&L,10);

    printf("整体创建L的元素(头插法):\n");

    ListTraverse(L);

    printf("\n");

    break;

    case 2:

    CreateListTail(&L,10);

    printf("整体创建L的元素(尾插法):\n");

    ListTraverse(L);

    printf("\n");

    break;

    case 3:

    ListTraverse(L);

    printf("\n");

    break;

    case 4:

    printf("要在第几个位置插入元素?");

    scanf("%d",&pos);

    printf("插入的元素值是多少?");

    scanf("%d",&value);

    ListInsert(&L,pos,value);

    ListTraverse(L);

    printf("\n");

    break;

    case 5:

    printf("要删除第几个元素?");

    scanf("%d",&pos);

    ListDelete(&L,pos,&e);

    printf("删除第%d个元素成功,现在链表为:\n", pos);

    ListTraverse(L);

    printf("\n");

    break;

    case 6:

    printf("你需要获取第几个元素?");

    scanf("%d",&pos);

    GetElem(L,pos,&e);

    printf("第%d个元素的值为:%d\n", pos, e);

    printf("\n");

    break;

    case 7:

    printf("输入你需要查找的数:");

    scanf("%d",&pos);

    k=LocateElem(L,pos);

    if(k)

    printf("第%d个元素的值为%d\n",k,pos);

    else

    printf("没有值为%d的元素\n",pos);

    printf("\n");

    break;

    case 8:

    i=ClearList(&L);

    printf("\n清空L后:ListLength(L)=%d\n",ListLength(L));

    ListTraverse(L);

    printf("\n");

    break;

    case 9:

    ListReverse2(L);

    //L=ListReverse3(L);

    printf("\n反转L后\n");

    ListTraverse(L);

    printf("\n");

    break;

    case 10:

    printf("你要查找倒数第几个结点的值?");

    scanf("%d", &value);

    GetNthNodeFromBack(L,value,&e);

    printf("倒数第%d个元素的值为:%d\n", value, e);

    printf("\n");

    break;

    case '0':

    exit(0);

    }

    }

    }

    延伸阅读

    此文章所在专题列表如下:

    展开全文
  • 剑指offer–链表中倒数第k个结点 、前言 最近开始刷剑指offer,记录一下。牛客网在线编程板块的剑指offer专区。...输入个链表,输出该链表中倒数第k个结点。 三、代码 # -*- coding:utf-8 -*- class Li...
  • JAVA获得数字 正数倒数 几位的几种方法总结和对比
  • #include "stdio.h"#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedefint Status;/*Status是函数的类型,其值是函数结果状态代码,如OK等*/typedefint ElemType;/*ElemType类型根据实际情况而定,...
  • 翻滚的数字精度也完全可以由自己控制,每次可以变化精度的n倍,通过此功能可以实现倒数第一反转,倒数第二位翻转,倒数第n位翻转。支持设置开始翻滚的数值以及动画的最大时间。可以在数字后面设置单位,以前前面设置...
  • 题目:输入个单向链表,输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针。 分析: 单链表只能向后遍历,不能向前遍历,尾指针好找,倒数第K个不能尾指针向前找。 倒的不好找,正的好找,我们只...
  • (尾结点是倒数第一个)结点定义如下:public class ListNode {int val;ListNode next = null;ListNode(int val) {this.val = val;}}思路1:先遍历链表,计算其长度length;然后计算出倒数第k个结点就是正数第length - ...
  • 重磅干货,第一时间送达题目链表中倒数第k个节点题目要求输入一个链表的头结点,尾到头反过来打印出每个结点的值解题思路为了得到倒数第k个结点,很自然的想法是先走链表的尾端,再尾端回溯k步。当时,链表...
  • 设置两个指针分别指向头结点,第一个指针向前走k-1步,走到正数第k个结点,同时保持第二个指针不动,然后第一个指针和第二个指针每次同时前移一步,这样第一个指针指向尾结点的时候,第二个指针指向倒数第k个结点。...
  • 输入个链表,输出该链表中倒数第k个结点。 节点定义如下: public class ListNode { int val; ListNode next = null; } 测试用例 功能测试(第k个节点在链表的中间;第k个节点是链表的头结点;第k个节点...
  • 链表中倒数第k个节点

    2019-10-15 14:59:37
    输入个链表,输出该链表中倒数第k个结点。 我的思路: 刚开始我把这个问题想简单了 我想的是 直接把链表遍历遍 把每个节点都放 vector 中 之后把vector 倒置一下 找第k个就可以 之前的代码: ////// 创建含5个...
  • 题目英文 Given an unsorted integer array, find the smallest missing positive ...Example 1: Input: [1,2,0] Output: 3 Example 2: Input: [3,4,-1,1] Output: 2 Example 3: Input: [7,8,9,11,12] Output: 1...
  • 运行本文所述实例可实现输入个单向链表,输出该链表中倒数第k个节点。具体实现方法如下:/** Copyright (c) 2011 alexingcool. All Rights Reserved.*/#include using namespace std;int array[] ...
  • // q指向倒数第k个节点,倒数第k个节点即为正数第n-k个节点 int t = n - k; while (t >= 0) { q = q.next; t--; } return q; } // 创建带头节点的无环单链表,真正的节点有m个 public Node create...
  • 这时,我们就可以想到先遍历遍计算出总共的结点个数count,然后再头部开始遍历count-k,就能取到倒数第k个结点了。这个方法之间复杂度虽然为O(n),但是遍历了两次链表,对于结点个数不多的链表来说适用,...
  • 1.因为要求链表倒数第 k 个节点,也就是求正数第length - k个节点。 链表又是个单链表,并且没有保存长度信息,所以需要循环次计算length。第二次循环找到第length - k个节点。 2.快慢(双)指针 (1)快慢指针同时...
  • 1、为了找出倒数第k个元素,最容易想到的办法是首先遍历遍单链表,求出整个单链表的长度n,然后将倒数第k个,转换为正数第n-k个,接下来遍历次就可以得到结果。但是该方法存在个问题,即需要对链表进行两次...
  • L1-050 倒数第N个字符串 (15 分)

    千次阅读 2019-02-19 11:28:14
    给定个完全由小写英文字母组成的字符串等差递增序列,该序列中的每个字符串的长度固定为 L, L 个 a 开始,以 1 为步长递增。例如当 L 为 3 时,序列为 { aaa, aab, aac, ..., aaz, aba, abb, ..., abz, ..., ...
  • 输入个链表,输出该链表中倒数第k个结点。 public static ListNode FindKthToTail(ListNode head,int k) { ListNode p, q; //设置两个head指针 p = q = head; int i = 0; for (; p != null; i++) { ...
  • 题目给定个链表,删除链表的倒数第 n 个节点,并且返回链表的头结点。示例给定个链表: 1->2->3->4->5, 和 n = 2.当删除了倒数第二个节点后,链表变为 1->2->3->5.说明:给定的 n 保证是...
  • 下面是PHP如何将数组中的负数全部变为正数,让我们起来看看PHP如何将数组中的负数全部变为正数的具体内容吧!PHP如何将数组中的负数全部变为正数PHP将数组中的负数全部变为正数的方法:首先新建php...
  • //删除链表的倒数第N个节点, 给定的N一定是有效的,返回头结点 ... //如果单链表没有头结点,我们需要定义一个头结点指向单链表的第一个结点,否则会出现空指针异常 //ListNode tmpHead = new ListNo
  • java截取个字符串正数或倒数某个特定字符前后的内容 取出正数第二个“.”后面的内容 public class TestCode { public static void main(String[] args) { String str ="232ljsfsf....
  • 倒数第N个字符串 (15 分)

    千次阅读 2019-08-21 22:02:33
    给定个完全由小写英文字母组成的字符串等差递增序列,该序列中的每个字符串的长度固定为 L, L 个 a 开始,以 1 为步长递增。例如当 L 为 3 时,序列为 { aaa, aab, aac, …, aaz, aba, abb, …, abz, …, zzz }...
  • 为了符合大多数人的习惯,本题1开始计数,即链表的尾节点是倒数第1个节点。 例如,个链表有 6 个节点,从头节点开始,它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。 示例: ...
  • 为了符合大多数人的习惯,本题1开始计数,即链表的尾节点是倒数第1个节点。例如,个链表有6个节点,从头节点开始,它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。 示例: 给定个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,872
精华内容 5,948
热门标签
关键字:

从倒数第一到正数第一