刷题第一天——链表

已于 2023-12-30 14:07:06 修改
阅读量176 收藏
点赞数
分类专栏： 每日刷题挑战 文章标签： 链表 数据结构
于 2023-10-11 09:51:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/csdn_1_10086/article/details/133696193
版权

各种语言的数据读入代码

有些笔试题需要自己写读入数据的代码，牛客网上可以看到默认的读入数据的代码，可以作为参考。

1.java的读入代码

import java.util.Scanner;
public class Main{
	public static void main(){
		Scanner in = new Scanner(System.in);
		while(in.hasNextInt()){
			int a = in.nextInt();
			System.out.println(a);
		}
	}
}

2.c的读入代码

#include <stdio.h>
int mian(){
	int a,b;
	while(scanf("%d %d",&a,&b)!=EOF){
		printf("%d\n",a);
	}
	return 0;
}

3.python的读入代码

import sys
for line in sys.stdin:
	a=line.split()
	print(int(a[0]))

1.链表

1.1链表基础知识

链表和数组是数据类型中两个重要的基础数据类型，数组是连续存储在内存中的数据结构，而链表是一种非连续、非顺序的存储结构，由一系列的结点构成，每个结点包含数据域和指针域。
head：保存首地址，item：保存数据，next：保存下一结点的地址
单向链表：最后一个结点的指针域指向一个空值
循环链表：最后一个结点的指针域指向头结点，包括单循环列表和双循环列表
双向链表：每个结点有两个指针域，prev和next，分别指向前后
链表的常用方法：增加、删除、查询、修改、遍历

1.2python的链表操作

python不存在指针
新建一个节点类，实现基本功能：更新数据、查询数据、更新后继结点和查询后继结点
新建一个链表类，实现基本功能：增加、查找、删除、是否为空、链表长度
新建一个升序链表类，和链表类就增加、查找、删除操作会有一定的区别

参考

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

    def get_data(self):
        return self.data

    def set_data(self,new_data):
        self.data=new_data

    def get_next(self):
        return self.next

    def set_next(self,new_next):
        self.next=new_next

class Linked_list(object):
    def __init__(self):
        self.head=None

    def add(self,data):  #单链表添加只需要一个指针
        new_node=Node(data)
        new_node.data=data
        new_node.set_next(self.head) #头插法
        self.head=new_node

    def search(self,data):
        checking=self.head
        while checking!=None:
            if checking.get_data()==data:
                return True
            checking=checking.get_next()
        return False

    def remove(self,data):  #删除需要两个指针
        checking=self.head  #从头结点开始查询
        previous=None  #记录前一个结点，头结点为None
        while checking!=None:
            if checking.get_data()==data:
                break
            previous=checking
            checking=checking.get_next()

        if previous==None:  #不存在前驱结点
            self.head=checking.get_next()
        else:
            previous.set_next(checking.get_next())

    def isEmpty(self):
        return self.head==None

    def size(self):
        count=0
        checking=self.head
        while checking!=None:
            count+=1
            checking=checking.get_next()
        return count

#升序链表
class Ordered_linked_list(object):
    def __init__(self):
        self.head=None

    def add(self,data):  #需要两个指针
        checking=self.head
        previous=None
        while checking!=None:
            if checking.get_data()>data:
                break
            previous=checking
            checking=checking.get_next()

        new_node=Node(data)
        if previous==None: #插入头结点
            new_node.set_next(self.head)
        else:
            previous.set_next(new_node)
            new_node.set_next(checking)
    def search(self,data):
        checking=self.head
        while checking!=None:
            if checking.get_data()==data:
                return True
            elif checking.get_data>data:
                return False
            checking=checking.get_next()
        return False

    def remove(self,data):
        checking=self.head
        previous=None
        while checking!=None:
            if checking.get_data()==data:
                break
            previous=checking
            checking=checking.get_next()

        if previous==None:
            self.head=checking.get_next()
        else:
            previous.set_next(checking.get_next())

1.3python实现栈和队列

参考
栈：先进后出

# 构建了一个长度无限的栈
class Stack:
    def __init__(self):
        self.stack = []
 
    def push(self, element):
        return self.stack.append(element)
 
    def pop(self):
        if self.is_empty():
            raise IndexError("Stack is empty")
        else:
            return self.stack.pop()
 
    def get_top(self):
        if self.is_empty():
            raise IndexError("Stack is empty")
        else:
            return self.stack[-1]  # 输出表尾
 
    def is_empty(self):
        if len(self.stack) == 0:
            return True  # 是空栈
        else:
            return False
 
 
