বাছাই করা অ্যারেতে দুটি সাজানো অ্যারে কীভাবে মার্জ করবেন? [বন্ধ]


160

এটি একটি সাক্ষাত্কারে আমার কাছে জিজ্ঞাসা করা হয়েছিল এবং এটিই আমার দেওয়া সমাধান:

public static int[] merge(int[] a, int[] b) {

    int[] answer = new int[a.length + b.length];
    int i = 0, j = 0, k = 0;
    while (i < a.length && j < b.length)
    {
        if (a[i] < b[j])
        {
            answer[k] = a[i];
            i++;
        }
        else
        {
            answer[k] = b[j];
            j++;
        }
        k++;
    }

    while (i < a.length)
    {
        answer[k] = a[i];
        i++;
        k++;
    }

    while (j < b.length)
    {
        answer[k] = b[j];
        j++;
        k++;
    }

    return answer;
}

এটি করার আরও কার্যকর উপায় আছে?

সম্পাদনা করুন: দৈর্ঘ্যের পদ্ধতি সংশোধন করা হয়েছে।


30
আমার কাছে বেশ সুন্দর উত্তর বলে মনে হচ্ছে। এই সমস্যায় সর্বোত্তমভাবে ও (এন) জটিলতা থাকবে এবং আপনার উত্তর এটি অর্জন করবে। আর কিছু হ'ল মাইক্রোপটিমাইজেশন।
ড্রু হল

3
তুমি ভালই করেছো! এটি মূলত মার্জ সাজানোর একটি অংশ: দুটি বাছাই করা স্ট্রিমগুলি (টেপ বা ডিস্ক থেকে) অন্য সাজানো স্ট্রিমে মার্জ করা।
ভ্লাদিমির ডিউজেভ

9
কাজ পেয়েছেন?
শাই

5
এছাড়াও আপনি টের্নারি অপারেটর ব্যবহার করতে পারেন: while (i < a.length && j < b.length) answer[k++] = a[i] < b[j] ? a[i++] : b[j++]; জাভা ভাষার স্পেসিফিকেশন: শর্তাধীন অপারেটর? :
আন্তন ডোজার্টসেভ

1
আপনি মন্তব্য করতে ভুলে গেছেন !!!
লিজিপিজি

উত্তর:


33

একটি সামান্য উন্নতি, কিন্তু প্রধান লুপের পরে, আপনি System.arraycopyঅন্যটির শেষে পৌঁছালে আপনি কোনও ইনপুট অ্যারের লেজ অনুলিপি করতে ব্যবহার করতে পারেন । O(n)যদিও এটি আপনার সমাধানের কর্মক্ষমতা বৈশিষ্ট্যগুলিকে পরিবর্তন করবে না won't


109
public static int[] merge(int[] a, int[] b) {

    int[] answer = new int[a.length + b.length];
    int i = 0, j = 0, k = 0;

    while (i < a.length && j < b.length)  
       answer[k++] = a[i] < b[j] ? a[i++] :  b[j++];

    while (i < a.length)  
        answer[k++] = a[i++];

    while (j < b.length)    
        answer[k++] = b[j++];

    return answer;
}

কিছুটা কমপ্যাক্ট হলেও ঠিক একই রকম!


যে ব্যক্তি এই বলেছিল যে কোনও সূচককে সীমার ব্যতিক্রম ছাড়িয়েছে আপনি কী ইনপুট ব্যবহার করছেন? এটি আমার জন্য সব ক্ষেত্রেই কাজ করে।
মাইক সোল

1
লুপের ভেরিয়েবল এবং লুপ নিয়ন্ত্রণের ঘোষণা করে লাইনগুলিকে মার্জ করতে লুপের জন্য একটি ব্যবহার করুন। কিছুটা ফাঁক করে ডাবল ফাঁকা রেখা ব্যবহার করুন - প্রতিসাম্প্রদায়ী "লেজের অনুলিপি" এর মধ্যে অবরুদ্ধ দেখায়।
গ্রেইবার্ড

58

আমি অবাক হয়েছি যে এর চেয়ে বেশি দুর্দান্ত, দক্ষ এবং কমপ্যাক্ট বাস্তবায়নের কথা কেউ উল্লেখ করেনি:

public static int[] merge(int[] a, int[] b) {
    int[] answer = new int[a.length + b.length];
    int i = a.length - 1, j = b.length - 1, k = answer.length;

    while (k > 0)
        answer[--k] =
                (j < 0 || (i >= 0 && a[i] >= b[j])) ? a[i--] : b[j--];
    return answer;
}

আগ্রহের বিষয়

  1. লক্ষ্য করুন যে এটি অন্য ও (এন) অ্যালগরিদমের মতো একই বা কম সংখ্যক ক্রিয়াকলাপ করে তবে আক্ষরিকভাবে একক বিবৃতিতে লুপের সময়!
  2. যদি দুটি অ্যারে প্রায় একই আকারের হয় তবে ও (এন) এর জন্য ধ্রুবক একই। তবে যদি অ্যারেগুলি সত্যই ভারসাম্যহীন হয় তবে এর সাথে সংস্করণগুলি System.arraycopyজিততে পারে কারণ অভ্যন্তরীণভাবে এটি একক x86 সমাবেশ নির্দেশের সাহায্যে এটি করতে পারে।
  3. a[i] >= b[j]পরিবর্তে লক্ষ্য করুন a[i] > b[j]। এটি "স্থায়িত্ব" এর গ্যারান্টি দেয় যা সংজ্ঞায়িত হয় যখন a এবং b এর উপাদানগুলি সমান হয়, আমরা খ এর আগে একটি থেকে উপাদান চাই।

এটি একটি সত্যিই দুর্দান্ত পদ্ধতির। সুইফ্ট ল্যাং-এ আমার মার্জ বাছাই অ্যালগরিদমগুলিতে ভাল মানদণ্ড পেতে আমার সমস্যা হয়েছিল। এটিকে রূপান্তর করা আমাকে যা প্রয়োজন তা দিয়েছে, অনেক ধন্যবাদ
চ্যাকেল

লুপের (জে <0) এর বিন্দুটি কী? বিটিডব্লিউ, +1, এটি সত্যিই দুর্দান্ত! ভাগ করে নেওয়ার জন্য ধন্যবাদ.
হেনগামেহ

2
@Hengameh ক্ষেত্রে j < 0, bইতিমধ্যে ক্লান্ত হয় তাই আমরা অবশিষ্ট যোগ রাখা aউপাদান answer অ্যারের
Natan Streppel

6
খুব "চালাক" এবং মনে মনে পড়া খুব কঠিন। আমি কোড পড়তে সহজতর পছন্দ করি বিশেষত যেহেতু আপনি এই কোডটির সাহায্যে কোনও কার্যকারিতা উন্নতি করতে পারেন না।
কেভিন এম

