面试 数据结构 以及基本算法题目

1.KMP

    int j = 0;
    int k = -1;
    while (j < p.length - 1) {
       if (k == -1 || p[j] == p[k]) {
              j++;
              k++;
              next[j] = k;
       } else {
           k = next[k];
       }
    }

    return next;

2.Horspool 算法

def shift_table(pattern):

 # 生成 Horspool 算法的移动表

 # 当前检测字符为c，模式长度为m

 # 如果当前c不包含在模式的前m-1个字符中，移动模式的长度m

 # 其他情况下移动最右边的的c到模式最后一个字符的距离

 table = defaultdict(lambda: len(pattern))

 for index in range(0, len(pattern)-1):

  table[pattern[index]] = len(pattern) - 1 - index

 return table

def horspool_match(pattern, text):

 # 实现 horspool 字符串匹配算法

 # 匹配成功，返回模式在text中的开始部分；否则返回 -1

 table = shift_table(pattern)

 index = len(pattern) - 1

 while index <= len(text) - 1:

  print("start matching at", index)

  match_count = 0

   #从右往左

  while match_count < len(pattern) and pattern[len(pattern)-1-match_count] == text[index-match_count]:

   match_count += 1

  if match_count == len(pattern):

   return index-match_count+1

  else:

   index += table[text[index]]

 return -1

3.汉诺塔

 def mov(a,b,c,n):

               move(a,c,b,n-1)

               move(a,b,c,1)

                move(b,a,c,n-1)

4.青蛙跳台阶问题

   4.1f(n) =f(n-1)+fn(n-2)

   4.2  for i in range(n):

               sum = res1 + res2;

                res1 = res2;

                res2 = sum ;

5.排序

  5.1 快速排序

       i = 0； j=len(str)

       key = str[i]

       while(i<j):

                while(str[j]>key) and left  < right:

                         j--

                  str[i] = str[j]

                  while left< right and (str[i]<key)

                          i++

                  str[j] = str[i]

         array[right] = key

        quick_sort(array,low , i-1)

       quick_sort(array,i+1 , high)

        5.2 桶排序 

                bucketNum =  max- min / bucksize  + 1   

                 buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);

     在套用其他排序

  5.3  希尔排序

      step = len /2

      while step> 0 :

         for i in range(step, len):

           while i >= step and nums[i]< nums[i - step]:

                 swap(nums[i],nums[i-step])

                 i = i-step

           #不需要else，因为保证了前面有序

         step = step/2

  5.4 堆排序

   

                 大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]  

                 小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]  

    public static void sort(int []arr){
        //1.构建大顶堆
        for(int i=arr.length/2-1;i>=0;i--){
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr,0,j);//重新对堆进行调整
        }

          

void AdjustDown(int arr[], int i, int n)
{
    int j = i * 2 + 1;//子节点 
    while (j<n)
    {
        if (j+1<n && arr[j] > arr[j + 1])//子节点中找较小的
        {
            j++;
        }
        if (arr[i] < arr[j])
        {
            break;
        }
        swap(arr[i],arr[j]);
        i = j;
        j = i * 2 + 1;
    }
}

                                    

                 

6.