算法基础二：渐增型算法---两个有序序列的合并算法

算法基础二：渐增型算法---两个有序序列的合并算法

一、算法描述与思路分析

1、问题描述

2、思路分析

案例流程

3、伪码描述

二、程序实现

1、可以比较类型数组版本

①程序源码

import java.util.Arrays;

public class LinearList_01 {

    public static void merge(Comparable[] a,int p,int q,int r){
        int i,j,k;
        int n1 = q-p+1;//[p....q]的长度
        int n2 = r-q;//[q+1....r]的长度

        Comparable[] L = Arrays.copyOfRange(a,p,q+1);//将a[p...q]复制到L
        Comparable[] R = Arrays.copyOfRange(a,q+1,r+1);//将a[q+1...r]复制到R

        //也可以简写为下面的形式
        //Comparable[] L1 = Arrays.copyOfRange(a,p,q+1),
                     //R1 = Arrays.copyOfRange(a,q+1,r+1);

        i = j = 0;
        k = p;

        while(i<n1 && j<n2){
            if (L[i].compareTo(R[j]) < 0){
                a[k] = L[i];
                i++;
                k++;
            }else {
                a[k++] = R[j++];
            }
        }

        //将L[i....n1]复制到a[k...r]
        if (i<n1)
            for (;i<n1;i++)
                a[k++] = L[i];

        if (j<n2)
            for (;j<n2;j++)
                a[k++] = R[j];
    }

}

②测试

public class Test_01 {

    public static void main(String[] args) {
        Integer a[] = {1,2,5,8,9,0,3,4,6,7};
        String b[] = {"AoMen","BeiJing","ShangHai","ChongQing","TianJin","XiangGang"};
        Double c[] = {0.5,3.7,6.3,8.5,9.2,1.7,2.3,4.1,5.9,7.4};

        LinearList_01.merge(a,0,4,9);
        LinearList_01.merge(b,0,2,5);
        LinearList_01.merge(c,0,4,9);

        int i=0;
        for (i=0;i<a.length;i++){
            System.out.print(a[i]+"");
        }
        System.out.println();
        for (i=0;i<b.length;i++){
            System.out.print(b[i]+"");
        }
        System.out.println();
        for (i=0;i<c.length;i++){
            System.out.print(c[i]+"");
        }


    }
}

2、可比较类型线性表容器版本

①程序源码

import java.util.List;

public class LinearList_02 {

    public static void merge(List<Comparable> a, int p, int q, int r) {
        int i, j, k;
        int n1 = q - p + 1;//[p....q]的长度
        int n2 = r - q;//[q+1....r]的长度

        Comparable[] L = new Comparable[n1];//将a[p...q]复制到L
        Comparable[] R = new Comparable[n2];//将a[q+1...r]复制到R

        for (i = 0; i < n1; i++) {
            L[i] = a.get(p + i);
        }

        for (j = 0; j < n2; j++) {
            R[j] = a.get(q + 1 + j);
        }

        i = j = 0;
        k = p;
        while (i < n1 && j < n2) {
            if (L[i].compareTo(R[j]) < 0) {
                a.set(k++, L[i++]);
            } else {
                a.set(k++, R[j++]);
            }
        }

        if (i<n1)
            for (;i<n1;i++)
                a.set(k++,L[i]);

        if (j<n2)
            for (;j<n2;j++)
                a.set(k++,R[j]);
    }
}

本方法的参数a的类型改变为List，这意味着，该方法可以施用于元素类型是Comparable的子类的ArrayList、LinkedList、Vector等容器。

②测试

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;

public class Test_02 {

    public static void main(String[] args) {
        Integer a[] = {1,2,5,8,9,0,3,4,6,7};
        String b[] = {"AoMen","BeiJing","ShangHai","ChongQing","TianJin","XiangGang"};
        Double c[] = {0.5,3.7,6.3,8.5,9.2,1.7,2.3,4.1,5.9,7.4};

        ArrayList<Integer> A = new ArrayList<Integer>();
        for (Integer integer : a) {
            A.add(integer);
        }

        Vector<String> B = new Vector<String>();
        for (String s : b) {
            B.add(s);
        }

        LinkedList<Double> C = new LinkedList<>();
        for (Double aDouble : c) {
            C.add(aDouble);
        }

        LinearList_02.merge((List)A,0,4,9);
        System.out.println(A);
        LinearList_02.merge((List)B,0,2,5);
        System.out.println(B);
        LinearList_02.merge((List)C,0,4,9);
        System.out.println(C);

    }

}

3、双向版本

①算法程序

	import java.util.Comparator;
import java.util.List;

public class LinearList_03 {

    public static void merge(List<Comparable> a, int p, int q, int r, Comparator comp){
        int i,j,k;
        int n1 = q-p+1;
        int n2 = r-q;

        Comparable[] L = new Comparable[n1];
        Comparable[] R = new Comparable[n2];
        for (i=0;i<n1;i++)
            L[i] = a.get(p+i);

        for (j=0;j<n2;j++)
            R[j] = a.get(q+1+j);
        i=j=0;
        k=p;
        while (i<n1 && j<n2){
            if (comp.compare(L[i],R[j])<0)
                a.set(k++,L[i++]);
            else
                a.set(k++,R[j++]);
        }
        if (i<n1)
            for (;i<n1;i++)
                a.set(k++,L[i]);
        if (j<n2)
            for (;j<n2;j++)
                a.set(k++,R[j]);

    }

}

import java.util.Comparator;

public class Greater implements Comparator<Comparable> {
    public int compare(Comparable x, Comparable y){
        return x.compareTo(y);
    }
}

import java.util.Comparator;

public class Less implements Comparator<Comparable> {
    @Override
    public int compare(Comparable o1, Comparable o2) {
        return o2.compareTo(o1);
    }
}