1
নোটিশের জন্য প্লাস পয়েন্ট এবং একটি [i]> = বি [জে] এর পরিবর্তে একটি [আই]> বি [জে]। এটি "স্থিতিশীলতার" গ্যারান্টি দেয়
ইয়ান খোন্সকি

16

যে কোনও উন্নতি করা যেতে পারে তা হবে মাইক্রো-অপটিমাইজেশন, সামগ্রিক অ্যালগোরিদম সঠিক।


যদি একটি বড় হয় এবং খ ছোট হয় তবে এই অ্যালগরিদমটি ভুল।
জ্যাক

7
এটি ভুল নয় তবে দক্ষ নয়।
জ্যাক

@ জ্যাক আপনি কীভাবে ও (এন) এর চেয়ে দ্রুত কাজ করতে পারবেন যখন আপনি এন আইটেমগুলির একটি অ্যারে তৈরি করছেন?
উইল

@ System.arrayCopy()সিপিইউ-অপ্টিমাইজড memcpyকলগুলি ব্যবহার করার সাথে সাথে এটি মূর্খতার সাথে দ্রুত । সুতরাং খণ্ডগুলি অনুলিপি করে কর্মক্ষমতা উন্নত করার সুযোগ রয়েছে। সীমাগুলির জন্য বাইনারি অনুসন্ধানের সুযোগও রয়েছে।
পাতলা

বিশেষত যদি আপনি বেশিরভাগ এন্ট্রি এড়াতে বাছাই করা প্রকৃতিটি ব্যবহার করতে পারেন এবং কখনই সেগুলি তুলনা করেন না। আপনি আসলে ও (এন) কে মারতে পারেন।
তাতারাইজ

10

অন্যান্য অ্যারের উপাদানগুলি অনুলিপি করতে System.arrayCopy ব্যবহার করা বাদে এই সমাধানটি অন্যান্য পোস্টগুলির সাথেও খুব মিল।

private static int[] sortedArrayMerge(int a[], int b[]) {
    int result[] = new int[a.length +b.length];
    int i =0; int j = 0;int k = 0;
    while(i<a.length && j <b.length) {
        if(a[i]<b[j]) {
            result[k++] = a[i];
            i++;
        } else {
            result[k++] = b[j];
            j++;
        }
    }
    System.arraycopy(a, i, result, k, (a.length -i));
    System.arraycopy(b, j, result, k, (b.length -j));
    return result;
}

7

এখানে ফাংশন আপডেট করা হয়। এটি সদৃশগুলি সরিয়ে দেয়, আশা করি কেউ এটি ব্যবহারযোগ্য হিসাবে আবিষ্কার করবে:

public static long[] merge2SortedAndRemoveDublicates(long[] a, long[] b) {
    long[] answer = new long[a.length + b.length];
    int i = 0, j = 0, k = 0;
    long tmp;
    while (i < a.length && j < b.length) {
        tmp = a[i] < b[j] ? a[i++] : b[j++];
        for ( ; i < a.length && a[i] == tmp; i++);
        for ( ; j < b.length && b[j] == tmp; j++);
        answer[k++] = tmp;
    }
    while (i < a.length) {
        tmp = a[i++];
        for ( ; i < a.length && a[i] == tmp; i++);
        answer[k++] = tmp;
    }
    while (j < b.length) {
        tmp = b[j++];
        for ( ; j < b.length && b[j] == tmp; j++);
        answer[k++] = tmp;
    }
    return Arrays.copyOf(answer, k);
}

+1, ভাগ করে নেওয়ার জন্য ধন্যবাদ। একটি প্রশ্ন: আপনি কেন অ্যারে এবং ভেরিয়েবলের 'টাইপ' ধরণের টাইপ দীর্ঘ নির্বাচন করেছেন?
হেনগামে

(পদ্ধতির নাম সম্পর্কে আমার সন্দেহ আছে))
গ্রেইবার্ড

5

এটি নীচে হিসাবে 4 টি স্টেটমেন্টে করা যেতে পারে

 int a[] = {10, 20, 30};
 int b[]= {9, 14, 11};
 int res[]=new int[a.legth+b.length]; 
 System.arraycopy(a,0, res, 0, a.length); 
 System.arraycopy(b,0,res,a.length, b.length);
 Array.sort(res)


5
এই উত্তর কেন নেতিবাচক ভোট পেয়েছে তা আমি বুঝতে পারি না। এটি কার্যকর যে এটি দক্ষ নয়। তবে কখনও কখনও আপনার যা প্রয়োজন তা হ'ল যত তাড়াতাড়ি সম্ভব কাজটি করা। যদি আপনি খুব ছোট অ্যারে নিয়ে কাজ করে থাকেন তবে 100 টিরও কম উপাদান বলুন, আমি একটি দীর্ঘ কোড লিখার চেয়ে উপরের কোডটি ব্যবহার করতে পছন্দ করব যা কোনও গুরুত্বপূর্ণ পারফরম্যান্সের উন্নতি করবে না। সুতরাং, সুধীরকে এই সহজ সমাধান সরবরাহ করার জন্য ধন্যবাদ এবং এটি সম্পাদনার জন্য এসএনএএন 3 thanks
আহমেদভ

2
অলিখিত লিখিত ধারণাটি হ'ল কোনও sortফাংশন বাছাই করার পদ্ধতি হিসাবে নিজেকে ব্যবহার করতে পারে না। এটি পুনরাবৃত্তি পরিবর্তে অসীম রিগ্রেশন হবে। এছাড়াও অন্যান্য ভিত্তিটি হ'ল মার্জ_আরেই হ'ল ফাংশন যা সাজানোর প্রয়োগ করে। এই উত্তরটি সম্ভবত সম্ভাব্য প্রেক্ষাপটে অব্যর্থ।
আকি সুহিকনেন

জিজ্ঞাসিত প্রশ্নটিতে উল্লেখ করা হয়নি যে প্রয়োজনীয় কোডটি কেবলমাত্র ছোট অ্যারের জন্য ছিল। সুতরাং এই উত্তরটি বিভ্রান্তিকর হবে যদি না এটি স্পষ্টভাবে এর সীমাবদ্ধতা বর্ণনা করে। নীচে আমার উত্তর দেখুন। কোনও কার্যকর অ্যারে আকারের জন্য কার্যকর কোডটি লিখতে একই সংখ্যক লাইনের দরকার পড়ে :)
শীতল শাহ

