刷题打卡第一天

最新推荐文章于 2024-07-25 15:31:50 发布
最新推荐文章于 2024-07-25 15:31:50 发布
阅读量148 收藏
点赞数
分类专栏： 牛客网top100 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wywxring98/article/details/127906687
版权

刷题打卡

2022-11-17

牛客-面试高频榜单

2 简单 3 中等 1困难

78 反转链表

简单

题目

给定一个单链表的头结点p Head(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0≤n≤1000

要求：空间复杂度 O(1) ，时间复杂度 O(n) 。

如当输入链表{1,2,3}时，

经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。

示例1

输入：

{1,2,3}

返回值：

{3,2,1}

示例2

输入：

{}

返回值：

{}

说明：

空链表则输出空

题解

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

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur  = head;
        ListNode next;
		//关键
        while(cur!=null){
            next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
		//注意
        return pre;
    }
}

140 排序

题解

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    public int[] MySort (int[] arr) {
        // write code here
        // 解法1：调用库函数Arrays.sort
        /*
        Arrays.sort(arr);
        return arr;
        */

        // 解法2：冒泡排序bubbleSort
       //return bubbleSort(arr);

       //解法3：快速排序quickSort
        //quickSort(arr , 0 , arr.length-1 );
        //return arr;
		
        //解法4：选择排序selectSort
        //return selectSort(arr);
        
        //解法5：插入排序insertSort
        return insertSort(arr);
        
        //解法6：归并排序mergeSort
        //mergeSort(arr,0,arr.length-1);
        //return arr;

        //解法7：堆排序heapSort
       //heapSort(arr);
       //return arr;
    }

    // 解法2：冒泡排序bubbleSort
    public int[] bubbleSort(int[] arr){
        if(arr.length<2){
            return arr;
        }
        //升序
        //相邻的两两比较，把大的沉在最底下
        for(int i = 0 ;i<arr.length-1 ;i++){
            for(int j = 0 ; j<arr.length-i-1 ;j++){
                if( arr[j] > arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
        return arr;
    }

    //解法3：快速排序quickSort
    public void quickSort(int[] arr,int left ,int right){
        if(left < right){
            int pos = part(arr,left,right);
            QuickSort(arr,pos+1,right);
            QuickSort(arr,left,pos-1);
        }
        
    }
    public int part(int[] arr ,int left ,int right){
        int first = arr[left];
       
        while(left < right){
            while(left<right && arr[left]<=first){
                left++;
            }
            swap(arr,left,right);
            while(left<right && arr[right]>=first){
                right--;
            }
            swap(arr,left,right);

        }
        return  left;
    }

    //解法4：选择排序selectSort
    public int[] selectSort(int[] arr){
	//从无序区间不断挑选出最小值，挑选 n-1 次
    for (int i = 0; i < arr.length - 1; i++) {
        int minIndex = i;
        for (int j = i + 1; j < arr.length; j++) {
        	//更换最小值下标
            minIndex = arr[minIndex] < arr[j] ? minIndex : j;
        }
        //交换最小值与无序区间第一个元素
        swap(arr,i,minIndex)
    }
}

    //解法5：插入排序insertSort
    public int[]  insertSort(int[] arr){
        for (int i = 1; i < arr.length; i++) {
            int insertValue = arr[i];
            int j = i - 1;
            //从右向左比较元素的同时，进行元素复制
            for(; j >=0 && insertValue < arr[j]; j--){
                arr[j+1] = arr[j];
            }
            //insertValue的值插入适当位置
            arr[j+1] = insertValue;
        }
	}

    
    //解法6：归并排序MergeSort
    public void mergeSort(int[] arr,int l,int r){
        if(l==r){
            return;
        }
        int mid = l+((r-l)>>1); //中点位置，即(l+r)/2
        mergeSort(arr,l,mid);
        mergeSort(arr,mid+1,r);
        merge(arr,l,mid,r);
    }
 
    public void merge(int[] arr,int l,int mid,int r){
        int [] help= new int[r-l+1];    //辅助数组
        int i=0;
        int p1=l; //左半数组的下标
        int p2=mid+1; //右半数组的下标
    
        //判断是否越界
        while(p1<=mid && p2<=r){
            help[i++]=arr[p1]<arr[p2] ? arr[p1++] : arr[p2++];
        }
        //p1没有越界，说明p2越界了，将左边剩余元素拷贝到辅助数组
        while(p1<=mid){
            help[i++]=arr[p1++];
        }
        //p2没有越界，说明p1越界了
        while(p2<=r){
            help[i++]=arr[p2++];
        }
        //将辅助数组元素拷贝会原数组
        for(i=0;i<help.length;i++){
            arr[l+i]=help[i];
        }
    }

    //解法7：堆排序HeapSort
   public static void heapSort(int[] arr){
       if(arr == null || arr.length<2){
           return;
       }
       for(int i=0;i<arr.length;i++){
           heapInsert(arr,i); //构造完全二叉树
       }
       int size = arr.length;
       swap2(arr,0,--size);
       while(size>0){
           heapify(arr,0,size);// 最后一个数与根交换
           swap2(arr,0,--size);
       }

   }
   //判断该结点与父结点的大小，大结点一直往，建立大根堆
   public static void heapInsert(int[] arr,int index){
       while(arr[index]>arr[(index-1)/2]){
           swap2(arr,index,(index-1)/2);
           index=(index-1)/2;
       }
   }

   //一个值变小往下沉的过程
   public static void heapify(int[] arr,int index,int size){
       int left=index*2+1;
       while(left<size){
           int largest = left + 1 < size && arr[left+1] > arr[left] ? left+1 : left;
           largest = arr[largest] > arr[index] ? largest :index;
           if(largest==index){
               break;
           }
           swap2(arr,largest,index);
           index=largest;
           left=index*2 +1;

       }
   }

   //交换函数
   public static void swap2(int[] arr, int i, int j){
       int tmp;
       tmp=arr[i];
       arr[i]=arr[j];
       arr[j]=tmp;
   }


    public void swap(int[] arr ,int i ,int j){
        int temp = arr[i] ;
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

tips

img

45 二叉树先序，中序和后序遍历

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 the root of binary tree
     * @return int整型二维数组
     */
    public int[][] threeOrders (TreeNode root) {
       //三个集合，分别存储三种遍历结果
        List<Integer> list1 = new ArrayList<>();
        List<Integer> list2 = new ArrayList<>();
        List<Integer> list3 = new ArrayList<>();

        //调用函数计算遍历结果
        preOrder(root, list1);
        inOrder(root, list2);
        postOrder(root, list3);

        //存放结果集
        int[][] res = new int[3][list1.size()];
        for(int i = 0; i < list1.size(); i++){
            res[0][i] = list1.get(i);
            res[1][i] = list2.get(i);
            res[2][i] = list3.get(i);

        }
        //答案返回
        return res;
    }
    // 先序遍历函数
    public void preOrder(TreeNode root, List<Integer> list){
        //特判
        if(root == null){
            return;
        }
        //对左右子树进行递归的遍历
        list.add(root.val);
        preOrder(root.left, list);
        preOrder(root.right, list);
    }

    // 中序遍历函数
    public void inOrder(TreeNode root, List<Integer> list){
        //特判
        if(root == null){
            return;
        }
       //递归调用：对左右子树进行递归的遍历
        inOrder(root.left, list);
        list.add(root.val);
        inOrder(root.right, list);
    }

    // 后序遍历函数
    public void postOrder(TreeNode root, List<Integer> list){
        if(root == null){
            return;
        }
        //递归调用：对左右子树进行递归的遍历
        postOrder(root.left, list);
        postOrder(root.right, list);
        list.add(root.val);
    }

}

15 二叉树层序遍历

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @return int整型ArrayList<ArrayList<>>
     */
    public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        
        // write code here
        ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
        if(root==null) return res;
        ArrayList<Integer> temp = new ArrayList<Integer>();
        
        ArrayList<TreeNode> list = new ArrayList<TreeNode>();
        list.add(root);

        while(!list.isEmpty()){
            int count = list.size();
            temp = new ArrayList<Integer>();
            for(int i = 0 ; i<count ;i++){
                TreeNode t = list.get(0);
                list.remove(0);
                temp.add(t.val);
                if(t.left!=null) list.add(t.left);
                if(t.right!=null) list.add(t.right);
            }
            res.add(temp);
        }

        return res;
        
    }
}

119 最小的K个数

题目

给定一个长度为 n 的可能有重复值的数组，找出其中不去重的最小的 k 个数。例如数组元素是4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4(任意顺序皆可)。

题解

    import java.util.*;
    public class Solution{
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] input, int k) {
        ArrayList<Integer> res = new ArrayList<>(k);
        //根据题意要求，如果K>数组的长度，返回一个空的数组
        if (k > input.length || k == 0)
            return res;
        quickSort(input, res, k, 0, input.length - 1);
        return res;
    }

    private void quickSort(int[] input, ArrayList<Integer> res, int k, int left, int right) {
        //快排的实现方式有多种，我们选择了其中的一种
        int start = left;
        int end = right;
        while (left < right) {
            while (left < right && input[right] >= input[start]) {
                right--;
            }
            while (left < right && input[left] <= input[start]) {
                left++;
            }
            swap(input, left, right);
        }
        swap(input, left, start);
        //注意这里，start是数组中元素的下标。在start之前的元素都是比start指向的元素小，
        //后面的都是比他大。如果k==start，正好start之前的k个元素是我们要找的，也就是
        //数组中最小的k个，如果k>start，说明前k个元素不够，我们还要往后再找找。如果
        //k<start，说明前k个足够了，我们只需要在start之前找k个即可。
        if (left > k) {
            quickSort(input, res, k, start, left - 1);
        } else if (left < k) {
            quickSort(input, res, k, left + 1, end);
        } else {
            //取前面的k个即可
            for (int m = 0; m < k; ++m) {
                res.add(input[m]);
            }
        }
    }

    private void swap(int[] arr, int i, int j) {
        if (i == j)
            return;
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    }