if __name__ == "__main__":
    init_stack = Stack()
    init_stack.stack = [1, 2, 3, 4, 5]
    init_stack.push(6)  # 进栈：6
    init_stack.pop()    # 出栈：6
    for items in init_stack.stack:
        print(items)    # 栈的遍历

队列：先进先出

# deque是一个双向队列，可以实现队首队尾出队、队首队尾入队
from collections import deque
def in_de_queue():
    queue = deque([1, 2, 3])    # 实例化，创建对象queue
    queue.pop()  # 队尾出队(3)
    queue.append(4)  # 队尾入队(4)
    queue.appendleft([7, 8, 9])  # 队首入队([7,8,9])
    queue.appendleft(6)  # 队首入队(6)
    queue.popleft()  # 队首出队(6)
    print(queue)

1.4java的链表操作

java有一个LinkedList（链表）类，是一种常用的数据容器，是一个双向链表，定义了next和prev两个指针
相较于ArrayList，LinkedList的增加和删除操作效率更高，然而查找和修改的操作效率较低。
LinkedList类位于java.util包里面，需要import java.util.LinkedList; 。

//java的源代码
 private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }
    
//自定义的Node
 public class ListNode{
        int val;
        ListNode next=null;
        public ListNode(int val){
            this.val=val;
        }
    }

LinkList<String> sites = new LinkList<String>();

//增加
private void linkFirst(E e) {
        final Node<E> f = first;
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

    /**
     * Links e as last element.
     */
    void linkLast(E e) {
        final Node<E> l = last;
        final Node<E> newNode = new Node<>(l, e, null);
        last = newNode;
        if (l == null)
            first = newNode;
        else
            l.next = newNode;
        size++;
        modCount++;
    }

//删除
public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }

//查询
public E get(int index) {
        checkElementIndex(index);
        return node(index).item;
    }
Node<E> node(int index) {
        // assert isElementIndex(index);

        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }

//修改
public E set(int index, E element) {
        checkElementIndex(index);
        Node<E> x = node(index);
        E oldVal = x.item;
        x.item = element;
        return oldVal;
    }


//遍历
for(int i=0;i<sites.size();i++){
   System.out.println(sites.get(i));
}
        
for(String i:sites){
   System.out.println(i);
}
        
Iterator iter=sites.iterator();
while (iter.hasNext()){
   System.out.println(iter.next());
}

1.5java链表的应用：队列和栈

队列：先进先出
栈：先进后出


//队列
LinkedList list = new LinkedList();
list.add("Java");  //入队
list.poll();  //出队

public E poll() {
        final Node<E> f = first;
        return (f == null) ? null : unlinkFirst(f);
    }

//栈
LinkedList list = new LinkedList();
list.add("Java"); //进栈
list.pollLast(); //出栈

public E pollLast() {
        final Node<E> l = last;
        return (l == null) ? null : unlinkLast(l);
    }

 private E unlinkLast(Node<E> l) {
        // assert l == last && l != null;
        final E element = l.item;
        final Node<E> prev = l.prev;
        l.item = null;
        l.prev = null; // help GC
        last = prev;
        if (prev == null)
            first = null;
        else
            prev.next = null;
        size--;
        modCount++;
        return element;
    }

1.6反转链表-java

参考
1.使用Stack（栈）

public ListNode reverseList(ListNode head) {
    if (head == null) return null;
    Stack<ListNode> stack = new Stack<>();
    stack.push(head); // 存入第一个节点
    while (head.next != null) {
        stack.push(head.next); // 存入其他节点
        head = head.next; // 指针移动的下一位
    }
    // 反转链表
    ListNode listNode = stack.pop(); // 反转第一个元素
    ListNode lastNode = listNode; // 临时节点，在下面的 while 中记录上一个节点
    while (!stack.isEmpty()) {
        ListNode item = stack.pop(); // 当前节点
        lastNode.next = item;
        lastNode = item;
    }
    lastNode.next = null; // 最后一个节点赋为null（不然会造成死循环）
    return listNode;
}

2.递归

public static ListNode reverseList(ListNode head) {
    if (head == null || head.next == null) return head;
    // 从下一个节点开始递归
    ListNode reverse = reverseList(head.next);
    head.next.next = head; // 设置下一个节点的 next 为当前节点
    head.next = null; // 把当前节点的 next 赋值为 null，避免循环引用
    return reverse;
}