প্রশ্নটি বর্ণিত হয়েছিল যে অ্যারেগুলি ইতিমধ্যে সাজানো হয়েছে are অ্যারেগুলি যদি খুব বড় হতে পারে তবে এই দ্রবণটি থামতে হবে এবং খারাপভাবে পারফর্ম করবে। সুতরাং নিশ্চিত হয়ে নিন যে আপনি প্রয়োজনীয় শেষ ফলাফল পেয়ে যাবেন, কিন্তু অ্যাপটি সম্পাদন করবে না এবং আমি যদি সাক্ষাত্কার দিচ্ছিলাম তবে আপনি চাকরি পাবেন না।
কেভিন এম

অ্যারে.সোর্ট () ফাংশন টিমসোর্ট ব্যবহার করে যা খুব বাছাই করা রানগুলি খুঁজে পেতে পারে এবং সেগুলিতে মার্জ সাজানোর প্রয়োগ করে। অদ্ভুতভাবে যথেষ্ট, এই কোডটি "দক্ষ নয়" এর জন্য সত্যিকার অর্থেও ত্রুটিযুক্ত হতে পারে না এটি বাছাই করা রানের কারণে আসলে ও (এন) সময়ে সমাপ্তিতে পড়ে যাবে। আপনি এটিতে একগুচ্ছ মানদণ্ড চালাতে পারেন, বৈষম্যগুলি খুব ভাল এটি ওপি কোডটি প্রায়শই পরাজিত করবে good
তাতারাইজ

4

আমাকে এটি জাভাস্ক্রিপ্টে লিখতে হয়েছিল, এটি এখানে:

function merge(a, b) {
    var result = [];
    var ai = 0;
    var bi = 0;
    while (true) {
        if ( ai < a.length && bi < b.length) {
            if (a[ai] < b[bi]) {
                result.push(a[ai]);
                ai++;
            } else if (a[ai] > b[bi]) {
                result.push(b[bi]);
                bi++;
            } else {
                result.push(a[ai]);
                result.push(b[bi]);
                ai++;
                bi++;
            }
        } else if (ai < a.length) {
            result.push.apply(result, a.slice(ai, a.length));
            break;
        } else if (bi < b.length) {
            result.push.apply(result, b.slice(bi, b.length));
            break;
        } else {
            break;
        }
    }
    return result;
}

4

অ্যাপাচি সংগ্রহগুলি সংস্করণ 4 থেকে কোলেটের পদ্ধতিটিকে সমর্থন করে; আপনি collateপদ্ধতিটি ব্যবহার করে এটি করতে পারেন :

org.apache.commons.collections4.CollectionUtils

জাভাডোকের উদ্ধৃতি এখানে:

collate(Iterable<? extends O> a, Iterable<? extends O> b, Comparator<? super O> c)

দুটি বাছাই করা সংগ্রহগুলিকে মার্জ করে aএবং b, একটি একক, বাছাই করা তালিকায় যেমন তুলনামূলক সি অনুযায়ী উপাদানগুলির ক্রম বজায় থাকে।

চাকাটি নতুন করে আবিষ্কার করবেন না! ডকুমেন্ট রেফারেন্স: http://commons.apache.org/proper/commons-collections/apidocs/org/apache/commons/collections4/CollectionUtils.html


4

গ্যালাপ অনুসন্ধান মার্জ: ও (লগ (এন) * লগ (আই)) ও (এন) এর পরিবর্তে

আমি মন্তব্যগুলিতে গ্রেইয়ার্ডের পরামর্শটি এগিয়ে গিয়ে প্রয়োগ করেছি। বেশিরভাগ কারণেই আমার এই কোডটির একটি অত্যন্ত দক্ষ মিশনের সমালোচনামূলক সংস্করণ প্রয়োজন।

  • কোডটি একটি গ্যালাপ অনুসন্ধান ব্যবহার করে যা হে (লগ (i)) যেখানে আমি বর্তমান সূচক থেকে দূরত্ব যেখানে প্রাসঙ্গিক সূচক বিদ্যমান।
  • গ্যালপ অনুসন্ধান যথাযথ, ব্যাপ্তি সনাক্ত করার পরে কোডটি বাইনারি অনুসন্ধান ব্যবহার করে। যেহেতু গ্যালাপ এটিকে একটি ছোট পরিসীমাতে সীমাবদ্ধ করেছে ফলাফলযুক্ত বাইনারি অনুসন্ধানগুলি ও (লগ (i))
  • গ্যালাপ এবং মার্জ পিছনের দিকে সঞ্চালিত হয়। এটি মিশনকে গুরুত্বপূর্ণ বলে মনে হচ্ছে না তবে এটি অ্যারেগুলিকে মার্জ করার অনুমতি দেয়। যদি আপনার অ্যারেগুলির একটিতে ফলাফলের মানগুলি সংরক্ষণ করার জন্য পর্যাপ্ত জায়গা থাকে তবে আপনি কেবল এটি মার্জ করা অ্যারে এবং হিসাবে ব্যবহার করতে পারেন ফলাফল অ্যারে । আপনার অবশ্যই এ জাতীয় ক্ষেত্রে অ্যারের মধ্যে বৈধ পরিসরটি নির্দিষ্ট করতে হবে।
  • সেক্ষেত্রে এটির জন্য মেমরি বরাদ্দ প্রয়োজন হয় না (সমালোচনামূলক ক্রিয়াকলাপগুলিতে বড় সঞ্চয়)। এটি কেবল নিশ্চিত করে যে এটি কোনও অ-প্রক্রিয়াজাত মানগুলিকে ওভাররাইট করতে পারে না এবং (যা কেবল পিছনের দিকে করা যায়)। আসলে, আপনি ইনপুট এবং ফলাফল উভয়ের জন্য একই অ্যারে ব্যবহার করেন। এটি কোনও খারাপ প্রভাব ফেলবে না।
  • আমি ধারাবাহিকভাবে Integer.compare ব্যবহার করেছি () যাতে এটি অন্য উদ্দেশ্যে স্যুইচ করা যায়।
  • এর আগে এমন কিছু সুযোগ রয়েছে যা আমি পূর্বে প্রমাণিত তথ্যগুলি সামান্য প্রচার করতে এবং ব্যবহার না করে থাকতে পারি। যেমন দুটি মানের ব্যাপ্তিতে বাইনারি অনুসন্ধান করা, যার জন্য একটি মান ইতিমধ্যে পরীক্ষা করা হয়েছিল। মূল লুপটি বলার আরও ভাল উপায় থাকতে পারে, যদি ক্রমিকভাবে দুটি ক্রিয়াকলাপে একত্রিত করা হয় তবে ফ্লিপিং সি মানটির প্রয়োজন হবে না। যেহেতু আপনি জানেন যে আপনি একটি করতে হবে অন্য সময় প্রতি সময়। কিছু পালিশের জন্য জায়গা আছে।

