演算法面試問題

Ⅰ 如何回答面試演算法問題

給定一個有序數組xxx 中,"有序"是否可以利用?

a: 用幾個簡單的測試用例,檢驗一下
b:暴力解法 通常都是思考的起點.

a: 遍歷常見的演算法思路
b: 遍歷常見的數據結構

c: 空間和時間的交換?
d: 預處理數據 => 排序
e: 在瓶頸處找到答案

a: 極端條件判斷
數組為空? 字元串==null? 數字==0? 指針->null?
b: 變數名等 符合規范
c: 注重模塊化,復用性

演算法在1s之內 可解決的問題:
O(n^2) 的演算法可處理大約10^4級別的數據
O(n) 的演算法可處理大約10^8級別的數據
O(nlogn)的演算法可處理大約10^7級別的數據

Ⅱ 大公司筆試面試有哪些經典演算法題目

1、二維數組中的查找

具體例題：如果一個數字序列逆置之後跟原序列是一樣的就稱這樣的數字序列為迴文序列。例如：{1, 2, 1}, {15, 78, 78, 15} , {112} 是迴文序列, {1, 2, 2}, {15, 78, 87, 51} ,{112, 2, 11} 不是迴文序列。現在給出一個數字序列，允許使用一種轉換操作：選擇任意兩個相鄰的數，然後從序列移除這兩個數，並用這兩個數字的和插入到這兩個數之前的位置(只插入一個和)。現在對於所給序列要求出最少需要多少次操作可以將其變成迴文序列？

Ⅲ java演算法面試題：排序都有哪幾種方法

