စာရင်း Leetcode ဖြေရှင်းချက်လှည့်


ခက်ခဲအဆင့် အလယ်အလတ်
မကြာခဏမေးတယ် Adobe က အမေဇုံ ဘလွန်းဘာ့ဂ် Facebook က LinkedIn တို့ Microsoft က Samsung
ချိတ်ဆက်စာရင်း နှစ်ခုထောက်ပြ

Rotate List Leetcode Solution မှကျွန်တော်တို့ကိုချိတ်ဆက်ထားသောစာရင်းနှင့်ကိန်းတစ်ခုပေးသည်။ ချိတ်ဆက်ထားသောစာရင်းအားညာဘက်နေရာများအား k နေရာများသို့လှည့်ရန်ကျွန်ုပ်တို့အားပြောထားသည်။ ဒီတော့ကျနော်တို့ကချိတ်ဆက်ထားတဲ့ list k နေရာတွေကိုညာဘက်သို့လှည့်လိုက်ရင်ခြေလှမ်းတိုင်းမှာနောက်ဆုံး element ကို list ထဲကနေယူပြီး၎င်းမှထည့်လိုက်ပါ။ ကျွန်ုပ်တို့သည်ဤစစ်ဆင်ရေး၏ k အရေအတွက်ကိုပြုကြပြီသည်အထိကျွန်တော်ဒီကိုပြန်လုပ်ပါ။ ဥပမာအချို့ကိုကြည့်ကြစို့။

head = [1,2,3,4,5], k = 2
[4,5,1,2,3]

ရှင်းလင်းချက် - ရိုးရိုးရှင်းရှင်းလည်ပတ်မှု ၂ ခုခွဲထားတယ်။ ထို့ကြောင့်ပထမအဆင့်သို့မဟုတ်ရွေ့လျားမှုတွင်ကျွန်ုပ်တို့သည် element ၏စာရင်း၏အဆုံးမှယူပြီးရှေ့တွင်ထည့်လိုက်သည်။ ထို့ကြောင့်စာရင်းသည် [၅၊ ၁၊ ၂၊ ၃၊ ၄] ဖြစ်လာသည်။ ယခုကျွန်ုပ်တို့သည် ထပ်မံ၍ စာရင်းပြုစုသောတူညီသောလုပ်ငန်းစဉ်ကိုထပ်လုပ် [2, 5, 1, 2, 3] ဤအရပ်မှအဖြေ။

head = [0,1,2], k = 4
[2, 0, 1]

ရှင်းလင်းချက် - လုပ်ငန်းစဉ်ကို ၄ ကြိမ်ထပ်ခါတလဲလဲလုပ်ခြင်းသည်အဖြေနှင့်ဆက်စပ်သောစာရင်းကိုဖြစ်ပေါ်စေသည်။ အောက်ပါပုံကိုကြည့်ခြင်းအားဖြင့်၎င်းကိုပိုမိုနားလည်နိုင်သည်။

စာရင်း Leetcode ဖြေရှင်းချက်လှည့်

လှည့်စာရင်း Leetcode ဖြေရှင်းချက်များအတွက်ချဉ်းကပ်

Rotate List Leetcode Solution မှပြyouနာကသင့်အားလည်ပတ်ရန်အတွက်ကိန်းတစ်ခုနှင့်ချိတ်ဆက်ထားသောစာရင်းတစ်ခုပေးထားသည်ဟုဖော်ပြသည်။ ဆိုလိုသည်မှာကျွန်ုပ်တို့သည် k နေရာများစာရင်းကိုညာဘက်သို့လှည့်ရန်လိုအပ်သည်ကိုဆိုလိုသည်။ စာရင်းရဲ့အဆုံးမှ element များကိုယူပြီးရှေ့တွင်ထားခြင်းကိုရိုးရှင်းစွာလုပ်ဆောင်ခြင်းဖြင့်ပြoperationနာကိုနားလည်နိုင်ပါတယ်။ Element တစ်ခုကိုအဆုံးမှထိရောက်စွာဖယ်ရှား။ ရှေ့တွင်ထားရန်နည်းလမ်းမရှိသောကြောင့်ဖြစ်သည်။ ကျနော်တို့စစ်ဆင်ရေးလုပ်ဆောင်ရန်အခြားမည်သည့်လမ်းစဉ်းစားရန်လိုအပ်သည်။ ကျွန်ုပ်တို့လေ့လာတွေ့ရှိပါက k လုပ်ငန်းများဆောင်ရွက်ပြီးနောက်အဆုံးမှ k element များကိုဖယ်ရှားပြီးရှေ့တွင်နေရာချကြောင်းတွေ့နိုင်ပါသည်။ ဤနေရာတွင်သတိပြုရမည့်အချက်တစ်ခုမှာ k အရွယ်အစားသည်ချိတ်ဆက်ထားသောစာရင်း၏အရွယ်ထက်ကြီးလျှင်ဖြစ်သည်။ ကျနော်တို့ဆက်စပ်စာရင်း၏အရှည်ကျော် k ၏ modulo ယူပါလိမ့်မယ်။