ও (লগ (এন) * লগ (আই)) ও (এন) এর পরিবর্তে সময়ের জটিলতার সাথে এটি করার সবচেয়ে কার্যকরী উপায় হওয়া উচিত । এবং ও (এন) এর সবচেয়ে খারাপ ক্ষেত্রে সময়ের জটিলতা। যদি আপনার অ্যারেগুলি ঝাঁঝরা হয়ে থাকে এবং মানগুলির দীর্ঘ স্ট্রিং একসাথে থাকে তবে এটি এটি করার জন্য অন্য কোনও উপায়ে বামন হবে, অন্যথায় এটি তাদের চেয়ে ভাল হবে।

মার্জিং অ্যারের শেষে এটি দুটি পড়ার মান এবং ফলাফল অ্যারের মধ্যে লেখার মান রয়েছে। কোন শেষ মানটি কম তা সন্ধান করার পরে, এটি অ্যারেটিতে গ্যালাপ অনুসন্ধান করে। 1, 2, 4, 8, 16, 32, ইত্যাদি ইত্যাদি যখন এটির সীমাটি খুঁজে পায় যেখানে অন্য অ্যারের পড়ার মানটি আরও বড়। এটি বাইনারি সেই ব্যাপ্তিতে অনুসন্ধান করে (পরিধিকে অর্ধেক করে দেয়, সঠিক অর্ধে সন্ধান করে, একক মান পর্যন্ত পুনরাবৃত্তি করে)। তারপরে এটি অ্যারে সেই মানগুলি রাইটিং পজিশনে অনুলিপি করে। অনুলিপিটি প্রয়োজনীয়তার সাথে মনে রেখে, এমনভাবে সরানো হয়েছে যে এটি উভয় পাঠ্য অ্যারে থেকে একই মানগুলি ওভাররাইট করতে পারে না (যার অর্থ লেখার অ্যারে এবং পড়ার অ্যারে একই হতে পারে)। এরপরে এটি অন্যান্য অ্যারের জন্য একই ক্রিয়াকলাপ সম্পাদন করে যা এখন অন্য অ্যারের নতুন পঠিত মানের চেয়ে কম হিসাবে পরিচিত।

static public int gallopSearch(int current, int[] array, int v) {
    int d = 1;
    int seek = current - d;
    int prevIteration = seek;
    while (seek > 0) {
        if (Integer.compare(array[seek], v) <= 0) {
            break;
        }
        prevIteration = seek;
        d <<= 1;
        seek = current - d;
        if (seek < 0) {
            seek = 0;
        }
    }
    if (prevIteration != seek) {
        seek = binarySearch(array, seek, prevIteration, v);
        seek = seek >= 0 ? seek : ~seek;
    }
    return seek;
}

static public int binarySearch(int[] list, int fromIndex, int toIndex, int v) {
    int low = fromIndex;
    int high = toIndex - 1;
    while (low <= high) {
        int mid = (low + high) >>> 1;
        int midVal = list[mid];
        int cmp = Integer.compare(midVal, v);
        if (cmp < 0) {
            low = mid + 1;
        } else if (cmp > 0) {
            high = mid - 1;
        } else {
            return mid;// key found
        }
    }
    return -(low + 1);// key not found.
}

static public int[] sortedArrayMerge(int[] a, int[] b) {
    return sortedArrayMerge(null, a, a.length, b, b.length);
}

static public int[] sortedArrayMerge(int[] results, int[] a, int aRead, int b[], int bRead) {
    int write = aRead + bRead, length, gallopPos;
    if ((results == null) || (results.length < write)) {
        results = new int[write];
    }
    if (aRead > 0 && bRead > 0) {
        int c = Integer.compare(a[aRead - 1], b[bRead - 1]);
        while (aRead > 0 && bRead > 0) {
            switch (c) {
                default:
                    gallopPos = gallopSearch(aRead, a, b[bRead-1]);
                    length = (aRead - gallopPos);
                    write -= length;
                    aRead = gallopPos;
                    System.arraycopy(a, gallopPos--, results, write, length);
                    c = -1;
                    break;
                case -1:
                    gallopPos = gallopSearch(bRead, b, a[aRead-1]);
                    length = (bRead - gallopPos);
                    write -= length;
                    bRead = gallopPos;
                    System.arraycopy(b, gallopPos--, results, write, length);
                    c = 1;
                    break;
            }
        }
    }
    if (bRead > 0) {
        if (b != results) {
            System.arraycopy(b, 0, results, 0, bRead);
        }
    } else if (aRead > 0) {
        if (a != results) {
            System.arraycopy(a, 0, results, 0, aRead);
        }
    }
    return results;
}

এটি করার সবচেয়ে কার্যকর উপায় এটি হওয়া উচিত।


কিছু উত্তরের একটি সদৃশ অপসারণ ক্ষমতা ছিল। এর জন্য একটি ও (এন) অ্যালগরিদম প্রয়োজন কারণ আপনাকে অবশ্যই প্রতিটি আইটেম তুলনা করতে হবে। সুতরাং বাস্তবের পরে প্রয়োগ করার জন্য এটির জন্য এখানে একা একা। আপনি যদি সেগুলির সবকটি দেখার প্রয়োজন হয় তবে আপনি নকলগুলি সন্ধান করতে পারেন, আপনি যদি সেগুলির অনেক কিছু পেয়ে থাকেন তবে আপনি একাধিক এন্ট্রিগুলি পুরো পথ ধরে ঘুরে দেখতে পারবেন না।

static public int removeDuplicates(int[] list, int size) {
    int write = 1;
    for (int read = 1; read < size; read++) {
        if (list[read] == list[read - 1]) {
            continue;
        }
        list[write++] = list[read];
    }
    return write;
}

আপডেট: পূর্ববর্তী উত্তর, ভৌতিক কোড নয় তবে উপরের থেকে পরিষ্কারভাবে নিকৃষ্টমান।

অপ্রয়োজনীয় হাইপার-অপটিমাইজেশন। এটি কেবলমাত্র শেষ বিটের জন্য অ্যারেকপি নয়, শুরুতেও ডাকে। ও (লগ (এন)) তে কোনও সূচক অ-ওভারল্যাপ প্রক্রিয়াজাত করে ডেটা বাইনারি অনুসন্ধান করে। ও (লগ (এন) + এন) হ'ল (এন) এবং কিছু ক্ষেত্রে এর প্রভাবটি উচ্চারণ করা হবে বিশেষত এমন জিনিসগুলিতে যেখানে মার্জিং অ্যারেগুলির মধ্যে কোনওরূপ ওভারল্যাপ নেই।

