leetcode

1、 Z 字形变换

将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 "LEETCODEISHIRING" 行数为 3 时，排列如下：

L   C   I   R
E T O E S I I G
E   D   H   N

之后，你的输出需要从左往右逐行读取，产生出一个新的字符串，比如："LCIRETOESIIGEDHN"。

请你实现这个将字符串进行指定行数变换的函数：

string convert(string s, int numRows);

示例 1:

输入: s = "LEETCODEISHIRING", numRows = 3
输出: "LCIRETOESIIGEDHN"

示例 2:

输入: s = "LEETCODEISHIRING", numRows = 4
输出: "LDREOEIIECIHNTSG"
解释:

L     D     R
E   O E   I I
E C   I H   N
T     S     G

 

 复杂度分析

    时间复杂度：O(n)O(n)O(n)，其中 n==len(s)n == \text{len}(s)n==len(s)。每个索引被访问一次。
    空间复杂度：O(n)O(n)O(n)。对于 C++ 实现，如果返回字符串不被视为额外空间，则复杂度为 O(1)O(1)O(1)。

class Solution {
    public String convert(String s, int numRows) {
        if (numRows == 1) return s;
        StringBuilder str=new StringBuilder();
        int n=s.length();
        int length=2*numRows-2;
        for(int i=0;i<numRows;i++){
            for(int j=0;j+i<n;j+=length){
                str.append(s.charAt(j+i));
                if(i!=0&&i!=numRows-1&&j+length-i<n){
                    str.append(s.charAt(j+length-i));
                }
            }
        }
        return str.toString();
    }
}

24. 两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

 

示例:

给定 1->2->3->4, 你应该返回 2->1->4->3.

方法二：迭代

我们把链表分为两部分，即奇数节点为一部分，偶数节点为一部分，A 指的是交换节点中的前面的节点，B 指的是要交换节点中的后面的节点。在完成它们的交换，我们还得用 prevNode 记录 A 的前驱节点。

算法：

    firstNode（即 A） 和 secondNode（即 B） 分别遍历偶数节点和奇数节点，即两步看作一步。
    交换两个节点：

 firstNode.next = secondNode.next
 secondNode.next = firstNode

    还需要更新 prevNode.next 指向交换后的头。

prevNode.next = secondNode

    迭代完成后得到最终的交换结果。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {

        // Dummy node acts as the prevNode for the head node
        // of the list and hence stores pointer to the head node.
        ListNode dummy = new ListNode(-1);
        dummy.next = head;

        ListNode prevNode = dummy;

        while ((head != null) && (head.next != null)) {

            // Nodes to be swapped
            ListNode firstNode = head;
            ListNode secondNode = head.next;

            // Swapping
            prevNode.next = secondNode;
            firstNode.next = secondNode.next;
            secondNode.next = firstNode;

            // Reinitializing the head and prevNode for next swap
            prevNode = firstNode;
            head = firstNode.next; // jump
        }

        // Return the new head node.
        return dummy.next;
    }
}

复杂度分析

• 时间复杂度：O(N)O(N)O(N)，其中 NNN 指的是链表的节点数量。
• 空间复杂度：O(1)O(1)O(1)。

31. 下一个排列

实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。

如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。

必须原地修改，只允许使用额外常数空间。

以下是一些例子，输入位于左侧列，其相应输出位于右侧列。
1,2,3 → 1,3,2
3,2,1 → 1,2,3
1,1,5 → 1,5,1

 

 

 

 

 

class Solution {
    public void nextPermutation(int[] nums) {
        int p=nums.length-2;
        while(p>=0&&nums[p]>=nums[p+1]){
            p--;
        }
        if(p>=0){
            int i=nums.length-1;
            while(i>=0&&nums[i]<=nums[p]){           
                    i--;
            }
            swap(nums,p,i);
        }reverse(nums,p+1);
    }
    public static void swap(int[] nums,int i,int j){
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }
    public static void reverse(int[] nums,int i){
        int j=nums.length-1;
        while(i<j){
        swap(nums,i,j);
        i++;
        j--;
        }

    }
}

 

 

300. 最长上升子序列

 

给定一个无序的整数数组，找到其中最长上升子序列的长度。

 

示例:

 

输入: [10,9,2,5,3,7,101,18]
输出: 4 
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

public class Solution {
    public int lengthOfLIS(int[] nums) {
        if (nums.length == 0) {
            return 0;
        }
        int[] dp = new int[nums.length];
        dp[0] = 1;
        int maxans = 1;
        for (int i = 1; i < dp.length; i++) {
            int maxval = 0;
            for (int j = 0; j < i; j++) {
                if (nums[i] > nums[j]) {
                    maxval = Math.max(maxval, dp[j]);
                }
            }
            dp[i] = maxval + 1;
            maxans = Math.max(maxans, dp[i]);
        }
        return maxans;
    }
}

 

 

300. 最长上升子序列 给定一个无序的整数数组，找到其中最长上升子序列的长度。 示例: 输入: [10,9,2,5,3,7,101,18] 输出: 4 解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。 public class Solution { public int lengthOfLIS(int[] nums) { if (nums.length == 0) { return 0; } int[] dp = new int[nums.length]; dp[0] = 1; int maxans = 1; for (int i = 1; i < dp.length; i++) { int maxval = 0; for (int j = 0; j < i; j++) { if (nums[i] > nums[j]) { maxval = Math.max(maxval, dp[j]); } } dp[i] = maxval + 1; maxans = Math.max(maxans, dp[i]); } return maxans; } }

[300. Zuì zhǎng shàngshēng zǐ xùliè gěi dìng yīgè wú xù de zhěngshù shùzǔ, zhǎodào qízhōng zuì zhǎng shàngshēng zǐ xùliè de chángdù. Shìlì: Shūrù: [10,9,2,5,3,7,101,18] Shūchū: 4 Jiěshì: Zuì zhǎng de shàngshēng zǐ xùliè shì [2,3,7,101], tā de chángdù shì 4. Public class Solution { public int lengthOfLIS(int[] nums) { if (nums.Length == 0) { return 0; } int[] dp = new int[nums.Length]; dp[0] = 1; int maxans = 1; for (int i = 1; i < dp.Length; i++) { int maxval = 0; for (int j = 0; j < i; j++) { if (nums[i] > nums[j]) { maxval = Math.Max(maxval, dp[j]); } } dp[i] = maxval + 1; maxans = Math.Max(maxans, dp[i]); } return maxans; } }]

300. The rise longest sequence


A disorder of a given integer array, the length of the longest found rising sequence.


Example:


Input: [10,9,2,5,3,7,101,18]
Output: 4
Interpretation: longest sequence is increased [2,3,7,101], its length is 4.

public class Solution {
public int lengthOfLIS (int [] nums) {
if (nums.length == 0) {
return 0;
}
int [] dp = new int [nums.length];
dp [0] = 1;
int maxans = 1;
for (int i = 1; i <dp.length; i ++) {
int maxval = 0;
for (int j = 0; j <i; j ++) {
if (nums [i]> nums [j]) {
maxval = Math.max (maxval, dp [j]);
}
}
dp [i] = maxval + 1;
maxans = Math.max (maxans, dp [i]);
}
return maxans;
}
}