第二章&第三章查找和排序（上）

最新推荐文章于 2022-02-12 16:34:16 发布

陈一Kristian

最新推荐文章于 2022-02-12 16:34:16 发布

阅读量266

点赞数

分类专栏：寒假算法专题总结

本文链接：https://blog.csdn.net/h_666666/article/details/86568460

版权

寒假算法专题总结专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1、经典递归问题：

汉诺塔问题：（递归+分治）

分治法要包括递归法：分治是指将原问题划分成多个小规模的子问题，递归的解决这些字问题然后合并其结果，得到原问题的解

代码：

class Main{
    public static void main(String[] args) {

        int num = 2;
        int x = hannuo(num);
        System.out.println(x);

    }
    static int hannuo(int n){
        if(n==1) return 1;

        return hannuo(n-1) +hannuo(n-1)+1;  //递归注意不要放到循环里
    }
}

自己刚开始的错误写法在下面，，会爆栈

class Main{
    public static void main(String[] args) {

        int num = 3;
        hannuo(num);
    }
    static int hannuo(int n){

        int sum =0;
        sum= hannuo(n-1) +hannuo(n-1)+1;   //注意递归不要加循环进去
        System.out.println(sum);
        return sum;   //不知道为什么会爆栈
    }
}

小白上楼梯：

小白在上楼梯，一共n阶，小白一次可以上1 2 3 阶，计算走完的方式


import java.util.Scanner;

class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int x = climb(n);
        System.out.println(x);
    }
    static int climb(int n){
        if(n==0) return 1;
        if(n==1) return 1;
        if(n==2) return 2;
        return climb(n-1)+climb(n-2)+climb(n-3);
    }

}

３９阶台阶

小明刚刚看完电影《第K级台阶》，离开电影院的时候，他数了数礼堂前的台阶数，恰好是K级!

站在台阶前，他突然又想着一个问题：

如果我每一步只能迈上1个或2个台阶。先迈左脚，然后左右交替，最后一步是迈右脚，

也就是说一共要走偶数步。那么，上完K级台阶，有多少种不同的上法呢？

请你利用计算机的优势，帮助小明寻找答案。

import java.util.Scanner;

//一堆数组和一个数组　求那一个的数组
//都转化为三进制的，因为３个相同的三进制数字无进制相加和为０
class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int k= sc.nextInt();
        int step[][] =new int[39][2]; //第一纬是多少阶，第二味是左右脚

        //第一阶台阶，左脚有一种，右脚没有
        step[0][0] = 1;
        step[0][1] = 0;

        //第二阶台阶 左脚一种，右脚一种
        step[1][0] = 1;
        step[1][1] =1;

        //之后的从第二阶开始数,但是左脚是基于右脚的基础，右脚基于左脚的基础
        for(int i=2;i<k;i++){
            step[i][0] +=step[i-1][1]+step[i-2][1];
            step[i][1] +=step[i-1][0]+step[i-2][0];

        }
        System.out.println(step[k-1][1]);
     }
}

2、基于查找排序的引申题目：

旋转数组的最小数字（改造二分法）：

把一个数组最开始的若干个元素搬到数组的末尾，称之为数组的旋转，输入一个递增排序的数组的一个旋转，输出旋转数的最小值，例如{3,4,5,1,2}为{1,2,3,4,5}的旋转，结果为1

解：排序没有啥意思了，所以不用排序，看到递增，又要查找可以用二分

 
class Main{
    public static void main(String[] args) {
        int arr[] = {3,4,5,1,2};
        int x = findmin(arr);
        System.out.println(x);
    }
    static int findmin(int []arr){
        int begin = 0;
        int end = arr.length-1;
        if(arr[begin]<arr[end]) return arr[begin];
       
        while (begin+1<end){
            int mid = begin+((end-begin)>>1);

            if(arr[mid]>=arr[begin]){ //左侧有序
                begin = mid;
            }else {
                end = mid; //右侧有序
            }
        }
        
        return arr[end];
    }
}

