प्रौद्योगिकी साझेदारी

चयनित लिकोउ, न्यूकेलियन पृष्ठ परीक्षण प्रश्न

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

💎 欢迎各位大佬互三：मम मुखपृष्ठम्

1. लिङ्क् कृतसूचीं विपर्ययम्

206.विपरीतलिङ्कितसूची

चिन्तनम् : यदि भवान् अतिरिक्तं स्थानं न उद्घाटयति तथा च केवलं मूललिङ्क् कृतसूचीं परिवर्तयति तर्हि का पद्धतिः प्रयोक्तव्या?

केवलं द्वितीयतत्त्वात् आरभ्य क्रमेण शिरःप्रवेशं कुर्वन्तु ।

ततः केवलं सन्दर्भं परिवर्तयन्तु, अन्तिमं तत्त्वं च null इति दर्शयन्तु

  1. class Solution {
  2.     public ListNode reverseList(ListNode head) {
  3.         //head为null，直接返回
  4.         if(head == null){
  5.             return head;
  6.         }
  7.  
  8.         ListNode cur = head.next;
  9.         //head变为了末尾元素，指向null
  10.         head.next = null;
  11.         while(cur!=null){
  12.             //curn为cur的next节点，便于往后移动
  13.             ListNode curn = cur.next;    
  14.             cur.next = head;
  15.             head = cur;
  16.             //更新cur
  17.             cur = curn;
  18.         }
  19.         return head;
  20.     }
  21. }

2. लिङ्क् कृतस्य सूचीयाः मध्यमः नोड्

876. लिङ्क्ड् सूचीयाः मध्यवर्ती नोड्

अस्य प्रश्नस्य कृते प्रथमः विधिः यः मनसि आगच्छति सः निश्चितरूपेण cnt परिभाषितुं, एकवारं लिङ्क् कृतं सूचीं भ्रमितुं, ततः मध्यसङ्ख्यां अन्वेष्टुम्, ततः रिटर्न् मूल्यं पारयितुं च एषा विधिः अतीव सरलः अस्ति, परन्तु यदि भवन्तः the traverse कर्तुं प्रवृत्ताः सन्ति तर्हि किम् मध्यवर्ती नोड् अन्वेष्टुं केवलं एकवारं सूचीं लिङ्क् कृतवती?

अत्र एकः नूतनः विचारः अस्ति: द्रुत-मन्द-सूचकानाम् उपयोगं कुर्वन्तु, शिरःतः आरभ्य द्रुत-सूचकः प्रत्येकं समये एकं नोडं चालयति, किं च एतेन परमं लक्ष्यं प्राप्यते?

ततः तत् कार्यान्वयामः : १.

  1. class Solution {
  2.     public ListNode middleNode(ListNode head) {
  3.         if(head == null){
  4.             return null;
  5.         }
  6.         ListNode fast = head;
  7.         ListNode slow = head;
  8.         while(fast!= null&&fast.next!= null){
  9.             fast = fast.next.next;
  10.             slow = slow.next;
  11.         }
  12.         return slow;
  13.     }
  14. }

किं एतत् अधिकं कार्यक्षमं स्यात् ?

3. अन्तिमतः k-th नोड् प्रत्यागच्छतु

साक्षात्कारप्रश्नः 02.02 अन्तिमतः k-th नोड् प्रत्यागच्छतु

अस्य प्रश्नस्य प्रथमं मनसि आगच्छति यत् कुलदीर्घतां प्राप्तुं एकवारं तस्य परिभ्रमणं करणीयम्, ततः अन्तिमतः k-th नोड् अन्वेष्टुम् तथापि पूर्वप्रश्नस्य आधारेण अन्यं पद्धतिं चिन्तयितुं शक्यते तथा च .द्रुत-मन्द-सूचकानाम् उपयोगेन प्रथमं k-1 नोड्स् शीघ्रं गच्छन्तु, ततः मन्दं द्रुतं च एकस्मिन् समये गच्छन्तु यदा द्रुतस्य अग्रिमः शून्यः भवति तदा तस्य अर्थः भवति यत् द्रुतं अन्तिमं नोड् प्राप्तवान्, अस्मिन् समये च मन्दम् इति क-थः ग्रन्थिः अधस्तात् ।