ပြီးတာနဲ့ကျနော်တို့အဆုံးကနေ kth node ကိုသည်အထိဖြတ်သန်းပါလိမ့်မယ်။ ထို့နောက်ကျွန်ုပ်တို့သည်အချို့သောလုပ်ဆောင်မှုများကိုလုပ်ဆောင်ပြီးပါပြီ။ နောက်ဆုံး node ၏နောက်ကို head သို့သတ်မှတ်သည်။ အဆုံးမှ kth node ကိုချိတ်ဆက်ထားသောစာရင်း၏ခေါင်းအဖြစ်သတ်မှတ်ပါ။ သို့သော်ကျွန်ုပ်တို့သည်အဆုံးမှ k-1 node ၏နောက် node ကို null အဖြစ်သတ်မှတ်ခြင်းကိုမမေ့သင့်ပါ။ အခုဒီစစ်ဆင်ရေးသုံးခုကိုလုပ်ပြီးတဲ့နောက်မှာကျနော်တို့စာရင်းကိုလှည့်လိုက်တယ်။

လှည့်စာရင်း Leetcode ဖြေရှင်းချက်များအတွက်ကုဒ်

C ++ ကုဒ်

#include <bits/stdc++.h>
using namespace std;

struct ListNode{
    int data;
    ListNode* next;
};

ListNode* rotateRight(ListNode* head, int k) {
    if(head==NULL || head->next==NULL)return head;

    ListNode *tmp = head;
    int cnt = 0;
    while(tmp)tmp=tmp->next,cnt++;
    tmp=head;
    k%=cnt;
    if(k==0)return head;

    while(k--)tmp = tmp->next;
    ListNode *tmpHead = head;
    while(tmp->next!=NULL){
        tmp = tmp->next;
        head = head->next;
    }
    ListNode* newHead = head->next;
    tmp->next = tmpHead;
    head->next = NULL;
    return newHead;
}

int main(){
    ListNode *head = new ListNode();
    head->data = 0;
    head->next = new ListNode();
    head->next->data = 1;
    head->next->next = new ListNode();
    head->next->next->data = 2;

    head = rotateRight(head, 4);
    while(head != NULL){
        cout<<head->data<<" ";
        head = head->next;
    }
}
2 0 1

ဂျာဗားကုဒ်

import java.util.*;
import java.lang.*;
import java.io.*;

class ListNode{
  int data;
  ListNode next;
}

class Solution {
    public static ListNode rotateRight(ListNode head, int k) {
        if(head==null || head.next==null)return head;
    
        ListNode tmp = head;
        int cnt = 0;
        while(tmp != null){
            tmp=tmp.next;
            cnt++;
        }
        tmp=head;
        k %= cnt;
        if(k==0)return head;

        while(k-- > 0)
            tmp = tmp.next;
        ListNode tmpHead = head;
        while(tmp.next != null){
            tmp = tmp.next;
            head = head.next;
        }
        ListNode newHead = head.next;
        tmp.next = tmpHead;
        head.next = null;
        return newHead;
    }
    
    public static void main(String[] args){
    	ListNode head = new ListNode();
      head.data = 0;
      head.next = new ListNode();
      head.next.data = 1;
      head.next.next = new ListNode();
      head.next.next.data = 2;
  
      head = rotateRight(head, 4);
      while(head != null){
          System.out.print(head.data + " ");
          head = head.next;
      }
    }
}
2 0 1

ရှုပ်ထွေးဆန်းစစ်ခြင်း

အချိန်ရှုပ်ထွေး

အို (N)၊ N သည်ချိတ်ဆက်ထားသောစာရင်း၏အရွယ်အစားကိုကိုယ်စားပြုသည်။ ကျွန်ုပ်တို့သည်ချိတ်ဆက်ထားသောစာရင်းကိုဖြတ်ကျော်ရန်လိုအပ်သောကြောင့်အချိန်ရှုပ်ထွေးမှုမှာ linear ဖြစ်ပြီးစာရင်း၏အရွယ်အစားပေါ်တွင်မူတည်သည်။

အာကာသရှုပ်ထွေးမှု

အို (၁)၊ ကျနော်တို့ node များအသီးအသီးအဘို့အချက်အလက်သိုလှောင်ရန်မလိုအပ်ပါဘူးကတည်းက။ ထို့ကြောင့်အာကာသရှုပ်ထွေးစဉ်ဆက်မပြတ်ဖြစ်ပါတယ်။