之前代码一直有问题，最后发现是位运算那里少了一个括号，，，哎，括号能多不能少，以后多写吧

关于这个题的引申题目：

给一个整数数组，找到两个数使得他们的和等于一个给定的数 target。你需要输出这两个数的下标, 并且第一个下标小于第二个下标。注意这里下标的范围是 0 到 n-1。

你可以假设数组递增有序。

请在O(N)时间内完成。

import java.util.Arrays;

class test6{
    public static int num = 0;
    static int temp[];
    public static void main(String[] args) {
        int []arr = {3,2,1,5,4};
        sort(arr,0,arr.length-1);
        System.out.println(Arrays.toString(arr));
        System.out.println(num);
    }

    private static void sort(int[] arr,int left,int right){
        temp= new int[arr.length];
        if(left<right){
            int mid = (left+right)/2;
            sort(arr,left,mid);//左边归并排序，使得左子序列有序
            sort(arr,mid+1,right);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right);//将两个有序子数组合并操作
        }
    }
    private static void merge(int arr[],int left,int mid,int right){
        int i = left;//左序列指针
        int j = mid+1;//右序列指针
        int t = 0;//临时数组指针
        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
                num+= mid-left+1;//当左边的left index满足条件时，左边left往后的所有element都会满足条件，此时的个数为mid - left + 1,
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        //把temp数组里的数字都拷贝到原数组里去吧
        t=0;
        while (left<=right){
            arr[left++] = temp[t++];
        }
    }

}

找最长连续递增子序列：

（1,9,2,5,7,3,4,6,8,0）中最长递增子序列为（３，４，６，８）

class Main{
    public static void main(String[] args) {
        int arr[] = {1,9,2,5,7,3,4,6,8,0};
        int [] list= find(arr);
        for(int i=0;i<list.length;i++){
            System.out.println(list[i]);
        }
    }
    static int[] find(int [] arr){
        int low = 0;
        int high =1;
        int begin = 0;
        int end=0;
        int count = 0;
        int max = 0;
        for (int i=0;i<arr.length;i++){
            if(arr[high]>arr[low]){
                high++;
                count++;
            }else {
                if(count>max){
                    max = count;
                    begin = low;
                    end = high;
                }
                low = high;
                count =0;
            }

        }
        int [] newData = {0};
        System.arraycopy(arr,begin,newData,0,end-begin+1);
        return newData;

    }

}

代码有问题，，不会不知道为啥

快速幂问题；

快速求出２的１０次方

class Main{
    public static void main(String[] args) {
        int a= 2;
        int n= 5;
        int  h =pow(a,n);
        System.out.println(h);
    }
    static int pow(int a,int n){
        if(n==0) return 1;
        int ex= 1;
        int res = a;  //注意这里不能直接用a　因为下面要成时a的数字就变了
        while((ex<<1)<=n){
            res = res*res;
            ex = ex<<1;

        }
        return res*pow(a,n-ex);
    }

}

寻找发帖水王：

Tango是微软亚洲研究院的一个试验项目。研究院的员工和实习生们都很喜欢在Tango上面交流灌水。传说，Tango有一大“水王”，他不但喜欢发贴，还会回复其他ID发的每个帖子。坊间风闻该“水王”发帖数目超过了帖子总数的一半。如果你有一个当前论坛上所有帖子（包括回帖）的列表，其中帖子作者的ID也在表中，你能快速找出这个传说中的Tango水王吗？
解：两两消除，不管是否包含水王，，通过把数字的个数减少，将其转化为更小的问题

Type Find(Type *ID,int N){
        
        Type candidate;
        int nTime = 0;
        for(int i=0;i<N;i++){
            
            if(nTime==0){
                candidate = ID[i],nTime = 1;
            }else{
                if(candidate == ID[i])
                    nTime++;
                else 
                    nTime--;
            }
        }
        return candidate;
    }

练习

１、

你可以假设数组递增有序。

请在O(N)时间内完成。

