输出单向链表中倒数第k个结点

#include <iostream>
#include <vector>
#include <cstdio>

using namespace std;

struct ListNode {
  int val;
  ListNode* next;
  ListNode(int _val) : val(_val), next(nullptr) {}
};

int main(const int argc, const char* const argv[]) {
  int n, val, k;
  ListNode *head, *tail, *slow, *fast;
  while (scanf("%d", &n) != EOF) {
    head = tail = nullptr;
    while (n--) {
      cin >> val;
      if (!head)
        head = tail = new ListNode(val);
      else
        tail = tail->next = new ListNode(val);
    }
    cin >> k;
    if (!k) {
      cout << '0' << endl;
      continue;
    }
    slow = fast = head;
    while (k--) fast = fast->next;
    while (fast) slow = slow->next, fast = fast->next;
    cout << slow->val << endl;
  }
  
  return 0;
}

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()) {

            int[] arr = new int[scanner.nextInt() + 1];

            for (int i = 0; i < arr.length - 1; i++) {
                arr[i] = scanner.nextInt();
            }

            System.out.println(arr[arr.length - scanner.nextInt() - 1]);

        }

    }

}

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNextInt()) {
            ListNode head=new ListNode(0);
            ListNode node=head;
            int n=in.nextInt();
            for(int i=0;i<n;i++){
                node.next=new ListNode(in.nextInt());
                node=node.next;
            }
            int k=in.nextInt();
            int num=last(head,k);
            System.out.println(num);
            
        }
        in.close();
    }
    public static int last(ListNode head,int k){
        int t=0;
        ListNode nx=head,last1=head;
        while(nx!=null){
            t++;
            nx=nx.next;
        }
        int m=t-k;
        if(t==k&&t>0){
            return head.val;
        }
        if(k>t||k<=0){
            return 0;
        }
        for(int i=0;i<m;i++){
            last1=last1.next;
        }
        return last1.val;
    }
}
class ListNode{
    int val;
    ListNode next;
    public ListNode(int val){
        this.val=val;
    }
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        while(scanner.hasNext()){
            String num = scanner.nextLine();
            List<String> linkedList = new LinkedList<>(Arrays.asList(scanner.nextLine().split(" ")));
            Collections.reverse(linkedList);
            String indexReverse = scanner.nextLine();
            if (Integer.parseInt(indexReverse) > 0){
                System.out.println(linkedList.get(Integer.parseInt(indexReverse)-1));
            }else{
                System.out.println("0");
            }
        }
    }
}

class LNode:
    def __init__(self, elem, _next = None):
        self.elem = elem
        self.next = _next
        
class LList:
    def __init__(self):
        self._head = None
        
    def prepend(self, elem):
        self._head = LNode(elem, self._head)
        
    def search(self, k):
        p = self._head
        while p is not None and k > 1:
            k -= 1
            p = p.next
        if k == 1:
            print(p.elem)
            
    def length(self):
        p = self._head
        l = 0
        while p is not None:
            l += 1
            p = p.next
        return l
            
    def append(self, elem):
        if self._head is None:
            self._head = LNode(elem)
            return
        p = self._head
        while p.next is not None:
            p = p.next
        p.next = LNode(elem)

while True:
    try:
        L = int(input())
        N = [int(i) for i in input().split()]
        P = int(input())
        A = LList()
        for i in N:
            A.append(i)
        if P == 0:
            print(0)
        else:
            k = A.length() - P + 1
            A.search(k)
    except:
        break
        定义了类，倒序就是长度-倒序号+1，这样在搜索就能够搜索到位置，为了避免位置出错，下边应以0开始，而且，特殊情况是1个元素，索引为0

#include <bits/stdc++.h>
using namespace std;
struct ListNode{
    int key;
    ListNode* pNext;
};
ListNode* createList(vector<int>& vec){
    ListNode* list = new ListNode{vec[0],NULL},*lastNode=list;
    for(int i=1;i<vec.size();++i){
        ListNode* node = new ListNode{vec[i],NULL};
        lastNode->pNext=node;
        lastNode = node;
    }
    return list;
}
int findKeyByRIndex(ListNode* list,int listSize,int k){
    if(k==0) return 0;
    ListNode* current = list;
    for(int i=0;i<(listSize-k);++i)
        current = current->pNext;
    return current->key;
}
int main(){
    int n,k;
    while(cin>>n){
        vector<int> vec(n);
        for(int i=0;i<vec.size();++i) cin>>vec[i];
        cin>>k;
        ListNode* list = createList(vec);
        cout << findKeyByRIndex(list,n,k) << endl;
    }
}