3.循环

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null) return null;
        // 最终排序的倒序链表
        ListNode prev = null;
        while (head != null) {
            // 循环的下个节点
            ListNode next = head.next;
            // 反转节点操作
            head.next = prev;
            // 存储下个节点的上个节点
            prev = head;
            // 移动指针到下一个循环
            head = next;
        }
        return prev;
    }
}
leetcode刷题（javaScript）——链表相关场景题总结
涵盖了计算机专业基础知识、数学建模相关实践、复杂网络论文研究、LeetCode算法刷题经验、C语言开发经验、前端Vue、React框架开发实战相关知识
03-02 1335
1. 熟悉链表的基本操作：了解链表的基本结构和操作，包括节点的定义、指针操作等。：在处理链表时，要考虑边界情况，如空链表、只有一个节点的链表等。2. 反转链表：将链表的指针方向反转，使链表的尾部变为头部。1. 遍历链表：从头到尾遍历链表，处理每个节点的值或指针。3. 合并两个有序链表：将两个有序链表合并成一个有序链表。4. 删除链表中的指定节点：删除链表中特定值或位置的节点。5. 检测链表中是否有环：判断链表中是否存在环形结构。：递归是解决链表问题的常见方法，可以简化问题的复杂度。
五月集训(第12天) —— 链表
英雄哪里出来
05-12 782
第12天
刷题的一天——链表结构
Hollowbrain的博客
04-09 1292
1、给定一个头结点为head的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。 示例： 输入：[1,2,3,4,5] 输出：此列表中的结点 3 (序列化形式：[3,4,5]) 返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。 注意，我们返回了一个 ListNode 类型的对象 ans，这样： ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = ...
leetcode刷题第五天——链表Ⅰ
m0_74640012的博客
02-09 367
需要注意的是，要控制好链表的访问，不能“越界”，最后一个结点的next域是NULL，不能访问它，即假设ListNode* tmp指向链表的最后一个结点，tmp->val、tmp->next这样的访问是错误的！这两道题，比本人在学数据结构的时候的实验要简单很多，但是一年过去了，代码阅读能力和写代码的速度都下降了，还是得多敲，奥里给！因为，首结点的存在，使得头节点的插入和删除变得与链表中的其它结点没有任何区别，这样子，就可以统一操作头结点和其它结点的代码了，YYDS。//结点指针域，指向下一个链表结点。
leetcode刷题第五天——链表Ⅱ
m0_74640012的博客
02-09 208
142不会做，先留着，链表就到此告一段落了，明天开始刷哈希表了，奥里给。太妙了啊，有时候，在链表中双指针也嘎嘎好用啊！本次刷题顺序是按照卡尔的代码随想录中给出的顺序。
leetcode刷题第六天——哈希表Ⅰ
m0_74640012的博客
02-10 407
快乐数那道题，可以使用哈希表来做，因为哈希表可以存储已经出现过的数，如果该数再度出现并值不等于1，那么说明出现了环，该数不是快乐数。用哈希表判断是否有环还是有局限的，如果环中有重复出现的数，例如环“2-1-1-2-3-4-2”，用哈希表是不能判断的，这时候快慢指针就可以处理。h(k)=k%p，其中，p为大小于TableSize的素数时，效果最好，k为映射得到的索引。本次刷题使用c语言，后面学完c++再用c++标准库中的容器再做一遍，奥里给！滑动窗口+哈希真是太妙了，用在一些匹配类题目还是挺好用的。
leetcode刷题第21天——1763，117，572
tomly2020的博客
02-01 682
第二十一天 1763 最长的美好子串 当一个字符串s包含的每一种字母的大写和小写形式 同时 出现在s中，就称这个字符串 s是 美好 字符串。比方说，"abABB" 是美好字符串，因为'A'和 'a'同时出现了，且 'B'和'b'也同时出现了。然而，"abA"不是美好字符串因为'b' 出现了，而 'B'没有出现。 给你一个字符串s ，请你返回s 最长的 美好子字符串 。如果有多个答案，请你返回 最早 出现的一个。如果不存在美好子字符串，请你返回一个空字符串。 方法 遍历字符的开始位置，每次从字符串的开始位置往
LeetCode刷题第一天——1two sum 2 AddTwoList
weixin_30284355的博客
06-06 102
1.Leetcode 1 给定数组和目标，问：数组中的文字哪两个能组成这个目标。且规定只有一种可能（人为简化条件） 注意点： LeetCode出于简化编程的思路，只让写solution类即可，但是本地调试需要自己写main函数。在main函数中新建一个变量 Solution s 通过s调用相关函数或者变量，这体现了一种封装的思想 进步： 复习了C语言中类的用法 迭代器的用法...
leetcode刷题第17天——1996，82，15
tomly2020的博客
01-28 4589
第十七天 1996 游戏中弱角色的数量 你正在参加一个多角色游戏，每个角色都有两个主要属性：攻击 和 防御 。给你一个二维整数数组properties ，其中 [i] = [attacki, defensei]表示游戏中第 i个角色的属性。 如果存在一个其他角色的攻击和防御等级 都严格高于 该角色的攻击和防御等级，则认为该角色为 弱角色 。更正式地，如果认为角色 i 弱于 存在的另一个角色 j ，那么 attackj > attacki且 defensej > defensei。 返回 弱角色
力扣刷题第2天——两数相加+无重复字符的最长子串
qq_52189899的博客
04-13 221
力扣每日一题挑战：第二天——两数相加
六月集训(第12天) —— 链表
英雄哪里出来
06-12 535
6月的第12天
leetcode刷题（javaScript）——堆相关场景题总结
涵盖了计算机专业基础知识、数学建模相关实践、复杂网络论文研究、LeetCode算法刷题经验、C语言开发经验、前端Vue、React框架开发实战相关知识
03-13 1104
堆是什么？堆都能用树表示，并且一般树的实现都是利用链表。平时使用的最多的是二叉堆，它可以用完全二叉树表示，二叉堆易于存储，并且便于索引。在堆的实现时注意：因为是数组，所以父子节点的关系就不需要特殊的结构去维护了，索引之前通过计算就可以得到，省掉了很多麻烦，如果是链表结构，就会复杂很多。在JavaScript刷题中，堆（Heap）通常用于解决一些需要高效处理优先级的问题，例如找出最大或最小的K个元素、实现优先队列等。：通过维护一个大小为K的最大堆或最小堆，可以快速找出数组中最大或最小的K个元素。
leetcode刷题（javaScript）——字典哈希表相关场景题总结
涵盖了计算机专业基础知识、数学建模相关实践、复杂网络论文研究、LeetCode算法刷题经验、C语言开发经验、前端Vue、React框架开发实战相关知识
03-04 1234
在 JavaScript 刷题中，字典（Dictionary）和哈希表（Hash Table）通常用来存储键值对，提供快速的查找、插入和删除操作。它们在很多算法题目中都有广泛的应用，特别是在需要快速查找元素或统计元素出现次数的情况下。
数据结构 - 栈与队列
Xingshi89的专栏
06-09 235
栈又称为后进先出的线性表（Last In First Out , LIFO）。是一种先进先出的线性表（First In Fist Out , FIFO）。它只允许在表的一端进行插入，而在另一端删除元素。：限定仅在表尾进行插入或删除操作的。在队列中，允许插入的一端称为。表尾端有特殊含义，称为。，允许删除的一端则称为。
从零手写Java版本的LSM Tree （二）：KeyValue 数据结构
翊歌
06-09 941
KeyValue 数据结构 的核心深度剖析
【数据结构】图算法（代码）
m0_73911405的博客
06-10 1271
这里我用的上一章节中图的邻接矩阵的结构，进行遍历的。这里其实跟二叉树中，层序遍历思想差不多，都是前一个节点带后面的节点(A带B,C,D之后依次类推)当然这里有一个难点就是当我们遍历到B的时候我们插入队列的时候有AEC，但是我们只想要E，因为A已经pop掉了，C在队列中。我们该如何操作？用个数组标记一下全部元素，当前要插入队列中的元素是否用过，也就是说当我们元素插入到队列的时候标记一下。代码理解一下测试结果。
用Java实现常见排序算法详解
最新发布
m0_66884848的博客
06-13 817
本文介绍了6种常见排序算法的Java实现，包括冒泡、选择、插入排序等基础算法，以及快速、归并、堆排序等高效算法。对每种算法从基本思想、时间复杂度分析和Java代码实现三个方面进行详细说明，展示了排序算法的核心逻辑和性能特点。这些排序方法在计算机科学中具有广泛应用，理解其原理和实现有助于提升编程能力和算法思维。
26-数据结构-线性表2
m0_57856520的博客
06-13 457
本文整理了顺序表常见操作的C/C++实现方法，涵盖多种基础算法：1. O(n)划分算法（快速排序思想）实现元素按key值左右划分；2. 数组逆置操作及回文判断；3. 递归实现的二分查找算法；4. 优化后的双向冒泡排序（鸡尾酒排序）；5. 高效数组循环左移的三步反转法。这些算法均基于顺序表结构实现，包含完整代码示例，是数据结构学习的核心基础内容，适合初学者通过实践掌握线性表的基本操作原理和应用场景。
数据结构 (树) 学习 2025年6月12日12:59:39
梦境虽美,却不长.
06-12 625
左旋和右旋是平衡的核心，需熟练掌握四种不平衡情况的处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值