-
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获得数字(正数和倒数)第几位的几种方法总结和对比 | 学步园
2021-03-05 21:06:26JAVA获得某个数字的最后第几位是什么的方法，比如，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个结点
2019-08-12 12:09:47输出单链表的倒数第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个结点
2019-10-31 21:45:39剑指offer–链表中倒数第k个结点 一、前言 最近开始刷剑指offer，记录一下。牛客网在线编程板块的剑指offer专区。...输入一个链表，输出该链表中倒数第k个结点。 三、代码 # -*- coding:utf-8 -*- class Li... -
JAVA获得数字 正数和倒数 第几位的几种方法总结和对比
2018-11-16 13:52:06JAVA获得数字 正数和倒数 第几位的几种方法总结和对比 -
如何获取单链表倒数第N个结点值
2020-12-09 21:49:36#include "stdio.h"#define OK 1#define ERROR 0#define TRUE 1#define FALSE 0typedefint Status;/*Status是函数的类型,其值是函数结果状态代码，如OK等*/typedefint ElemType;/*ElemType类型根据实际情况而定，... -
翻滚的数字精度也完全可以由自己控制，每次可以变化精度的n倍，通过此功能可以实现倒数第一反转，倒数第二...
2019-09-24 01:55:50翻滚的数字精度也完全可以由自己控制，每次可以变化精度的n倍，通过此功能可以实现倒数第一反转，倒数第二位翻转，倒数第n位翻转。支持设置开始翻滚的数值以及动画的最大时间。可以在数字后面设置单位，以前前面设置... -
微软算法面试(8)：输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针
2021-01-29 22:55:50题目：输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针。 分析： 单链表只能向后遍历，不能向前遍历，尾指针好找，倒数第K个不能从尾指针向前找。 倒的不好找，正的好找，我们只... -
Java输出链表倒数第k个节点
2021-02-26 15:04:26(尾结点是倒数第一个)结点定义如下：public class ListNode {int val;ListNode next = null;ListNode(int val) {this.val = val;}}思路1：先遍历链表，计算其长度length;然后计算出倒数第k个结点就是正数第length - ... -
每日算法题 | 剑指offer 链表专题 （5）链表中倒数第k个节点
2021-01-14 13:10:00重磅干货，第一时间送达题目链表中倒数第k个节点题目要求输入一个链表的头结点，从尾到头反过来打印出每个结点的值解题思路为了得到倒数第k个结点，很自然的想法是先走到链表的尾端，再从尾端回溯k步。当时，从链表... -
Python链表中倒数第k个结点
2021-04-27 03:20:42设置两个指针分别指向头结点，第一个指针向前走k-1步，走到正数第k个结点，同时保持第二个指针不动，然后第一个指针和第二个指针每次同时前移一步，这样第一个指针指向尾结点的时候，第二个指针指向倒数第k个结点。... -
22、剑指offer_java版本_链表中倒数第k个节点（正数第n-k+1个）
2020-01-15 11:31:45输入一个链表，输出该链表中倒数第k个结点。 节点定义如下： public class ListNode { int val; ListNode next = null; } 测试用例 功能测试（第k个节点在链表的中间；第k个节点是链表的头结点；第k个节点... -
链表中倒数第k个节点
2019-10-15 14:59:37输入一个链表，输出该链表中倒数第k个结点。 我的思路: 刚开始我把这个问题想简单了 我想的是 直接把链表遍历一遍 把每个节点都放到 vector 中 之后把vector 倒置一下 找第k个就可以 之前的代码: ////// 创建含5个... -
LeetCode实战：缺失的第一个正数
2019-08-03 15:36:20题目英文 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... -
C++_C语言实现输出链表中倒数第k个节点，本文实例展示了C++实现输出链 - phpStudy
2021-05-07 07:38:37运行本文所述实例可实现输入一个单向链表，输出该链表中倒数第k个节点。具体实现方法如下：/** Copyright (c) 2011 alexingcool. All Rights Reserved.*/#include using namespace std;int array[] ... -
输入一个单向链表，输出该链表中倒数第k个结点。链表的倒数第0个结点为链表的尾指针
2017-09-25 17:08:49// q指向倒数第k个节点,倒数第k个节点即为正数第n-k个节点 int t = n - k; while (t >= 0) { q = q.next; t--; } return q; } // 创建带头节点的无环单链表,真正的节点有m个 public Node create... -
java-输入一个单向链表，输出该链表中倒数第k个结点
2019-07-17 23:30:57这时，我们就可以想到先遍历一遍计算出总共的结点个数count，然后再从头部开始遍历到count-k，就能取到倒数第k个结点了。这个方法之间复杂度虽然为O（n），但是遍历了两次链表，对于结点个数不多的链表来说适用，... -
JAVA编程题之单链表：输入一个链表，输出该链表中倒数第k个结点
2020-08-19 20:42:521.因为要求链表倒数第 k 个节点，也就是求正数第length - k个节点。 链表又是个单链表，并且没有保存长度信息，所以需要循环一次计算length。第二次循环找到第length - k个节点。 2.快慢(双)指针 （1）快慢指针同时... -
如何找出单链表中的倒数第k个元素
2020-12-09 21:49:131、为了找出倒数第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, ..., ... -
【剑指offer】——求链表中倒数第K个数
2019-09-27 14:53:12输入一个链表，输出该链表中倒数第k个结点。 public static ListNode FindKthToTail(ListNode head,int k) { ListNode p, q; //设置两个head指针 p = q = head; int i = 0; for (; p != null; i++) { ... -
19. 删除链表的倒数第N个节点（Python）
2021-01-30 17:37:02题目给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。示例给定一个链表: 1->2->3->4->5, 和 n = 2.当删除了倒数第二个节点后，链表变为 1->2->3->5.说明：给定的 n 保证是... -
PHP如何将数组中的负数全部变为正数
2021-03-23 18:55:30下面是PHP如何将数组中的负数全部变为正数，让我们一起来看看PHP如何将数组中的负数全部变为正数的具体内容吧！PHP如何将数组中的负数全部变为正数PHP将数组中的负数全部变为正数的方法：首先新建php... -
删除链表的倒数第N个结点的两种思路及JAVA代码
2020-08-08 14:44:12//删除链表的倒数第N个节点, 给定的N一定是有效的,返回头结点 ... //如果单链表没有头结点，我们需要定义一个头结点指向单链表的第一个结点，否则会出现空指针异常 //ListNode tmpHead = new ListNo -
java截取一个字符串正数或倒数某个特定字符前后的内容
2018-01-24 22:04:00java截取一个字符串正数或倒数某个特定字符前后的内容 取出正数第二个“.”后面的内容 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 }... -
【LeetCode 力扣 剑指offer_22】链表中倒数第k个节点,输入一个链表，输出该链表中倒数第k个节点。...
2021-03-05 09:46:49为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。 例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。 示例： ... -
JS链表中倒数第k个节点
2020-05-19 10:59:57为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。 示例： 给定一个...