अयं प्रश्नः सूचयति यत् निवेशः k कानूनी अस्ति, अतः k अवैधः अस्ति वा इति कथं न्यायः करणीयः, तथा च आवश्यकं यत् लिङ्क् कृतस्य सूचीयाः दीर्घता प्रत्यक्षतया न लभ्यते, अतः गच्छन् मन्दं न्यायं कर्तुं आवश्यकम्।

  1. class Solution {
  2.     public int kthToLast(ListNode head, int k) {
  3.         if (head == null) {
  4.             return -1;
  5.         }
  6.         ListNode fast = head;
  7.         ListNode slow = head;
  8.         int cnt = 0;
  9.         while (cnt != k - 1) {
  10.             //判断k的合法性，虽然本题不用判断
  11.             fast = fast.next;
  12.             if(fast == null){
  13.                 return;
  14.             }
  15.             cnt++;
  16.         }
  17.         //slow和fast同时移动
  18.  
  19.         while (fast.next != null) {
  20.             fast = fast.next;
  21.             slow = slow.next;
  22.         }
  23.         return slow.val;
  24.     }
  25. }

4. लिङ्क् कृतानि सूचीनि विलीनयन्तु

21. क्रमबद्धलिङ्कितसूचौ विलीनं कुर्वन्तु

विचारं:भवद्भिः केवलं नूतनं नोड् newH परिभाषितुं आवश्यकम्, ततः headA तथा headB इत्येतयोः val इत्यस्य तुलना करणीयम् अन्ततः विलयितस्य लिङ्क्ड् सूचीयाः head नोड् अन्वेष्टुं, भवन्तः tmp = newH इत्यपि परिभाषितुं प्रवृत्ताः सन्ति, ततः यस्य लघुतरं भवति tmp.next तत् सूचयिष्यति।

  1. class Solution {
  2.     public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
  3.         ListNode head = new ListNode();
  4.         ListNode tmp = head;
  5.     
  6.         while(list1!=null&&list2!=null){
  7.             if(list1.val < list2.val){
  8.                 tmp.next = list1;
  9.                 list1 = list1.next;
  10.                 tmp = tmp.next;
  11.             }else{
  12.                 tmp.next = list2;
  13.                 list2 = list2.next;
  14.                 tmp = tmp.next;
  15.             }
  16.         }
  17.         //判断剩余的情况
  18.         if(list1!=null){
  19.             tmp.next = list1;
  20.         }else if(list2!=null){
  21.             tmp.next = list2;
  22.         }
  23.         return head.next;
  24.     }
  25. }

5. लिङ्क्ड् सूची विभक्तम्

CM11 लिङ्क्ड् सूची विभक्तम्

एषः Niuke इत्यस्य विषये साक्षात्कारप्रश्नः अस्ति ।

विचारः : मूललिङ्क्ड् सूचीं पारयितुं (मूललिङ्क्ड् सूचीं परिवर्तनं न भवेत् इति निवारयितुं), x इत्यस्मात् बृहत्तरं सर्वं लिङ्क्ड् सूचीयां स्थापयित्वा, x इत्यस्मात् लघुतरं सर्वं लिङ्क्ड् सूचीयां स्थापयन्तु, अन्ते च द्वयोः संयोजयितुं नूतनं नोड् cur परिभाषयन्तु लिङ्क् कृताः सूचीः।

  1. public class Partition {
  2.     public ListNode partition(ListNode pHead, int x) {
  3.         ListNode bs = null;
  4.         ListNode be = null;
  5.         ListNode as = null;
  6.         ListNode ae = null;
  7.         ListNode cur = pHead;
  8.         while (cur != null) {
  9.             if (cur.val < x) {
  10.                 //处理刚开始为null的情况
  11.                 if (bs == null) {
  12.                     bs = be = cur;
  13.                 }else{
  14.                     be.next = cur;
  15.                     be = be.next;
  16.                 }
  17.             }else{
  18.                 if(as == null){
  19.                     as = ae = cur;
  20.                 }else{
  21.                     ae.next = cur;
  22.                     ae = ae.next;
  23.                 }
  24.             }
  25.             cur = cur.next;
  26.         }
  27.         //都是比x大的情况
  28.         if(bs == null){
  29.             return as;
  30.         }
  31.         be.next = as;
  32.         //最后都要置为null，不然可能会报错
  33.         if(as!=null){
  34.             ae.next = null;
  35.         }
  36.         return bs;
  37.     }
  38. }

ज्ञातव्यं यत् यदि ते x इत्यस्मात् बृहत्तराः सन्ति अर्थात् bs = null, तर्हि as प्रत्यक्षतया प्रत्यागमिष्यति, यदि च as.next अन्ते null इति सेट् भवति

6. OR36 लिङ्क्ड् सूचीयाः पैलिण्ड्रोम संरचना

