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

最新推荐文章于 2025-03-16 23:56:29 发布

原创最新推荐文章于 2025-03-16 23:56:29 发布 · 164 阅读

0 ·

CC 4.0 BY-SA版权

本文深入探讨了多种经典算法，包括KMP算法、Horspool算法、汉诺塔问题、青蛙跳台阶问题以及各种排序算法（如快速排序、桶排序、希尔排序和堆排序）。通过具体的实现代码，帮助读者理解这些算法的工作原理及应用场景。

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;
    }
}