思路：首先　暴力，但是复杂度在ｎ^2，所以不行。　有序递增的话可以考虑去用二分查找法，复杂度在ｎｌｏｇｎ，所以也不行　。最后，，考虑双指针，因为有序所以复杂度会很低。另外，还可以用ｈａｓｈｍａｐ，复杂度在ｎ级

class Main {
    public static void main(String[] args) {
        int []arr = {-8,-4,-3,0,2,4,5,8,9,10};
        int begin = 0;
        int end =arr.length-1;
        int k = 10;
        while(begin <end){
            if(arr[begin]+arr[end]==k){
                System.out.println("("+arr[begin]+","+arr[end]+")");
                begin++;
            }
            if(arr[begin]+arr[end]>k){
                end--;
            }
            if(arr[begin]+arr[end]<k){
                begin++;
            }
        }


    }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class test{
    public static ArrayList<Integer> twosum(int[] sum, int target){
        ArrayList<Integer> temp = new ArrayList<Integer>();  //arraylist基于数组实现的collection
        Map<Integer,Integer> a = new HashMap<Integer,Integer>();
        //将数组中的元素为key，下标为value:
        for(int i=0;i<sum.length;i++) {
            a.put(sum[i], i);
        }
        for(int i=0;i<sum.length;i++) {
            int x=sum[i];
            int y=target-x;
            if(a.containsKey(y)&&i!=a.get(y)&&y>x) {
                temp.add(i);
                temp.add(a.get(y));
            }
        }

        return temp;
    }
    public static void main(String[] args) {

        int[] num = {-8,-4,-3,0,2,4,5,8,9,10};
        ArrayList list  = new ArrayList();
        list = twosum(num,10);
    //    System.out.println(list);

        for(int j=0;j<list.size();j=j+2) {
            int[] t=new int[2];
            t[0] = list.get(j);
            t[1] = list.get(j+1);  //list接口的方法
            System.out.println("("+t[0]+","+t[1]+")");
        }

    }
}

那三元组呢？三元组应该怎么解？

两道逆序对的题目：

合并有序数组：

给定两个排序后的数组Ａ和Ｂ，Ａ的末端有足够的缓冲空间容纳Ｂ，如何将Ｂ并入Ａ排序中。

思路：　Ａ和Ｂ从最后开始比大小，，大的数字放在Ａ的末尾　　，，注意，ｂ比较小的话，在ｂ完后，，ａ不用复制

先来写一下

public static void merge(int[] a,int[] b,int lastA,int lastB){
        int indexA=lastA-1;
        int indexB=lastB-1;
        int indexMerged=lastA+lastB-1;

        while(indexA>=0&&indexB>=0){
        if(a[indexA]>b[indexB]){
        a[indexMerged]=a[indexA];
        indexMerged--;
        indexA--;
        }else{
        a[indexMerged]=a[indexB];
        indexMerged--;
        indexB--;
        }
        }

        while(indexB>=0){
        a[indexMerged]=a[indexB];
        indexMerged--;
        indexB--;
        }

        }

逆序对个数：

一个数列，左边数大，右边数小，则这俩数为逆序对，求数列中逆序对的个数。

思路；不要爆破，

合并排序：合并排序是将一个数组均分，递归调用对子数组进行排序，然后将子数组合并，主要使用分治思想。在本题中，示例数组可分为：

[8,8,3,0]

[6,8,9,3]

分别排序之后为

A: [0,3,8,8]

B: [3,6,9,8]

设置i=0,j=0分别标志A、B数组，在合并的过程中，比较A[i]、B[j]，若A[i]>B[j] 则将B[i]放入原数组，i++,同理将数据依次放入。

解决逆序对的最关键的就是合并这一步，假设A[i]>B[i]了，那么A[i]之后的所有数据，都是大于B[i]的，此时设置一个标识，用于记录数据，返回这个数据，递归，最后就可以得到所有逆序对了，这一方法的时间复杂度为O(nlogn)，在数组数据非常多的时候可以明显感受到它的效率。

小tip：[8, 8, 3, 0, 6, 8, 9, 3]，前大后小的数据即为一个逆序对，例如[8,3]、[3,0]　输出格式？？

！！！！这儿的思路是，把他分成两个部分，然后左有序，右有序，然后再两边合并，放到整个数组中来看就是把左边一直通过分成左右递归到最深处，然后合并左边最深处的两个，一直合并到全数组的左边有序，然后去拆分全数组的右边，直到全数组的右边有序，然后在ｍｅｒｇｅ全数组的左右。

一般的归并排序：

public class test3 {

