zoukankan      html  css  js  c++  java
  • CareerCup Chapter 9 Sorting and Searching

    9.1 You are given two sorted arrays, A and B, and A has a large enough buffer at the end to hold B. Write a method to merge B into A in sorted order.

           A has enough buffer at the end to hold B, we can merge two arrays from end to start index, like merge two arrays in merge sort algorithm.

           void mergeTwoArray(int A[],int m,int B[],int n){

                  int k=m+n-1;

                  m--;n--;

                  while(m>=0&&n>=0){

                         if(A[m]>=B[n])A[k--]=A[m--];

                         else A[k--]=B[n--];

                   }

                   while(m>=0)A[k--]=A[m--];

                   while(n>=0)A[k--]=B[n--];

           }

    9.2 Write a method to sort an array of strings so that all the anagrams are next to each other.

           Based on basic sort function, we define a cmp function to decide how to sort. Here, we compare theirs anagrams' state.

           int cmp(string s1,string s2){

                  sort(s1.begin(),s1.end());

                  sort(s2.begin(),s2.end());

                  if(s1<s2)return 1;

                  else return 0; 

          }

          void sortStrings(vector<string> &strs){

                  sort(strs.begin(),strs.end(),cmp);

          }

    **9.3 Given a sorted array of n integers that has been rotated an unknown number of times, give an O(log n) algorithm that finds an element in the array. You may assume that the array was originally sorted in increasing order.
    EXAMPLE:
    Input: find 5 in array (15 16 19 20 25 1 3 4 5 7 10 14) 

    Output: 8 (the index of 5 in the array)

           like binary search, we declare left/mid/right variables to represent current array part, because the array is rotated, we will have 8 states as following: k is the goal data.

          k<a[mid],k<a[left],k<a[right], in this condition, right=mid-1 || left=mid+1, for we cannot make sure which part including rotated part.

          k<a[mid],k<a[left],k>a[right], in this condition, left=mid+1;

          k<a[mid],k>a[left],k<a[right], in this condition, right=mid-1;

          k<a[mid],k>a[left],k>a[right], in this condition, right = mid-1;

          k>a[mid],k<a[left],k<a[right], in this condition, left=mid+1;

          k>a[mid],k<a[left],k>a[right], in this condition, right=mid-1;

          k>a[mid],k>a[left],k<a[right], in this condition, left=mid+1;

          k>a[mid],k>a[left],k>a[right], in this condition, left=mid+1 || right=mid-1;

    int findIndex(int a[],int left,int right,int k){
        if(left>right)return -1;
        int mid=left+(right-left)/2;
        if(k==a[mid])return mid;
        else if(k==a[left])return left;
        else if(k==a[right])return right;
        else if(k<a[mid]){
            if(k<a[left]){
                if(k<a[right]){
                    int temp=findIndex(a,left,mid-1,k);
                    if(temp!=-1)return temp;
                    return findIndex(a,mid+1,right,k);
                }else{
                    return findIndex(a,mid+1,right,k);
                }
            }else if(k>a[left]){
                return findIndex(a,left,mid-1,k);
            }
        }else if(k>a[mid]){
            if(k>right){
                if(k>left){
                    int temp=findIndex(a,left,mid-1,k);
                    if(temp!=-1)return temp;
                    return findIndex(a,mid+1,right,k);
                }else{
                    return findIndex(a,left,mid-1,k);
                }
            }else{
                return findIndex(a,mid+1,right,k);
            }
        }
        return -1;
    }
        int search(int A[], int n, int target) {
            return findIndex(A,0,n-1,target);
        }

            Method2: not only compare target with a[left/mid/right], we compare a[left]/a[mid]/a[right] to decide which part has rotated part.

            k<mid,left<mid,k<left, in this condition, left=mid+1

            k<mid,left<mid,k>left, in this condition, right=mid-1

            k<mid,left>mid, in this condition, right=mid-1

            k>mid,left<mid, in this condition, left=mid+1

            k>mid,left>mid,k>right, in this condition, right=mid-1

            k>mid,left>mid,k<right, in this condition, left=mid+1

            int search(int A[],int n,int target){

                 int left=0,right=n-1,mid;

                 while(left<=right){

                       mid=left+(right-left)/2;

                       if(A[mid]==target)return mid;

                       else if(target<A[mid]){

                                    if(A[left]<=A[mid]){

                                        if(target<A[left])left=mid+1;

                                        else right=mid-1;

                                    }else right=mid-1;

                       }else{

                                    if(A[left]>A[mid]){

                                          if(target<=A[right])left=mid+1;

                                          else right=mid-1;

                                    }else left=mid+1;

                        }

                  }

                  return -1;

            }

    9.4 If you have a 2 GB file with one string per line, which sorting algorithm would you use to sort the file and why?

     external sort. Divide to N parts, sort each part, then N-way merge.

    9.5 Given a sorted array of strings which is interspersed with empty strings, write a method to find the location of a given string.
    Example: find “ball” in [“at”, “”, “”, “”, “ball”, “”, “”, “car”, “”, “”, “dad”, “”, “”] will return 4

    Example: find “ballcar” in [“at”, “”, “”, “”, “”, “ball”, “car”, “”, “”, “dad”, “”, “”] will return -1

          we do it based on binary search, first, we traverse the front part and the back part to make true left index and right index pointing to a no-empty string. Then we find mid index, if strs[mid]=="", we traverse mid to right then to left to find the first no-empty string, this index is the mid index and do it like binary search.

          int searchStrs(vector<string> strs,string target){

                 if(target==""||strs.size()==0)return -1;

                 int left=0,right=strs.size()-1,mid;

                 while(left<=right){

                        while(strs[left]==""&&left<right)left++; 

                        while(strs[right]==""&&right>left)right--;

                        mid=left+(right-left)/2;

                        if(strs[left]==target)return left;

                        if(strs[right]==target)return right;

                        if(strs[mid]==""){

                               for(int i=mid+1;i<right;i++){if(strs[i]!="")break;}

                               if(i!=right)mid=i;

                               else{

                                      for(int i=mid-1;i>left;i--){if(strs[i]!="")break;}

                                      if(i!=left)mid=i

                                      else return -1;

                                }

                         }

                         if(strs[mid]==target)return mid;

                         else if(strs[mid]<target)left=mid+1;

                         else if(strs[mid]>target)right=mid-1;  

                        }

                 }

                 return -1;

         }

    9.6 Given a matrix in which each row and each column is sorted, write a method to find an element in it.

           the matrix is sorted in rows and columns, let's assume it is a m*n matrix, we begin at matrix[0][n-1], if target< current, we move down, if target>current, we move left, if(target ==current) we find it, if we move out of the matrix, the element isn't in it.

           time complexity is O(n+m).

           int rowAndColumn(vector<vector<int> > matrix,int target){

                int m=matrix.size();if(m==0)return -1;

                int n=matrix[0].size();if(n==0)return -1;

                int x=0,y=n-1;

                while(x<m&&y>=0){

                         if(matrix[x][y]==target)return x*n+y;

                         else if(matrix[x][y]>target)y--;

                         else if(matrix[x][y]<target)x++;

                 }

                 return -1;

          }

    9.7 A circus is designing a tower routine consisting of people standing atop one another’s shoulders. For practical and aesthetic reasons, each person must be both shorter and lighter than the person below him or her. Given the heights and weights of each person in the circus, write a method to compute the largest possible number of people in such a tower.
    EXAMPLE:
    Input (ht, wt): (65, 100) (70, 150) (56, 90) (75, 190) (60, 95) (68, 110)
    Output: The longest tower is length 6 and includes from top to bottom: (56, 90) (60,95) (65,100) (68,110) (70,150) (75,190)

          we first sort all people by their height, then find the longest ascending sequence of their wight.

          struct People{

                 int height;

                 int weight; 

         };

          int cmp(People* p1,People* p2){

                if(p1->height<p2->height)return 1;

                else return 0;

         }

          int largestNum(vector<People*> peos){

                 if(peos.size()==0)return 0;

                 sort(peos.begin(),peos.end(),cmp);

                 int *f = new int[peos.size()];

                 int maxNum=0;

                 for(int i=0;i<peos.size();i++){

                         f[i]=1;

                         for(int j=0;j<i;j++){

                                 if(peos[j]->weight<peos[i]->weight){

                                       f[i]=max(f[i],f[j]+1); 

                                }

                         }

                         maxNum=(maxNum>f[i]?maxNum:f[i]);

                 }

                 return maxNum;

         }

  • 相关阅读:
    Spring Boot 2.1.10 学习笔记(2)
    Spring Boot 2.1.10 学习笔记(1)
    Win10 下载与激活 MSDN
    Java JDK 1.8 下载及其版本说明 8u202(最后一个免费版)
    shell函数开发意见优化系统脚本
    php大文件下载支持断点续传
    xunsearch使用笔记
    微信使用的curl方法
    php执行sql语句打印结果
    二维数组排序:array_orderby(php官网评论)
  • 原文地址:https://www.cnblogs.com/hrhguanli/p/3838533.html
Copyright © 2011-2022 走看看