93 设计LRU缓存结构

题目

设计LRU(最近最少使用)缓存结构，该结构在构造时确定大小，假设大小为 capacity ，操作次数是 n ，并有如下功能:

  1. Solution(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
  2. get(key)：如果关键字 key 存在于缓存中，则返回key对应的value值，否则返回 -1 。
  3. set(key, value)：将记录(key, value)插入该结构，如果关键字 key 已经存在，则变更其数据值 value，如果不存在，则向缓存中插入该组 key-value ，如果key-value的数量超过capacity，弹出最久未使用的key-value

提示:
1.某个key的set或get操作一旦发生，则认为这个key的记录成了最常使用的，然后都会刷新缓存。
2.当缓存的大小超过capacity时，移除最不经常使用的记录。
3.返回的value都以字符串形式表达，如果是set，则会输出"null"来表示(不需要用户返回，系统会自动输出)，方便观察
4.函数set和get必须以O(1)的方式运行
5.为了方便区分缓存里key与value，下面说明的缓存里key用""号包裹

题解

import java.util.*;

public class Solution {
    private int capacity;
    private Map<Integer, Node> map;
    private Node head;
    private Node tail;
    private int used;
    
    class Node {
        int key;
        int value;
        Node prev;
        Node next;
                
        Node(int key, int value, Node prev, Node next) {
            this.key = key;
            this.value = value;
            this.prev = prev;
            this.next = next;
        }
    }
    
    public Solution(int capacity) {
         // write code here
        this.capacity = capacity;
        this.map = new HashMap<>();
        this.used = 0;
    }

    public int get(int key) {
         // write code here
        if (!map.containsKey(key)) {
            return -1;
        }

        makeRecently(key);
        
        return map.get(key).value;
    }

    public void set(int key, int value) {
         // 如果 key 已存在，直接修改值，再移到链表头部
        if (map.containsKey(key)) {
            map.get(key).value = value;
            makeRecently(key);
            return;
        }
        
        // 如果达到容量上限，就要移除尾部节点，注意 HashMap 要 remove！！！
        if (used == capacity) {
            map.remove(tail.key);
            tail = tail.prev;
            tail.next = null;
            used--;
        }
        // 头节点为空，单独处理
        if (head == null) {
            head = new Node(key, value, null, null);
            tail = head;
        }
        else {
            Node t = new Node(key, value, null, head);
            head.prev = t;
            head = t;
        }
        map.put(key, head);
        
        used++;
    }
    
        // 把 key 对应的节点移到链表头部
    private void makeRecently(int key) {
        Node t = map.get(key);
        if (t != head) {
            if (t == tail) {
                tail = tail.prev;
                tail.next = null;
            }
            else {
                t.prev.next = t.next;
                t.next.prev = t.prev;
            }
            
            t.prev = null;
            t.next = head;
            head.prev = t;
            head = t;
        }
    }
}

/**
 * Your Solution object will be instantiated and called as such:
 * Solution solution = new Solution(capacity);
 * int output = solution.get(key);
 * solution.set(key,value);
 */

Node t = map.get(key);
if (t != head) {
if (t == tail) {
tail = tail.prev;
tail.next = null;
}
else {
t.prev.next = t.next;
t.next.prev = t.prev;
}

        t.prev = null;
        t.next = head;
        head.prev = t;
        head = t;
    }
}

}