一、冒泡排序
[java] view plain
package sort.bubble;
import java.util.Random;
/**
* 依次比較相鄰的兩個數，將小數放在前面，大數放在後面
* 冒泡排序，具有穩定性
* 時間復雜度為O（n^2）
* 不及堆排序，快速排序O（nlogn，底數為2）
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for(int i = 0 ; i < 10 ; i++){
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for(int i : sort){
System.out.print(i+" ");
}
buddleSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for(int i : sort){
System.out.print(i+" ");
}
}
/**
* 冒泡排序
* @param sort
*/
private static void buddleSort(int[] sort){
for(int i=1;i<sort.length;i++){
for(int j=0;j<sort.length-i;j++){
if(sort[j]>sort[j+1]){
int temp = sort[j+1];
sort[j+1] = sort[j];
sort[j] = temp;
}
}
}
}
}
二、選擇排序
[java] view plain
package sort.select;
import java.util.Random;
/**
* 選擇排序
* 每一趟從待排序的數據元素中選出最小（或最大）的一個元素，
* 順序放在已排好序的數列的最後，直到全部待排序的數據元素排完。
* 選擇排序是不穩定的排序方法。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
selectSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 選擇排序
* @param sort
*/
private static void selectSort(int[] sort){
for(int i =0;i<sort.length-1;i++){
for(int j = i+1;j<sort.length;j++){
if(sort[j]<sort[i]){
int temp = sort[j];
sort[j] = sort[i];
sort[i] = temp;
}
}
}
}
}
三、快速排序
[java] view plain
package sort.quick;
/**
* 快速排序 通過一趟排序將要排序的數據分割成獨立的兩部分， 其中一部分的所有數據都比另外一部分的所有數據都要小，
* 然後再按此方法對這兩部分數據分別進行快速排序， 整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
int[] sort = { 54, 31, 89, 33, 66, 12, 68, 20 };
System.out.print("排序前的數組為：");
for (int data : sort) {
System.out.print(data + " ");
}
System.out.println();
quickSort(sort, 0, sort.length - 1);
System.out.print("排序後的數組為：");
for (int data : sort) {
System.out.print(data + " ");
}
}
/**
* 快速排序
* @param sort 要排序的數組
* @param start 排序的開始座標
* @param end 排序的結束座標
*/
public static void quickSort(int[] sort, int start, int end) {
// 設置關鍵數據key為要排序數組的第一個元素，
// 即第一趟排序後，key右邊的數全部比key大，key左邊的數全部比key小
int key = sort[start];
// 設置數組左邊的索引，往右移動判斷比key大的數
int i = start;
// 設置數組右邊的索引，往左移動判斷比key小的數
int j = end;
// 如果左邊索引比右邊索引小，則還有數據沒有排序
while (i < j) {
while (sort[j] > key && j > start) {
j--;
}
while (sort[i] < key && i < end) {
i++;
}
if (i < j) {
int temp = sort[i];
sort[i] = sort[j];
sort[j] = temp;
}
}
// 如果左邊索引比右邊索引要大，說明第一次排序完成，將sort[j]與key對換，
// 即保持了key左邊的數比key小，key右邊的數比key大
if (i > j) {
int temp = sort[j];
sort[j] = sort[start];
sort[start] = temp;
}
//遞歸調用
if (j > start && j < end) {
quickSort(sort, start, j - 1);
quickSort(sort, j + 1, end);
}
}
}
[java] view plain
/**
* 快速排序
*
* @param a
* @param low
* @param high
* voidTest
*/
public static void kuaisuSort(int[] a, int low, int high)
{
if (low >= high)
{
return;
}
if ((high - low) == 1)
{
if (a[low] > a[high])
{
swap(a, low, high);
return;
}
}
int key = a[low];
int left = low + 1;
int right = high;
while (left < right)
{
while (left < right && left <= high)// 左邊向右
{
if (a[left] >= key)
{
break;
}
left++;
}
while (right >= left && right > low)
{
if (a[right] <= key)
{
break;
}
right--;
}
if (left < right)
{
swap(a, left, right);
}
}
swap(a, low, right);
kuaisuSort(a, low, right);
kuaisuSort(a, right + 1, high);
}
四、插入排序
[java] view plain
package sort.insert;
/**
* 直接插入排序
* 將一個數據插入到已經排好序的有序數據中,從而得到一個新的、個數加一的有序數據
* 演算法適用於少量數據的排序，時間復雜度為O(n^2)。是穩定的排序方法。
*/
import java.util.Random;
public class DirectMain {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
directInsertSort(sort);
System.out.println();
System.out.print("排序後的數組為");
for (int i : sort) {
System.out.print(i + " ");
}
}
/**
* 直接插入排序
*
* @param sort
*/
private static void directInsertSort(int[] sort) {
for (int i = 1; i < sort.length; i++) {
int index = i - 1;
int temp = sort[i];
while (index >= 0 && sort[index] > temp) {
sort[index + 1] = sort[index];
index--;
}
sort[index + 1] = temp;
}
}
}
順便添加一份，差不多的
[java] view plain
public static void charuSort(int[] a)
{
int len = a.length;
for (int i = 1; i < len; i++)
{
int j;
int temp = a[i];
for (j = i; j > 0; j--)//遍歷i之前的數字
{
//如果之前的數字大於後面的數字，則把大的值賦到後面
if (a[j - 1] > temp)
{
a[j] = a[j - 1];
} else
{
break;
}
}
a[j] = temp;
}
}
把上面整合起來的一份寫法：
[java] view plain
/**
* 插入排序:
*
*/
public class InsertSort {
public void sort(int[] data) {
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
swap(data, j, j - 1);
}
}
}
private void swap(int[] data, int i, int j) {
int temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
五、順便貼個二分搜索法
[java] view plain
package search.binary;
public class Main {
public static void main(String[] args) {
int[] sort = {1,2,3,4,5,6,7,8,9,10};
int mask = binarySearch(sort,6);
System.out.println(mask);
}
/**
* 二分搜索法，返回座標，不存在返回-1
* @param sort
* @return
*/
private static int binarySearch(int[] sort,int data){
if(data<sort[0] || data>sort[sort.length-1]){
return -1;
}
int begin = 0;
int end = sort.length;
int mid = (begin+end)/2;
while(begin <= end){
mid = (begin+end)/2;
if(data > sort[mid]){
begin = mid + 1;
}else if(data < sort[mid]){
end = mid - 1;
}else{
return mid;
}
}
return -1;
}
}

Ⅳ 經典C語言面試演算法題

經典C語言面試演算法題

1.寫一個函數,它的原形是int continumax(char *outputstr,char *intputstr)

功能：

在字元串中找出連續最長的數字串，並把這個串的長度返回，並把這個最長數字串付給其中一個函數參數outputstr所指內存。例如："abcd12345ed125ss123456789"的首地址傳給intputstr後，函數將返回

9，outputstr所指的值為123456789。

#include

#include

#include

int FindMax_NumStr(char *outputstr,char *inputstr)

{

char *in = inputstr,*out = outputstr,*temp;

char *final;

int count = 0;

int maxlen = 0;

int i;

while(*in!='')

{

if(*in > 47 && *in < 58)

{

for(temp = in;*in> 47 && *in <58;in++)

count++;

}

else

in++;

if(maxlen < count)

{

maxlen = count;

count = 0;

final = temp;

}

}

for(i =0;i

{

*out = *final;

out++;

final++;

}

*out = '';

return maxlen;

}

void main(void)

{

char input[]="abc123def123456eec123456789dd";

char output[50] = {0};

int maxlen;

maxlen = FindMax_NumStr(output,input);

printf("the str %s ",output);

printf("the maxlen is %d ",maxlen);

}

2.求1000!的未尾有幾個0;

求出1->1000里,能被5整除的數的個數n1,能被25整除的數的個數n2,能被125整除的'數的個數n3,能被625整除的數的個數n4.1000!末尾的零的個數=n1+n2+n3+n4;

只要是末尾是5的數它乘以一個偶數就會出現一個0，而末尾是0的數乘以任何數也都會出現0

而末尾是0的如果是一個0肯定能被5整除，兩個0肯定能被25整數，以此類推3個0就能被5的三次方整除，也就是125

1000!就是1-1000數的相乘，能被5整除的所有數分別乘以一個偶數就會出現這些個的0，而例如100，既能被5整除，也能被25整除，所以就是兩個0

1000，既能被5，25，也能被125整除，所以算三個0

例如是10!=1*2*3*4*5*6*7*8*9*10，裡面有兩個數能被5整除，就是10和5，而

5隨便乘以一個偶數就出現一個0，而10乘以其它數也會出現一個0，所以10!會有兩個0

#include

#define NUM 1000

int find5(int num)

{

int ret = 0;

while(num%5==0)

{

num/=5;

ret++;

}

return ret;

}

int main(void)

{

int result = 0;

int i;

for(i=5;i<=NUM;i+=5)

result +=find5(i);

printf("the total zero number is %d ",result);

return 0;

}

3。編寫一個 C 函數，該函數在一個字元串中找到可能的最長的子字元串，且該字元串是由同一字元組成的。

char * search(char *cpSource, char ch)

{

char *cpTemp=NULL, *cpDest=NULL;

int iTemp, iCount=0;

while(*cpSource)

{

if(*cpSource == ch)

{

iTemp = 0;

cpTemp = cpSource;

while(*cpSource == ch)

++iTemp, ++cpSource;

if(iTemp > iCount)

iCount = iTemp, cpDest = cpTemp;

if(!*cpSource)

break;

}

++cpSource;

}

return cpDest;

}

;

Ⅳ 數據結構與演算法處理面試題

1、時針走一圈，時針分針重合幾次

2、N*N的方格紙,裡面有多少個正方形

3、2000萬個整數，找出第五十大的數字？

4、網路POI中如何試下查找最近的商家功能(提示：坐標鏡像+R樹)。

5、一個文件中有100萬個整數，由空格分開，在程序中判斷用戶輸入的整數是否在此文件中。說出最優的方法

6、兩個不重復的數組集合中，這兩個集合都是海量數據，內存中放不下，怎麼求共同的元素？

7、燒一根不均勻的繩，從頭燒到尾總共需要1個小時。現在有若干條材質相同的繩子，問如何用燒繩的方法來計時一個小時十五分鍾呢？

8、萬億級別的兩個URL文件A和B，如何求出A和B的差集C(提示：Bit映射->hash分組->多文件讀寫效率->磁碟定址以及應用層面對定址的優化)

9、怎麼在海量數據中找出重復次數最多的一個？

10、海量日誌數據，提取出某日訪問網路次數最多的那個IP。

11、在2.5億個整數中找出不重復的整數，注，內存不足以容納這2.5億個整數。

12、搜索引擎會通過日誌文件把用戶每次檢索使用的所有檢索串都記錄下來，每個查詢串的長度為1-255位元組。

13、有一個1G大小的一個文件，裡面每一行是一個詞，詞的大小不超過16位元組，內存限制大小是1M。返回頻數最高的100個詞。

14、有10個文件，每個文件1G，每個文件的每一行存放的都是用戶的query，每個文件的query都可能重復。要求你按照query的頻度排序。

15、給定a、b兩個文件，各存放50億個url，每個url各佔64位元組，內存限制是4G，讓你找出a、b文件共同的url？

16、一個文本文件，大約有一萬行，每行一個詞，要求統計出其中最頻繁出現的前10個詞，請給出思想，給出時間復雜度分析。

17、騰訊面試題：給40億個不重復的unsigned int的整數，沒排過序的，然後再給一個數，如何快速判斷這個數是否在那40億個數當中？

18、100w個數中找出最大的100個數。

Ⅵ 面試演算法題：你的任務就是計算出長度為n的字元串(只包含『A』、『B』和『C』)，有多少個是暗黑字元串。

程序肯定不是判斷一個字元串是純潔的還是黑暗的。從現有的題目描述看，程序和題目沒有關系。

題目是否不全？

Ⅶ 面試演算法題

定義一個函數實現數據類型的轉換

第一個元素是數據標識，第二個元素的數值必須大於等於50才返回，不夠50往後累加，加到最後如果不夠50也直接返回，因為沒有可加的數據了

例子1：

a = [[1,3],[2,51],[3,49],[4,42],[5,42]] #入參

a1 = [[2,54],[4,91],[5,42]] #返回

例子2：

b = [[1,50],[2,5],[3,10],[4,42],[5,42],[6,10]] #入參

b1 = [[1,50],[4,57],[6,52]] #返回

a = [[1, 3], [2, 51], [3, 49], [4, 42], [5, 42]]

li = []

n =0

for i, kin a:

    n += k

    if n >=50:

       li.append([i, n])

        n =0

    elif len(a) == i:

li.append([i, k])

    print(li)

一個球從100米高度自由落下，每次落地後反跳回原高度的一半；再落下，求它在第10次落地時，共經過多少米？第10次反彈多高？

def fun(n):

    if n ==1:

        return 100 /2

    else:

        res = fun(n -1) /2

        return res

print(fun(10))

def func(n):

    if n ==1:

        return 100

    else:

        return (fun(n -1) *2) + func(n -1)

print(func(10))

# for 循環實現

def height_100():

# 定義S用來計算總距離

    s =0

    h =100

    for iin range(10):

# 加上本次落地的距離

        s += h

h = h /2

        # 加上反彈的距離

        s += h

print(f'第10次落地的總距離為：{s-h}')

print(f'第10次反彈的高度：{h}')

height_100()

斐波拉契數列

[1,1,2,3,5,8,13,21,34,55]

分析：

月份      數量

1        2隻

2        2隻

3        4隻

4        6隻

5        10隻

6        16隻

def tu_func(n):

    if n ==1 or n ==2:

            return 2

    else:

            return tu_func(n -1) + tu_func(n -2)

print(tu_func(10))

# for 循環實現

def tu_func1(n):

    s = []

    for iin range(1, n +1):

    if i ==1 or i ==2:

        s.append(2)

    else:

            s.append(s[i -2] + s[i -3])

    return s

print(tu_func1(10))

小明有100元錢 打算買100本書，A類書籍5元一本，B類書籍3元一本，C類書籍1元兩本，

    請用程序算出小明一共有多少種買法?

def func3():

    count =0

    for ain range(21):

            for bin range(34):

                    c =100 - a - b

                    if a *5 + b *3 + c *0.5 ==100:

                        count +=1

                        print(a, b, c)

    print(F'一共有{count}種買法')

func3()

Ⅷ 面試官常問十大經典演算法排序（用python實現）

演算法是一種與語言無關的東西，更確切地說就算解決問題的思路，就是一個通用的思想的問題。代碼本身不重要，演算法思想才是重中之重

我們在面試的時候總會被問到一下演算法，雖然演算法是一些基礎知識，但是難起來也會讓人非常頭疼。

排序演算法應該算是一些簡單且基礎的演算法，但是我們可以從簡單的演算法排序鍛煉我們的演算法思維。這里我就介紹經典十大演算法用python是怎麼實現的。

十大經典演算法可以分為兩大類：

比較排序： 通過對數組中的元素進行比較來實現排序。

非比較排序： 不通過比較來決定元素間的相對次序。

演算法復雜度

冒泡排序比較簡單，幾乎所有語言演算法都會涉及的冒泡演算法。

基本原理是兩兩比較待排序數據的大小 ，當兩個數據的次序不滿足順序條件時即進行交換，反之，則保持不變。

每次選擇一個最小（大）的，直到所有元素都被輸出。

將第一個元素逐個插入到前面的有序數中，直到插完所有元素為止。

從大范圍到小范圍進行比較-交換，是插入排序的一種，它是針對直接插入排序演算法的改進。先對數據進行預處理，使其基本有序，然後再用直接插入的排序演算法排序。

該演算法是採用 分治法 對集合進行排序。

把長度為n的輸入序列分成兩個長度為n/2的子序列，對這兩個子序列分別採用歸並排序，最終合並成序列。

選取一個基準值，小數在左大數在在右。

利用堆這種數據結構所設計的一種排序演算法。

堆是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。利用最大堆和最小堆的特性。

採用字典計數-還原的方法，找出待排序的數組中最大和最小的元素，統計數組中每個值為i的元素出現的次數，對所有的計數累加，將每個元素放在新數組依次排序。

設置一個定量的數組當作空桶；遍歷輸入數據，並且把數據一個一個放到對應的桶里去；對每個不是空的桶進行排序；從不是空的桶里把排好序的數據拼接起來。

元素分布在桶中：

然後，元素在每個桶中排序：

取得數組中的最大數，並取得位數；從最低位開始取每個位組成新的數組；然後進行計數排序。

上面就是我整理的十大排序演算法，希望能幫助大家在演算法方面知識的提升。看懂之後可以去試著自己到電腦上運行一遍。最後說一下每個排序是沒有調用數據的，大家記得實操的時候要調用。

參考地址：https://www.runoob.com/w3cnote/ten-sorting-algorithm.html