private static int binarySearch(int[] array, int low, int high, int v) {
    high = high - 1;
    while (low <= high) {
        int mid = (low + high) >>> 1;
        int midVal = array[mid];
        if (midVal > v)
            low = mid + 1;
        else if (midVal < v)
            high = mid - 1;
        else
            return mid; // key found
    }
    return low;//traditionally, -(low + 1);  // key not found.
}

private static int[] sortedArrayMerge(int a[], int b[]) {
    int result[] = new int[a.length + b.length];
    int k, i = 0, j = 0;
    if (a[0] > b[0]) {
        k = i = binarySearch(b, 0, b.length, a[0]);
        System.arraycopy(b, 0, result, 0, i);
    } else {
        k = j = binarySearch(a, 0, a.length, b[0]);
        System.arraycopy(a, 0, result, 0, j);
    }
    while (i < a.length && j < b.length) {
        result[k++] = (a[i] < b[j]) ? a[i++] : b[j++];
    }
    if (j < b.length) {
        System.arraycopy(b, j, result, k, (b.length - j));
    } else {
        System.arraycopy(a, i, result, k, (a.length - i));
    }
    return result;
}

1
প্রতিসাম্য সম্পর্কে কিছু করা শুরু করার জন্য উত্সাহিত, তবে কেন সেখানে থামছেন? গ্যালোপিং অনুসন্ধান ব্যবহার করুন, এটি সমান কীগুলির পরে সূচিটি ফেরত দিন । 3 টির বেশি উপাদান থাকলে অ্যারে কপি ব্যবহার করুন Use নোট করুন যে সেই অনুলিপিটির পরে, ক কিছুই পরিবর্তিত হয়নি) একটি ইনপুটের সূচনা সূচক এবং আউটপুট অ্যারে খ) আপনার "পরবর্তী" উপাদানটি ছোট কিনা তা সম্পর্কে আপনার জ্ঞান।
গ্রাইবার্ড

এটি পুরোপুরি বাস্তবায়িত অ্যারেস.সোর্টটি করে। এটি উল্লেখযোগ্যভাবে সবচেয়ে খারাপ এক মার্জ সাজ্ট। আমি মনে করি যেখানে তারা প্রয়োজন সেখানে 2 টি উপাদান অদলবদল করে তবে 2 টিরও বেশি উপাদানের জন্য অ্যারেওকপির মধ্যে পড়ে। আপনি পরবর্তী উপাদানটি রৈখিকভাবে পরীক্ষা করতে চান কিনা তা সম্পর্কে আমি নিশ্চিত নই বা এটিতে বাইনারি অনুসন্ধান করব। অনুমানমূলকভাবে পরীক্ষা করে দেখতে খুব বড় সুবিধা হবে যে আপনি যদি এই দূরত্বটি গলপ করতে পারতেন তবে আরও বড় দূরত্বটি গলপ করতে পারবেন কিনা। সামনে 8 টি চেক করুন এবং যদি আপনি অনুলিপি করতে পারেন যে আপনি নিজের 7 টি জিনিস অপারেশন করেছেন যা আপনাকে দেখার দরকার নেই।
টাটারাইজ

@ গ্রেইবার্ড ... এবং সম্পন্ন হয়েছে। পিছনেও গেছে যাতে আমি একই স্মৃতি আবার ব্যবহার করতে পারি।
তাতারাইজ

ভাল জিনিস আপনি ব্যালিস্টিক যেতে প্রেরণা। দিনের সময় ডুবে যাওয়ার জন্য আরও নিবিড় নজর রাখতে চলেছি।
গ্রেইবার্ড

That is totally what the implemented Arrays.sort does( এটি : আপনার উত্তরটির প্রথম সংশোধন থেকে - বা - আমার 19 ফেব্রুয়ারীর মন্তব্য থেকে?) - সানসোফ্টের জেডিকে 8-তে কোনওটিই খুঁজে পাচ্ছেন না: আপনি কোনটি প্রয়োগের Arrays.sortকথা উল্লেখ করছেন?
গ্রেইবার্ড

2

জাভাস্ক্রিপ্টে লিখিত একটি সংক্ষিপ্ত রূপ:

function sort( a1, a2 ) {

    var i = 0
        , j = 0
        , l1 = a1.length
        , l2 = a2.length
        , a = [];

    while( i < l1 && j < l2 ) {

        a1[i] < a2[j] ? (a.push(a1[i]), i++) : (a.push( a2[j]), j++);
    }

    i < l1 && ( a = a.concat( a1.splice(i) ));
    j < l2 && ( a = a.concat( a2.splice(j) ));

    return a;
}

1
    public class Merge {

    // stably merge a[lo .. mid] with a[mid+1 .. hi] using aux[lo .. hi]
    public static void merge(Comparable[] a, Comparable[] aux, int lo, int mid, int hi) {

        // precondition: a[lo .. mid] and a[mid+1 .. hi] are sorted subarrays
        assert isSorted(a, lo, mid);
        assert isSorted(a, mid+1, hi);

        // copy to aux[]
        for (int k = lo; k <= hi; k++) {
            aux[k] = a[k]; 
        }

        // merge back to a[]
        int i = lo, j = mid+1;
        for (int k = lo; k <= hi; k++) {
            if      (i > mid)              a[k] = aux[j++];
            else if (j > hi)               a[k] = aux[i++];
            else if (less(aux[j], aux[i])) a[k] = aux[j++];
            else                           a[k] = aux[i++];
        }

        // postcondition: a[lo .. hi] is sorted
        assert isSorted(a, lo, hi);
    }

    // mergesort a[lo..hi] using auxiliary array aux[lo..hi]
    private static void sort(Comparable[] a, Comparable[] aux, int lo, int hi) {
        if (hi <= lo) return;
        int mid = lo + (hi - lo) / 2;
        sort(a, aux, lo, mid);
        sort(a, aux, mid + 1, hi);
        merge(a, aux, lo, mid, hi);
    }

    public static void sort(Comparable[] a) {
        Comparable[] aux = new Comparable[a.length];
        sort(a, aux, 0, a.length-1);
        assert isSorted(a);
    }


   /***********************************************************************
    *  Helper sorting functions
    ***********************************************************************/

    // is v < w ?
    private static boolean less(Comparable v, Comparable w) {
        return (v.compareTo(w) < 0);
    }

    // exchange a[i] and a[j]
    private static void exch(Object[] a, int i, int j) {
        Object swap = a[i];
        a[i] = a[j];
        a[j] = swap;
    }


   /***********************************************************************
    *  Check if array is sorted - useful for debugging
    ***********************************************************************/
    private static boolean isSorted(Comparable[] a) {
        return isSorted(a, 0, a.length - 1);
    }

    private static boolean isSorted(Comparable[] a, int lo, int hi) {
        for (int i = lo + 1; i <= hi; i++)
            if (less(a[i], a[i-1])) return false;
        return true;
    }


   /***********************************************************************
    *  Index mergesort
    ***********************************************************************/
    // stably merge a[lo .. mid] with a[mid+1 .. hi] using aux[lo .. hi]
    private static void merge(Comparable[] a, int[] index, int[] aux, int lo, int mid, int hi) {

        // copy to aux[]
        for (int k = lo; k <= hi; k++) {
            aux[k] = index[k]; 
        }

        // merge back to a[]
        int i = lo, j = mid+1;
        for (int k = lo; k <= hi; k++) {
            if      (i > mid)                    index[k] = aux[j++];
            else if (j > hi)                     index[k] = aux[i++];
            else if (less(a[aux[j]], a[aux[i]])) index[k] = aux[j++];
            else                                 index[k] = aux[i++];
        }
    }

    // return a permutation that gives the elements in a[] in ascending order
    // do not change the original array a[]
    public static int[] indexSort(Comparable[] a) {
        int N = a.length;
        int[] index = new int[N];
        for (int i = 0; i < N; i++)
            index[i] = i;

        int[] aux = new int[N];
        sort(a, index, aux, 0, N-1);
        return index;
    }

    // mergesort a[lo..hi] using auxiliary array aux[lo..hi]
    private static void sort(Comparable[] a, int[] index, int[] aux, int lo, int hi) {
        if (hi <= lo) return;
        int mid = lo + (hi - lo) / 2;
        sort(a, index, aux, lo, mid);
        sort(a, index, aux, mid + 1, hi);
        merge(a, index, aux, lo, mid, hi);
    }

    // print array to standard output
    private static void show(Comparable[] a) {
        for (int i = 0; i < a.length; i++) {
            StdOut.println(a[i]);
        }
    }

    // Read strings from standard input, sort them, and print.
    public static void main(String[] args) {
        String[] a = StdIn.readStrings();
        Merge.sort(a);
        show(a);
    }
}