/**

  • Your Solution object will be instantiated and called as such:
  • Solution solution = new Solution(capacity);
  • int output = solution.get(key);
  • solution.set(key,value);
    */
aaaaa98666
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode刷题打卡第一天
2301_80165803的博客
04-04 149
1.枚举法的使用2.++i与i++在for循环里效果都一样，让i的值加1，但我用++i所用时间更少。3.++i和i++本质上没有什么区别，当有变量接受返回值时，一个是返回加之前的数，一个是加之后的数，对于for循环里没有效果区别，只不过时间效率上++i更快。
洛谷刷题打卡第一天
sharp0016的博客
11-20 497
洛谷1001 #include <stdio.h> int main(){ int a,b,c; scanf("%d %d",&a,&b); c = a+b; printf("%d",c); } 洛谷1421 #include <stdio.h> int main(){ int a,b,c,m,n,x; scanf ("%d %d",&a,&b); m = 10*a+b; n = 19; x = m/n; printf("%d",x
Leetcode刷题打卡第一天
biaodaikui0275的博客
07-13 167
问题描述给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。示例: 给定nums=[2,7,11,15],target=9 因为nums[0]+nums[1]=2+7=9 所以返回[0,...
Leecode 刷题打卡第一天
qq_45684413的博客
04-26 72
Leecode 刷题打卡第一天 最大连续1的个数 III 题目内容 看到这道题可以转换为，求解最长子序列，首先要求最长的子序列，我们看看限制条件是什么，是0的个数，如果在一个子序列中，0的个数恰好是可以翻转的k的个数，那这个子序列就一定是最长子序列的构成部分。 滑动窗口解法 我们求解最长子序列一般都使用滑动窗口的方法，以下代码参考自（@负雪明烛 的题解） 关于滑动窗口自己的理解 通过左右指针，来进行窗口内值的更新迭代，想要做滑动窗口的题，一定得先明确指针的限制条件，尤其是左指针，它决定着窗口能否收
代码随想录刷题打卡day02
04-18
代码随想录刷题打卡day02
打卡第一天 模拟退火
01-07
:heavy_large_circle:打卡 我昨天计划在今天看遗传算法，但是翻开黄书发现，现代优化算法这一章节里，模拟退火排在遗传的前面。所以今天就先学模拟退火了。在这之前要提一下什么是现代优化算法，这个问题会涉及到...
leetcode卡-leetcode:刷题打卡
07-06
这可能是一个开源项目的主要代码库，里面包含了用于管理LeetCode刷题、打卡、追踪进度等功能的源代码。对于开发者来说，研究这样的开源项目不仅可以学习到实际的编程技巧，还能深入了解如何构建类似的工具，提升自己...
leetcode跳跃-LeetCode:LeetCode刷题打卡
06-30
LeetCode刷题打卡 2020.02.04 回溯算法 编号 难度 题目 题解思路 执行结果 401 简单 二进制手表 回溯算法 40 ms 13.2 MB 784 简单 字母大小写全排列 回溯算法 64 ms 13.5 MB 2020.02.05 数组 编号 难度 题目 题解...
leetcode卡-leetcode:LeetCode刷题打卡
07-06
leetcode卡 leetcode LeetCode 刷题打卡
数据结构——双向链表及其总结
2406_83392683的博客
07-23 375
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
redis原理之底层数据结构-跳表
zhifou123456的博客
07-23 663
链表是在程序设计中最常见的数据结构之一，它通过指针将多个链表节点连接起来，这样就可以将逻辑上同一类的数据存储到不连续的内存空间上。链表结构如下：但是链表有一个问题，就是当链表需要查询一个元素的时候，需要从链表头部开始遍历，时间复杂度为o(n)。
【数据结构】搜索二叉树
dab112的博客
07-24 1347
介绍了二叉搜索树的实现与模拟
数据结构重置版（概念篇）
2302_80418176的博客
07-24 651
本篇文章是对数据结构的重置，且只涉及概念。
数据结构（2）
m0_62881487的博客
07-23 1111
为建立数据元素之间的线性关系，对每个链表结点，除存放元素自身的信息之外，还需要存放一个指向其后继的指针。为指针域，存放其后继结点的地址。由于单链表的元素离散地分布在存储空间中，因此是非随机存取的存储结构。1. 线性表的链式存储又称单链表。它是指通过一组任意的存储单元来存储线性表中的数据元素。的存储单元依次存储线性表中的数据元素，从而使得逻辑上相邻的两个元素在物理地址上也相邻。3. 顺序表的特点是表中元素的逻辑顺序与其存储的物理顺序相同。2. 线性表的顺序存储又称顺序表。，分别指向其直接前躯和直接后继。
2024.7.24 作业
qq_64434282的博客
07-24 1924
【代码】2024.7.24 作业。
数据结构和算法入门
最新发布
weixin_67852890的博客
07-25 1459
链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成。每个节点包含两部分：元素值（Element Value）和指向下一个节点的指针（Pointer）。链表可以分为多种类型，如单向链表、双向链表、循环链表等。元素在存储上并不连续。队列是一种基础且广泛应用的线性数据结构，它模拟了现实生活中的排队现象，遵循“先进先出”（First-In-First-Out, FIFO）原则。
2024 暑假友谊赛-热身2
qq_42643660的博客
07-24 992
树的直径，N%m=N-(N/m)*m，期望dp..迷，简单线段树
打卡第22天------回溯算法
GodLoveMe的博客
07-24 658
开始学习了，希望我可以尽快成功上岸！
编写代码 健康打卡一天只能打卡一次
04-05
假设我们有一个名为`health_check`的函数来执行健康打卡操作。我们可以使用一个字典来存储每个用户的打卡记录。字典的键是用户的ID，值是一个布尔值，表示用户今天是否已经打卡。 下面是一个示例代码： ``` check_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值