    public static void merSort(int[] arr,int left,int right){

        if(left<right){
            int mid = (left+right)/2;
            merSort(arr,left,mid);//左边归并排序，使得左子序列有序
            merSort(arr,mid+1,right);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right);//合并两个子序列
        }
    }

    private static void merge(int[] arr, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];//ps：也可以从开始就申请一个与原数组大小相同的数组，因为重复new数组会频繁申请内存
        int i = left;
        int j = mid+1;
        int k = 0;
        while(i<=mid&&j<=right){
            if (arr[i] < arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
     
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[k++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[k++] = arr[j++];
        }
        //将temp中的元素全部拷贝到原数组中
        for (int k2 = 0; k2 < temp.length; k2++) {
            arr[k2 + left] = temp[k2];
        }
    }
    public static void main(String args[]){
        int[] test = {9,2,6,3,5,7,10,11,12};
        merSort(test,0,test.length-1);
        for(int i=0; i<test.length;i++){
            System.out.print(test[i] + " ");
        }
        System.out.println(count);
    }

}

这个题：

public class test3 {

    public static void merSort(int[] arr,int left,int right){

        if(left<right){
            int mid = (left+right)/2;
            merSort(arr,left,mid);//左边归并排序，使得左子序列有序
            merSort(arr,mid+1,right);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right);//合并两个子序列
        }
    }
    static int count =0;
    private static void merge(int[] arr, int left, int mid, int right) {
        int[] temp = new int[right - left + 1];//ps：也可以从开始就申请一个与原数组大小相同的数组，因为重复new数组会频繁申请内存
        int i = left;
        int j = mid+1;
        int k = 0;
        while(i<=mid&&j<=right){
            if (arr[i] < arr[j]) {
                temp[k++] = arr[i++];
            } else {
                temp[k++] = arr[j++];
                count+= mid-i+1;
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[k++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[k++] = arr[j++];
        }
        //将temp中的元素全部拷贝到原数组中
        for (int k2 = 0; k2 < temp.length; k2++) {
            arr[k2 + left] = temp[k2];
        }
    }
    public static void main(String args[]){
        int[] test = {9,2,6,3,5,7,10,11,12};
        merSort(test,0,test.length-1);
        for(int i=0; i<test.length;i++){
            System.out.print(test[i] + " ");
        }
        System.out.println(count);
    }

}

特殊排序：

输入正整数数组，数组所有整数拼接起来排成一个数，打印最小的，例如：｛３，３２，３２１｝则打印３

个数能排成的最小数为３２１３２３

package org.lanqiao.algo.elementary._03sort;

import java.util.Arrays;
import java.util.Comparator;

public class Case11_MinCombineNum {
  public static void main(String[] args) {
    int res = f(new Integer[]{3, 32, 321});
    System.out.println(res);
  }

  private static int f(Integer[] arr) {
    //自定义比较规则
    Arrays.sort(arr, new Comparator<Integer>() {

      @Override
      public int compare(Integer o1, Integer o2) {
        String s1 = o1 + "" + o2;
        String s2 = o2 + "" + o1;
        return s1.compareTo(s2);
      }
    });
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < arr.length; i++) {
      sb.append(arr[i]);
    }
    return Integer.parseInt(sb.toString());
  }
}

陈一Kristian

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第二章&第三章查找和排序（上）

1、经典递归问题：汉诺塔问题：（递归+分治）分治法要包括递归法：分治是指将原问题划分成多个小规模的子问题，递归的解决这些字问题然后合并其结果，得到原问题的解代码：class Main{ public static void main(String[] args) { int num = 2; int x = hannuo(num); ...
复制链接

扫一扫