算法实现之应用分治策略的算法实现2

1.同时找出数组中最大最小元素

Java实现

public static int[]findmaxmin(int[]arr)
    {
        int []arr0 = new int[2];
        if(arr.length==1)
        {
            arr0[0]=arr[0];//设为最大
            arr0[1]=arr[0];//设为最小
        }
        else
        {
            int[]arr1 = new int[arr.length/2];
            int a;
            if(arr.length%2==0)
            {
                a = arr.length/2;
            }
            else
            {
                a = arr.length/2+1;
            }
            int[]arr2 = new int[a];
            System.arraycopy(arr, 0, arr1, 0, arr.length / 2);
            System.arraycopy(arr, arr.length/2, arr2, 0, arr.length-arr.length/2);
            arr0[0]=Math.max(findmaxmin(arr1)[0],findmaxmin(arr2)[0]);//递归比较最大
            arr0[1]=Math.min(findmaxmin(arr1)[1],findmaxmin(arr2)[1]);//递归比较最小

        }
        return arr0;
    }

python实现 

def find_max_min(arr):
    arr0 = [0, 0]
    if len(arr) == 1:
        arr0[0] = arr[0]
        arr0[1] = arr[0]
    else:
        arr1 = arr[:len(arr)//2]
        if len(arr) % 2 == 0:
            a = len(arr) // 2
        else:
            a = len(arr) // 2 + 1
        arr2 = arr[len(arr)//2:len(arr)]
        arr0[0] = max(find_max_min(arr1)[0], find_max_min(arr2)[0])
        arr0[1] = min(find_max_min(arr1)[1], find_max_min(arr2)[1])
    return arr0

2.锦标赛算法求数组第二大数

1、首先进行两两分组比较，大的数进入下一轮；被淘汰的数标记在淘汰它的元素上

2、每轮进行比拼，直到剩下1个元素即max为止

3、然后在被max淘汰的数里面找到最大的数，这个最大的数就是数组里的第二大的数

Java实现

public static void cmp(int[] a, int[] b, int n, int k, int v)
    {
        int k1 = k * 2 + 1;
        int k2 = k1 + 1;

        if (k1 >= n || k2 >= n)
        {
            b[k] = -1;
            return;
        }

        if (b[k1] == v)
        {
            cmp(a, b, n, k1, v);
        }
        else
        {
           cmp(a, b, n, k2, v);
        }

        if (b[k1] < 0)
        {
            if (b[k2] >= 0)
            {
                b[k] = b[k2];
            } else
            {
                b[k] = -1;
            }
            return;
        }

        if (b[k2] < 0)
        {
            if (b[k1] >= 0)
            {
                b[k] = b[k1];
            } else {
                b[k] = -1;
            }
            return;
        }

        if (a[b[k1]] > a[b[k2]])
        {
            b[k] = b[k1];
        } else {
            b[k] = b[k2];
        }
    }

    public static void findsecondmax(int[] a, int len)
    {
        int n = 1;
        while (n < len)
        {
            n *= 2;
        }

        int[] b = new int[2 * n - 1];
        for (int i = 0; i < n; i++)
        {
            if (i < len)
            {
                b[n - 1 + i] = i;
            }
            else
            {
                b[n - 1 + i] = -1;
            }
        }

        for (int i = 2 * n - 2; i > 0; i -= 2)
        {
            if (b[i] < 0)
            {
                if (b[i - 1] >= 0)
                {
                    b[(i - 1) / 2] = b[i - 1];
                } else {
                    b[(i - 1) / 2] = -1;
                }
            }
            else
            {
                if (a[b[i]] > a[b[i - 1]])
                {
                    b[(i - 1) / 2] = b[i];
                } else {
                    b[(i - 1) / 2] = b[i - 1];
                }
            }
        }

        cmp(a, b, 2 * n - 1, 0, b[0]);

        System.out.println("第二大的数为: " + a[b[0]]);
    }

python实现

def show(array, len):
    for i in range(len):
        print("{:<3d}".format(array[i]), end=" ")
    print()

def pk(a, b, n, k, v):
    k1 = k * 2 + 1
    k2 = k1 + 1

    if k1 >= n or k2 >= n:
        b[k] = -1
        return

    if b[k1] == v:
        pk(a, b, n, k1, v)
    else:
        pk(a, b, n, k2, v)

    if b[k1] < 0:
        if b[k2] >= 0:
            b[k] = b[k2]
        else:
            b[k] = -1
        return

    if b[k2] < 0:
        if b[k1] >= 0:
            b[k] = b[k1]
        else:
            b[k] = -1
        return

    if a[b[k1]] > a[b[k2]]:
        b[k] = b[k1]
    else:
        b[k] = b[k2]

def FindSecond(a, len):
    n = 1
    while n < len:
        n *= 2

    b = [0] * (2 * n - 1)
    for i in range(n):
        if i < len:
            b[n - 1 + i] = i
        else:
            b[n - 1 + i] = -1

    for i in range(2 * n - 1 - 1, 0, -2):
        if b[i] < 0:
            if b[i - 1] >= 0:
                b[(i - 1) // 2] = b[i - 1]
            else:
                b[(i - 1) // 2] = -1
        else:
            if a[b[i]] > a[b[i - 1]]:
                b[(i - 1) // 2] = b[i]
            else:
                b[(i - 1) // 2] = b[i - 1]

    pk(a, b, 2 * n - 1, 0, b[0])

    print("第二大的数: {}".format(a[b[0]]))

本文仅为学习记录，如有错误欢迎指出。