OR36 लिङ्क्ड् सूचीयाः palindrome संरचना

एषः Niuke इत्यस्य प्रश्नः अस्ति, यतः अस्य समयजटिलता अस्ति तथा च अन्तरिक्षजटिलतायाः आवश्यकताः सन्ति, यस्य अर्थः अस्ति यत् भवान् अतिरिक्तं सरणीं उद्घाटयितुं न शक्नोति, अन्यथा अन्तरिक्षजटिलता न अतिक्रान्तं भविष्यति, तथा च सामान्ययात्रायां O(n) इत्यस्य जटिलता भविष्यति ।

विचारः एतादृशः अस्ति यत् प्रथमं लिङ्क् कृतस्य सूचीयाः मध्यमं नोडं मन्दं अन्वेष्टुम्, ततः मध्यतः अन्त्यपर्यन्तं भागं विपर्यस्तं कुर्वन्तु, मन्दं नोड् अपि पृष्ठतः भ्रमति मूल्यानि भिन्नानि सन्ति, ते पाठसंरचना न प्रत्यागच्छन्ति इति अर्थः

लिङ्क्ड् सूचीं विपर्ययितुं मध्यवर्ती नोड् अन्वेष्टुं च पूर्वं अभ्यासः कृतः अस्ति

  1. public class PalindromeList {
  2.     public boolean chkPalindrome(ListNode head) {
  3.         if (head == null) {
  4.             return true;
  5.         }
  6.         //找到中间节点
  7.         ListNode fast = head;
  8.         ListNode slow = head;
  9.         while (fast != null && fast.next != null) {
  10.             fast = fast.next.next;
  11.             slow = slow.next;
  12.         }
  13.         //从slow开始到末尾反转
  14.         ListNode cur = slow.next;
  15.         while (cur != null) {
  16.             ListNode curn = cur.next;
  17.             cur.next = slow;
  18.             slow = cur;
  19.             cur = curn;
  20.         }
  21.         //判断回文
  22.         while (head != slow) {
  23.             if (head.val != slow.val) {
  24.                 return false;
  25.             }
  26.             //判断偶数节点
  27.             if (head.next == slow) {
  28.                 return true;
  29.             }
  30.             head = head.next;
  31.             slow = slow.next;
  32.         }
  33.         return true;
  34.     }
  35. }

विषमसङ्ख्यायुक्तानां नोडानां लिङ्क्ड् सूचीयाः समसङ्ख्यायुक्तानां नोड्स् इत्यस्य लिङ्क्ड् सूचीयाः च निर्णये अपि भेदः अस्ति इति ज्ञातव्यम् ।

यदि समसङ्ख्यायुक्तः नोडः उपरि स्थानान्तरितः भवति तर्हि अनन्तं पाशं जनयिष्यति, अतः समसङ्ख्यायुक्तस्य नोडस्य कृते अतिरिक्तविवेकस्य आवश्यकता भवति ।

7. प्रतिच्छेदिताः लिङ्क् कृताः सूचीः

160. प्रतिच्छेदिताः लिङ्क् कृताः सूचीः

प्रतिच्छेदनं सम्बद्धा सूची "Y" इत्यस्य सदृशं परिवर्तनम् अस्ति, यथा चित्रे दर्शितम् अस्ति

अधोलिखिते प्रश्ने चित्रम् अपि अतीव स्पष्टम् अस्ति।

विचारः यतः A लघुः अस्ति वा B लघुः अस्ति वा, तेषां मध्ये अन्तरं भवति यत् भवन्तः केवलं दीर्घं लिङ्क् कृतं सूचीं भेदेन चालयितुं शक्नुवन्ति, ततः द्वौ लिङ्क् कृतौ सूची नोडौ एकस्मिन् समये पश्चात् गच्छतः समानग्रन्थिः प्रतिच्छेदनं कर्तुं भवति

  1. public class Solution {
  2.     public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
  3.         ListNode pl = headA;
  4.         ListNode ps = headB;
  5.         int cnta = 0,cntb = 0;
  6.         //计算两个链表的长度
  7.         while(pl!=null){
  8.             pl = pl.next;
  9.             cnta++;
  10.         }
  11.         while(ps!=null){
  12.             ps = ps.next;
  13.             cntb++;
  14.         }
  15.         //如果链表b长，就更新pl,ps
  16.         int len = cnta - cntb;
  17.         //上面求长度时pl,ps都为空了，所以这里再重新指向
  18.         pl = headA;
  19.         ps = headB;
  20.         if(len < 0){
  21.             pl = headB;
  22.             ps = headA;
  23.             len = cntb - cnta;
  24.         }
  25.         //移动差值
  26.         while(len!=0){
  27.             pl = pl.next;
  28.             len--;
  29.         }
  30.         //找到相交节点
  31.         while(pl!=ps){
  32.             pl = pl.next;
  33.             ps = ps.next;
  34.         }
  35.         //链表不相交的情况
  36.         if(pl == null) return null;
  37.         return pl;
  38.     }
  39. }

