反转链表&&排序&&设计LRU缓存结构

NC78 反转链表

题目链接

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 dummy = new ListNode(0);
        while(head != null){
            ListNode tmp = head;
            head = head.next;
            tmp.next = dummy.next;
            dummy.next = tmp;
        }
        return dummy.next;
    }
}

NC140 排序

题目链接

1、解题思路

• 快排&归并排序

2、代码

快排

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    
    private void quickSort(int[] arr,int l,int r){
        if(l >= r){
            return;
        }
        int i = l;
        int j = r;
        int base = arr[i];
        while(i < j){
            while(i < j && arr[j] >= base){
                j--;
            }
            if(i < j){
                arr[i++] = arr[j];
            }
            while(i < j && arr[i] <= base){
                i++;
            }
            if(i < j){
                arr[j--] = arr[i];
            }
        }
        arr[i] = base;
        quickSort(arr,l,i-1);
        quickSort(arr,i+1,r);
    }
     
    public int[] MySort (int[] arr) {
        // write code here
        quickSort(arr,0,arr.length - 1);
        return arr;
    }
}

归并排序

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 将给定数组排序
     * @param arr int整型一维数组 待排序的数组
     * @return int整型一维数组
     */
    
    private void mergeSort(int[] arr,int l,int r){
        if(l >= r){
            return;
        }
        int mid = l + (r - l)/2;
        mergeSort(arr,l,mid);
        mergeSort(arr,mid+1,r);
        int[] tempArr = new int[r - l + 1];
        int i = l,j = mid+1;
        int index = 0;
        while(i <= mid || j <= r){
            if(i > mid){
                tempArr[index++] = arr[j++];
            }else if(j > r){
                tempArr[index++] = arr[i++];
            }else if(arr[i] < arr[j]){
                tempArr[index++] = arr[i++];
            }else{
                tempArr[index++] = arr[j++];
            }
        }
        for(i = 0;i < index;i++){
            arr[i + l] = tempArr[i];
        }
    }
    
    public int[] MySort (int[] arr) {
        // write code here
        int r = arr.length - 1;
        mergeSort(arr,0,r);
        return arr;
    }
}

NC93 设计LRU缓存结构

题目链接

1、解题思路

• 双链表数据结构，哈希表。在初始化的过程中，创建一个双链表和哈希表，哈希表的键是key，哈希表的值是Node，Node有两个数据域，第一个数据域是key（这个key和哈希表的键对应，方便查找），第二个数据域是value。首先，每执行一次get操作，都会将相应的节点先删除，然后移动到链表的头部。每一次set操作，先进行get操作，如果get能获取值，则可以直接通过哈希表进行改值，如果不能获取值，则需要判断链表的长度是否大于k（可以通过哈希表的大小间接判断），如果小于k，直接插入，如果==k，则需要从尾巴删除一个结点，然后再从头插入一个结点。这个方法还是超级棒的。

2、代码

import java.util.*;


public class Solution {
    static class Node{
        int key,value;
        Node prev = null,next = null;

        public Node(int key,int value) {
            this.key = key;
            this.value = value;
        }
    }

    private Map<Integer,Node> map = new HashMap<>();

    private Node head = new Node(-1,-1);
    private Node tail = new Node(-1,-1);

    private int k;

    public int[] LRU (int[][] operators, int k) {
        // write code here
        this.head.next = tail;
        this.tail.prev = head;
        this.k = k;
        int len = (int) Arrays.stream(operators).filter(x ->x[0] == 2).count();
        int[] ans = new int[len];
        int cnt = 0;
        for(int i = 0;i < operators.length;i++){
            if(operators[i][0] == 1){
                set(operators[i][1],operators[i][2]);
            }else{
                ans[cnt++] = get(operators[i][1]);
            }
        }
        return ans;
    }

    private void set(int key,int value){
        if(get(key) > -1){
            map.get(key).value = value;
        }else{
            if(map.size() == k){
                int rk = tail.prev.key;
                // 从末尾删除
                tail.prev.prev.next = tail;
                tail.prev = tail.prev.prev;
                map.remove(rk);
            }
            Node node = new Node(key,value);
            map.put(key,node);
            removeToHead(node);
        }
    }

    private int get(int key){
        if(map.containsKey(key)){
            Node node = map.get(key);
            node.prev.next = node.next;
            node.next.prev = node.prev;
            removeToHead(node);
            return node.value;
        }
        return -1;
    }

    private void removeToHead(Node node){
        node.next = head.next;
        head.next.prev = node;
        head.next = node;
        node.prev = head;
    }
}