এই কপি করে a[mid+1 .. hi]করতে auxজন্য?
গ্রেইবার্ড

1

আমি মনে করি যে বৃহত্তর বাছাই করা অ্যারেগুলির জন্য স্কিপ তালিকা প্রবর্তন করা হলে তুলনার সংখ্যা হ্রাস করতে পারে এবং তৃতীয় অ্যারেতে অনুলিপি করার প্রক্রিয়াটি গতিতে পারে। অ্যারে খুব বিশাল হলে এটি ভাল হতে পারে।


1
public int[] merge(int[] a, int[] b) {
    int[] result = new int[a.length + b.length];
    int aIndex, bIndex = 0;

    for (int i = 0; i < result.length; i++) {
        if (aIndex < a.length && bIndex < b.length) {
            if (a[aIndex] < b[bIndex]) {
                result[i] = a[aIndex];
                aIndex++;
            } else {
                result[i] = b[bIndex];
                bIndex++;
            }
        } else if (aIndex < a.length) {
            result[i] = a[aIndex];
            aIndex++;
        } else {
            result[i] = b[bIndex];
            bIndex++;
        }
    }

    return result;
}

2
কিছু ব্যাখ্যা সুন্দর হবে। :)
gsamaras

1
public static int[] merge(int[] a, int[] b) {
    int[] mergedArray = new int[(a.length + b.length)];
    int i = 0, j = 0;
    int mergedArrayIndex = 0;
    for (; i < a.length || j < b.length;) {
        if (i < a.length && j < b.length) {
            if (a[i] < b[j]) {
                mergedArray[mergedArrayIndex] = a[i];
                i++;
            } else {
                mergedArray[mergedArrayIndex] = b[j];
                j++;
            }
        } else if (i < a.length) {
            mergedArray[mergedArrayIndex] = a[i];
            i++;
        } else if (j < b.length) {
            mergedArray[mergedArrayIndex] = b[j];
            j++;
        }
        mergedArrayIndex++;
    }
    return mergedArray;
}

এর বাঁচানোর অনুগ্রহ কী? এটি সঙ্কুচিত হতে পারে for (int i, j, k = i = j = 0 ; k < c.length ; ) c[k++] = b.length <= j || i < a.length && a[i] < b[j] ? a[i++] : b[j++];। এটি অ্যান্ড্রু এর 2014 উত্তর থেকে কীভাবে আলাদা ?
গ্রেইবার্ড

1

অ্যালগরিদম বিভিন্ন উপায়ে উন্নত করা যেতে পারে। উদাহরণস্বরূপ, এটি পরীক্ষা করা যুক্তিসঙ্গত, যদি a[m-1]<b[0]বা হয়b[n-1]<a[0] । এই ক্ষেত্রে যে কোনও ক্ষেত্রে, আরও তুলনা করার প্রয়োজন নেই। অ্যালগরিদম কেবল সঠিক ক্রমে ফলাফলের মাধ্যমে উত্স অ্যারেগুলি অনুলিপি করতে পারে।

আরও জটিল বর্ধিতকরণগুলির মধ্যে অন্তর্ভুক্ত অংশগুলির সন্ধান এবং কেবল তাদের জন্য মার্জ অ্যালগরিদম চালানো অন্তর্ভুক্ত থাকতে পারে। এটি অনেক সময় সাশ্রয় করতে পারে, যখন মেশানো অ্যারেগুলির আকারগুলি বিভিন্ন সময়ে পৃথক হয়।


এই বর্ধনের জন্য প্রথম উপাদানটি বাইনারিসার্কের সাহায্যে দ্বিতীয় অ্যারেতে কোথায় পড়বে তা পরীক্ষা করা ভাল, তারপরে ডেটা শুরু করার জন্য অ্যারেরকপি। তারপরে যদি এই পরীক্ষাগুলির মধ্যে একটি সত্য হয় তবে এটিতে অ্যারেকপিটি সমস্ত কিছু হবে তারপরে ত্রৈমাসিকীর অ্যারেওকপি করে এবং আপনি একই ফলাফল পান। তবে, ওভারল্যাপের সামান্য বিটের ক্ষেত্রে, আপনাকে কেবল ওভারল্যাপের সময় সঠিক অ্যালগরিদম করতে হবে এবং অন্য কোনও সময় নয়। যেহেতু আপনি ও (এন) এর সাথে কিছু দ্রুত ও (লগন) কমান্ড ব্যবহার করে আটকে যাচ্ছেন তার আগে কোনও দাম পড়বে না।
তাতারাইজ

1