#include<stdio.h>
(737)#include<stdlib.h>
#include<string.h>
struct ListNode
{
	int       data;
	struct ListNode* m_pNext;
};
struct ListNode* creat_node(int data) {
	struct ListNode* p = (struct ListNode*)malloc(sizeof(struct ListNode));
	if (p == NULL) {
		printf("malloc error.\n");
		return NULL;
	}
	memset(p, 0, sizeof(struct ListNode));
	p->data = data;
	p->m_pNext = NULL;
	return p;
}
void insert(struct ListNode* pH, struct ListNode* new) {
	struct ListNode* p = pH;
	while (p->m_pNext != NULL) {
		p = p->m_pNext;
	}
	p->m_pNext =new;
	new->m_pNext = NULL;
}
int main() {
	int num = 0,delete = 0;
	
	while (scanf("%d", &num) != EOF) {
		int data1[10000] = { 0 }, data = 0;
		for (int i = 0; i < num; i++) {
			scanf("%d", &data1[i]);
		}
		scanf("%d", &data);
		struct ListNode* pHeader = creat_node(data);
		struct ListNode* p = NULL;
		for (int i = 0; i < num; i++) {
			insert(pHeader, creat_node(data1[i]));
		}
		p = pHeader;
		if (data >= 1 && data <=num) {
			for (int i = 0; i < num - data + 1; i++) {
				p = p->m_pNext;
			}
			printf("%d\n", p->data);
		}
		else {
			printf("0\n");
		}
	}
	return 0;
}

class Node(object):
    def __init__(self,elem):
        self.elem = elem
        self.next = None

class SingleLinkList(object):
    def __init__(self,node=None):
        self._head = node

    def append(self,item):
        node = Node(item)
        if not self._head:
            self._head = node
        else:
            cur = self._head
            while cur.next:
                cur = cur.next
            cur.next = node

    def length(self):
        count = 0
        cur = self._head
        while cur:
            count += 1
            cur = cur.next
        return count

    def search(self,item):
        if not self._head:
            return
        else:
            cur = self._head
            count = 0
            while cur:
                if item <= 0&nbs***bsp;item > self.length():
                    return 0
                else:
                    if count == self.length() - item:
                        return cur.elem
                    count += 1
                    cur = cur.next
            return 0
while True:
    try:
        ll = SingleLinkList()
        a,b,c = int(input()),list(map(int,input().split())),int(input())
        for i in b:
            ll.append(i)
        print(ll.search(c))
    except:
        break

#include<iostream>
using namespace std;

int main(){
	int _num;
	int _dnum;
	while (cin >> _num) {
		int* _link = new int[_num];
		for (int i = 0; i < _num; i++) {
			cin >> _link[i];
		}
		cin >> _dnum;
		cout << _link[_num - _dnum] << endl;
	}
}

//思路：按照顺序依次插入节点成为链表后，用双指针法，就可以依次遍历找到倒数第k个元素
//注意这里的异常处理结果是输出0
using namespace std;
struct ListNode{
    int key;
    ListNode* next;
};
ListNode* insertNode(ListNode* head, int key, int pos){
    ListNode dummy;//这个写的是头部不为空插入链表节点
    dummy.key = -1;
    dummy.next = head;
    ListNode* p = &dummy;
    for (int i = 1; i < pos ; i++){
        p = p->next;
    }
    ListNode* node = new ListNode;
    node->key = key;
    node->next = p->next;
    p->next = node;
    return dummy.next;
}
int main(){
    int n;
    int num;
    int pos;
    while (cin >> n){
        cin >> num;
        ListNode* head = new ListNode;
        head->key = num;
        head->next = nullptr;
        for (int i = 1; i < n; i++){
            cin >> num;
            head = insertNode(head, num, i + 1);
        }
        cin >> pos;
        if(pos>n || pos < 1){//注意这里就是题目说的异常返回空指针
            cout<<0<<endl;
            continue;
        }
        ListNode* first = head;
        ListNode* second = head;
        while (pos--){
            second = second->next;
        }
        while (second)//第二个指针为空的时候，第一个指针正好在倒数第k位置上
        {
            first = first->next;
            second = second->next;
        }
        cout << first->key << endl;
    }
    system("pause");
    return 0;
}

投机取巧了😀

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int len = sc.nextInt();
            int[] ints = new int[len];
            for(int i = 0; i < len; ++i){
                ints[i] = sc.nextInt();
            }
            int num = sc.nextInt();
            if(num == 0){ //为什么是这种特殊情况啊
                System.out.println(0);
            }else{
                System.out.println(ints[len - num]);    
            }

        }
    }
}