अन्ते अस्माभिः विसंगतस्थितिः योजयितव्या यद्यपि वयं एतत् प्रश्नं न योजयित्वा पारयितुं शक्नुमः तथापि कठोरतायां योजयितुं आवश्यकम्।

8. परिपत्रलिङ्कितसूची

८.१ पाशः अस्ति वा इति निर्धारयतु

141. परिपत्रलिङ्कितसूची

लिङ्क् कृतसूचिकायाः ​​चक्रं भवति वा इति कथं निर्धारयितुं शक्यते :अद्यापि वेगसूचकस्य उपयोगं कुर्वन्तु, यथा द्वौ जनाः क्रीडाङ्गणे धावन्ति, एकः व्यक्तिः द्रुतं धावति अपरः व्यक्तिः मन्दं धावति यतः क्रीडाङ्गणं वलयम् अस्ति, द्रुतगतिः मन्दं अवश्यमेव अतिक्रमितुं शक्नोति , परन्तु यदि तमाकी न स्यात् तर्हि ते कदापि मिलितुं न शक्नुवन्ति स्म, यथा देवी भवन्तः कियत् अपि कठिनतया अनुसरणं कृत्वा अपि ग्रहीतुं न शक्नुवन्ति।

परन्तु अन्यत् स्थितिः अस्ति यदि एतत् द्वौ नोड् युक्तः रिंगः अस्ति, तथा च परिभाषितः द्रुतसूचकः एकस्मिन् समये ३ पदानि गृह्णाति तथा च मन्दसूचकः एकैकं पदानि गृह्णाति, तर्हि ते कदापि न मिलन्ति

अतः परिभाषितसूचकाः प्रत्येकं समये कियन्तः पदानि गृह्णन्ति इति न्याययितुं आवश्यकं यदि एकः २ पदानि गृह्णाति अपरः १ पदानि गृह्णाति तर्हि ते निश्चितरूपेण मिलन्ति ।

  1. public class Solution {
  2.     public boolean hasCycle(ListNode head) {
  3.         ListNode fast = head;
  4.         ListNode slow = head;
  5.         while(fast!=null&&fast.next!=null){
  6.             fast = fast.next.next;
  7.             slow = slow.next;
  8.             if(fast == slow) return true;
  9.         }
  10.         return false;
  11.     }
  12. }

8.2 रिंग प्रवेशद्वारे नोडं प्रत्यागच्छतु

142. परिपत्रसम्बद्धसूची II

अस्मिन् समये पूर्वप्रश्ने वलयम् अस्ति वा इति न्याय्य रिंगमध्ये प्रवेशबिन्दुः ज्ञातव्यः

  1. public class Solution {
  2.     public ListNode detectCycle(ListNode head) {
  3.         ListNode fast = head;
  4.         ListNode slow = head;
  5.         //判断环
  6.         while(fast!=null&&fast.next!=null){
  7.             fast = fast.next.next;
  8.             slow = slow.next;
  9.             if(fast == slow) break;
  10.         }
  11.         if(fast == null||fast.next == null) return null;
  12.         slow = head;
  13.         //寻找环
  14.         while(slow!=fast){
  15.             slow = slow.next;
  16.             fast = fast.next;
  17.         }
  18.         return slow;
  19.     }
  20. }

यत् योजयितव्यं तत् अस्ति : १.

यदा वलयः अतीव लघुः भवति तदा अन्तिमः सरलीकरणपरिणामः उपरिष्टाद् भवति, परन्तु मूलसङ्केतः अद्यापि सुष्ठु अस्ति ।

व्यक्तिगत प्रोफाइल

सः ३० वर्षाणाम् अनुसरणं प्रौयोगिक क्रमबद्धता युक्तं, आलंकार, जावा, जावास्विस्च, ph, css, सद्भावना संस्कृती, ph, css निर्वहनशील भाषा सुनावंश, ससरोत विद्वान विपक्षी विद्वान विनियोग विनियोग विनियोग विनियोग्य विवेचन विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग विनियोग

मम सम्पर्कसूचना

मेल