এই সমস্যাটি মার্জর্ট অ্যালগরিদমের সাথে সম্পর্কিত, যেখানে দুটি বাছাই করা সাব-অ্যারেগুলি একক সাজানো সাব-অ্যারেতে মিলিত হয়। CLRS বই অ্যালগরিদম একটি উদাহরণ দেয় এবং পরীক্ষণ যদি শেষ একটি প্রহরী মান (কিছু যে তুলনা এবং "অন্য কোন মানের চেয়ে বড়") প্রতিটি অ্যারের শেষ যোগ করে হয়েছে পৌঁছেছেন প্রয়োজনীয়তার আপ সাফ করে।

আমি পাইথনে এটি লিখেছিলাম, তবে এটি জাভাতেও খুব সুন্দরভাবে অনুবাদ করা উচিত:

def func(a, b):
    class sentinel(object):
        def __lt__(*_):
            return False

    ax, bx, c = a[:] + [sentinel()], b[:] + [sentinel()], []
    i, j = 0, 0

    for k in range(len(a) + len(b)):
        if ax[i] < bx[j]:
            c.append(ax[i])
            i += 1
        else:
            c.append(bx[j])
            j += 1

    return c

উপাদানগুলি একবারে অনুলিপি করে (দক্ষতার সাথে) একটি সেন্ডিনেল ব্যবহার করুন ...
গ্রেইবার্ড

1

আপনি ফলাফলের অ্যারে পূরণ করতে 2 টি থ্রেড ব্যবহার করতে পারেন, একটি সামনে থেকে, পিছন থেকে একটি।

সংখ্যাগুলির ক্ষেত্রে এটি কোনও সিঙ্ক্রোনাইজেশন ছাড়াই কাজ করতে পারে, উদাহরণস্বরূপ যদি প্রতিটি থ্রেড মানের অর্ধেক সন্নিবেশ করে।


0
//How to merge two sorted arrays into a sorted array without duplicates?
//simple C Coding
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

main()
{
    int InputArray1[] ={1,4,5,7,8,9,12,13,14,17,40};
    int InputArray2[] ={4,5,11,14,15,17,18,19,112,122,122,122,122};
    int n=10;
    int OutputArray[30];
    int i=0,j=0,k=0;
    //k=OutputArray
    while(i<11 && j<13)
    {
        if(InputArray1[i]<InputArray2[j])
        {
            if (k == 0 || InputArray1[i]!= OutputArray[k-1])
            {
                OutputArray[k++] = InputArray1[i];
            }
            i=i+1;
        }
        else if(InputArray1[i]>InputArray2[j])
        {
            if (k == 0 || InputArray2[j]!= OutputArray[k-1])
            {
                OutputArray[k++] = InputArray2[j];
            }
            j=j+1;
        }
        else
        {
            if (k == 0 || InputArray1[i]!= OutputArray[k-1])
            {
                OutputArray[k++] = InputArray1[i];
            }
            i=i+1;
            j=j+1;
        }
    };
    while(i<11)
    {
        if(InputArray1[i]!= OutputArray[k-1])
            OutputArray[k++] = InputArray1[i++];
        else
            i++;
    }
    while(j<13)
    {
        if(InputArray2[j]!= OutputArray[k-1])
            OutputArray[k++] = InputArray2[j++];
        else
            j++;
    }
    for(i=0; i<k; i++)
    {
        printf("sorted data:%d\n",OutputArray[i]);
    };
}

0
public static int[] merge(int[] listA, int[] listB) {
        int[] mergedList = new int[ listA.length + listB.length];
        int i = 0; // Counter for listA
        int j = 0; // Counter for listB
        int k = 0; // Counter for mergedList
        while (true) {
            if (i >= listA.length && j >= listB.length) {
                break;
            }
            if (i < listA.length && j < listB.length) { // If both counters are valid.
                if (listA[i] <= listB[j]) {
                    mergedList[k] = listA[i];
                    k++;
                    i++;
                } else {
                    mergedList[k] = listB[j];
                    k++;
                    j++;
                }
            } else if (i < listA.length && j >= listB.length) { // If only A's counter is valid.
                mergedList[k] = listA[i];
                k++;
                i++;
            } else if (i <= listA.length && j < listB.length) { // If only B's counter is valid
                mergedList[k] = listB[j];
                k++;
                j++;
            }
        }
        return mergedList;
    }

0
var arrCombo = function(arr1, arr2){
  return arr1.concat(arr2).sort(function(x, y) {
    return x - y;
  });
};

2
এই উত্তরটি জাভা প্রোগ্রামিং ভাষার ক্ষেত্রে প্রযোজ্য নয়, যদিও এটি জাভাস্ক্রিপ্টের জন্য একটি ভাল উত্তর হবে।
gknicker

এটি একটি কাজের সাক্ষাত্কার অংশ ছিল। এই ক্ষেত্রে আপনি উপরের মতো "সাধারণ" কোডটি লিখবেন বলে আশা করা যায় না। তারা "দক্ষ" কোড এবং একটি বিক্ষোভের সন্ধান করছেন যা আপনি জড়িত অ্যালগরিদমগুলি বুঝতে পারেন।
d11wtq

0

আমার প্রিয় প্রোগ্রামিং ভাষাটি জাভাস্ক্রিপ্ট

function mergeSortedArrays(a, b){
    var result = [];

    var sI = 0;
    var lI = 0;
    var smallArr;
    var largeArr;
    var temp;

    if(typeof b[0] === 'undefined' || a[0]<b[0]){
        smallArr = a;
        largeArr = b;
    } else{
        smallArr = b;
        largeArr = a;
    }

    while(typeof smallArr[sI] !== 'undefined'){
        result.push(smallArr[sI]);
        sI++;

        if(smallArr[sI]>largeArr[lI] || typeof smallArr[sI] === 'undefined'){
            temp = smallArr;
            smallArr = largeArr;
            largeArr = temp;
            temp = sI;
            sI = lI;
            lI = temp;
        }
    }
    return result;
}

0

হয়তো System.arraycopy ব্যবহার করুন

public static byte[] merge(byte[] first, byte[] second){
    int len = first.length + second.length;
    byte[] full = new byte[len];
    System.arraycopy(first, 0, full, 0, first.length);
    System.arraycopy(second, 0, full, first.length, second.length);
    return full;
}

3
আপনি কেবল তাদের মার্জ করছেন; আপনার ফলস্বরূপ অ্যারে নিজেই বাছাই করা হয়নি যা প্রয়োজন ছিল।
সঞ্জীব ধীমান

0
public static void main(String[] args) {
    int[] arr1 = {2,4,6,8,10,999};
    int[] arr2 = {1,3,5,9,100,1001};

    int[] arr3 = new int[arr1.length + arr2.length];

    int temp = 0;

    for (int i = 0; i < (arr3.length); i++) {
        if(temp == arr2.length){
            arr3[i] = arr1[i-temp];
        }
        else if (((i-temp)<(arr1.length)) && (arr1[i-temp] < arr2[temp])){
                arr3[i] = arr1[i-temp];
        }
        else{
            arr3[i] = arr2[temp];
            temp++;
        }
    }

    for (int i : arr3) {
        System.out.print(i + ", ");
    }
}

আউটপুট হল:

1, 2, 3, 4, 5, 6, 8, 9, 10, 100, 999, 1001,


মধ্যে সূচক নামকরণের জন্য বিভ্রান্তিকর arr2নাind2 , কিন্তু temp
গ্রাইবার্ড

0

কোডটি আরও কিছুটা কমপ্যাক্ট করার জন্য আপনি টার্নারি অপারেটরগুলি ব্যবহার করতে পারেন

public static int[] mergeArrays(int[] a1, int[] a2) {
    int[] res = new int[a1.length + a2.length];
    int i = 0, j = 0;

    while (i < a1.length && j < a2.length) {
        res[i + j] = a1[i] < a2[j] ? a1[i++] : a2[j++];
    }

    while (i < a1.length) {
        res[i + j] = a1[i++];
    }

    while (j < a2.length) {
        res[i + j] = a2[j++];
    }

    return res;
}

0
public static int[] mergeSorted(int[] left, int[] right) {
    System.out.println("merging " + Arrays.toString(left) + " and " + Arrays.toString(right));
    int[] merged = new int[left.length + right.length];
    int nextIndexLeft = 0;
    int nextIndexRight = 0;
    for (int i = 0; i < merged.length; i++) {
        if (nextIndexLeft >= left.length) {
            System.arraycopy(right, nextIndexRight, merged, i, right.length - nextIndexRight);
            break;
        }
        if (nextIndexRight >= right.length) {
            System.arraycopy(left, nextIndexLeft, merged, i, left.length - nextIndexLeft);
            break;
        }
        if (left[nextIndexLeft] <= right[nextIndexRight]) {
            merged[i] = left[nextIndexLeft];
            nextIndexLeft++;
            continue;
        }
        if (left[nextIndexLeft] > right[nextIndexRight]) {
            merged[i] = right[nextIndexRight];
            nextIndexRight++;
            continue;
        }
    }
    System.out.println("merged : " + Arrays.toString(merged));
    return merged;
}

মূল সমাধান থেকে কিছুটা পৃথক


0

ও (এম + এন) সময়ের জটিলতায় দুটি বাছাই করা অ্যারে মার্জ করার জন্য কেবল এক লুপের সাহায্যে নীচের পদ্ধতির ব্যবহার করুন। মি এবং এন প্রথম অ্যারে এবং দ্বিতীয় অ্যারের দৈর্ঘ্য।

public class MargeSortedArray {
    public static void main(String[] args) {
        int[] array = new int[]{1,3,4,7};
        int[] array2 = new int[]{2,5,6,8,12,45};
        int[] newarry = margeToSortedArray(array, array2);
        //newarray is marged array
    }

    // marge two sorted array with o(a+n) time complexity
    public static int[] margeToSortedArray(int[] array, int[] array2) {
        int newarrlen = array.length+array2.length;
        int[] newarr = new int[newarrlen];

        int pos1=0,pos2=0;
        int len1=array.length, len2=array2.length;

        for(int i =0;i<newarrlen;i++) {     
            if(pos1>=len1) {
                newarr[i]=array2[pos2];
                pos2++;
                continue;
            }
            if(pos2>=len2) {
                newarr[i]=array[pos1];
                pos1++;
                continue;
            }

            if(array[pos1]>array2[pos2]) {
                newarr[i]=array2[pos2];
                pos2++;
            } else {
                newarr[i]=array[pos1];
                pos1++;
            }   
        }

        return newarr;
    }

}

0
var arr1 = [2,10,20,30,100];
var arr2 = [2,4,5,6,7,8,9];
var j = 0;
var i =0;
var newArray = [];

for(var x=0;x< (arr1.length + arr2.length);x++){
    if(arr1[i] >= arr2[j]){                //check if element arr2 is equal and less than arr1 element
        newArray.push(arr2[j]);
      j++;
    }else if(arr1[i] < arr2[j]){            //check if element arr1 index value  is less than arr2 element
        newArray.push(arr1[i]);
        i++;
    }
    else if(i == arr1.length || j < arr2.length){    // add remaining arr2 element
        newArray.push(arr2[j]);
        j++
    }else{                                                   // add remaining arr1 element
        newArray.push(arr1[i]); 
        i++
    }

}

console.log(newArray);

-1

যেহেতু প্রশ্নটি কোনও নির্দিষ্ট ভাষা ধরে না। পাইথনের সমাধান এখানে। ধরে নিচ্ছি অ্যারেগুলি ইতিমধ্যে বাছাই করা হয়েছে।

দৃষ্টিভঙ্গি 1 - নম্পি অ্যারে ব্যবহার করে: নমপি আমদানি করুন

arr1 = numpy.asarray([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 11, 14, 15, 55])
arr2 = numpy.asarray([11, 32, 43, 45, 66, 76, 88])

array = numpy.concatenate((arr1,arr2), axis=0)
array.sort()

পদ্ধতির 2 - তালিকা ব্যবহার করে, ধরে নিচ্ছি তালিকাগুলি সাজানো হয়েছে।

list_new = list1.extend(list2)
list_new.sort()

Since the question doesn't assume any specific language2011/5/11/19: 43 থেকে এটি জাভা ট্যাগ করা হয়েছে ।
গ্রেইবার্ড

আপনার সমাধান আসলে তালিকার সুযোগ গ্রহণ করে না ইতিমধ্যে সাজানো হয়, এবং তার রানটাইম না হে (ঢ), কারণ .sort()হয় O(n log n)শ্রেষ্ঠ সময়ে
dark_ruby

-1

এখানে আমার জাভা বাস্তবায়ন যা সদৃশ মুছে ফেলে।

public static int[] mergesort(int[] a, int[] b) {
    int[] c = new int[a.length + b.length];
    int i = 0, j = 0, k = 0, duplicateCount = 0;

    while (i < a.length || j < b.length) {
        if (i < a.length && j < b.length) {
            if (a[i] == b[j]) {
                c[k] = a[i];
                i++;j++;duplicateCount++;
            } else {
                c[k] = a[i] < b[j] ? a[i++] : b[j++];
            }
        } else if (i < a.length) {
            c[k] = a[i++];
        } else if (j < a.length) {
            c[k] = b[j++];
        }
        k++;
    }

    return Arrays.copyOf(c, c.length - duplicateCount);
}
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.