2. 程式人生 > >【演算法】資料結構面試演算法題目

【演算法】資料結構面試演算法題目

阿新 • • 發佈：2019-01-13

1 陣列去重

python實現

#呼叫內建函式去重
def func(str):
	len1=len(str)
	len2=len(list(set(str)))
	print("去重後的結果是：",list(set(str)),"\t去重個數是：",(len1-len2))
#for 迴圈去重
def func1(str):
	nums=[]
	for n in str:
		if n not in nums:
			nums.append(n)
	print("去重後的結果是：",sorted(nums),"\t去重個數是：",(len(str)-len(nums)))
# while去重
def func2(str):
	len1=len(str)
	for n in str:
		while str.count(n)>1:
			del str[str.index(n)]
	print("去重後的結果是：",sorted(str),"\t去重個數是：",(len1-len(str)))

str=[1,3,2,4,2,4,1,6,4,5]
func2(str)

字典去重

#呼叫內建函式去重
def func(str):
	len1=len(str.values())
	len2=len(list(set(str.values())))
	print("去重後的結果是：",list(set(str.values())),"\t去重個數是：",(len1-len2))
#for 迴圈去重
def func1(str):
	nums=[]
	for n in str.values():
		if n not in nums:
			nums.append(n)
	print("去重後的結果是：",sorted(nums),"\t去重個數是：",(len(str.values())-len(nums)))

str=[1,3,2,4,2,4,1,6,4,5]
dirc={1:1,2:2,3:3,4:3}
func2(dirc)

 python字串追加去重排序

#呼叫內建函式去重
def func(str1,str2):
	print("去重後的結果是：",sorted(set(str1+str2)),"\t去重個數是：",(len(str1+str2)-len(set(str1+str2))))

#for 迴圈去重
def func1(str1,str2):
	nums=[]
	str=str1+str2
	for n in str:
		if n not in nums:
			nums.append(n)
	print("去重後的結果是：",sorted(nums),"\t去重個數是：",(len(str)-len(nums)))
# while去重
def func2(str1,str2):
	str=str1+str2
	for n in str:
		while str.count(n)>1:
			del str[str.index(n)]
	print("去重後的結果是：",sorted(str),"\t去重個數是：",(len(str1+str2)-len(str)))

str1=['很好','不錯','很好','Very','Book','I','Love','I']
str2=['Java','C#','Python','C#']
func2(str1,str2)

Java實現

import java.util.LinkedList;
import java.util.List;


public class func {
	public static void unique(String[] str){
		// array_unique  
	    List<String> list = new LinkedList<String>();  
	    for(int i = 0; i < str.length; i++) { 
	        if(!list.contains(str[i])) {  
	            list.add(String.valueOf(str[i]));  
	        }  
	    }  
	    System.out.print("去重後的結果："+list+"\t 共去重個數："+(str.length-list.size()));
	}
	public static void main(String[] args){
		String[] str={"1","3","2","4","2","4","1","6","4","5"};
		unique(str);
	}

}

 set實現

import java.util.HashSet;
import java.util.Set;

public class func {
	public static void unique(String[] str){
		Set<String> set = new HashSet<String>();
        for (int i=0; i<str.length; i++) {
            set.add(str[i]);
        } 
	    System.out.print("去重後的結果："+set+"\t 共去重個數："+(str.length-set.size()));
	}
	public static void main(String[] args){
		String[] str={"Python","SQL","C#","Java","C","Python","R","Matlab","C++","SQL"};
		unique(str);
	}
}

java字串追加去重實現

/* package whatever; // don't place package name! */

import java.util.*;
import java.util.Set;
import java.util.HashSet;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
	/**
	 * 兩個數組合並去重
	 * 2016年11月5日12:43:34
	 * 白寧超
	 * str1   long[]  陣列1
	 * str2   long[]  陣列2
	*/
	public static void disstr(long[] str1,long[] str2 ){
		if(str1.length<=0||str2.length<=0){
			return;
		}
		long[] str= new long[str1.length+str2.length];  
        System.arraycopy(str1, 0, str, 0, str1.length);  
        System.arraycopy(str2, 0, str, str1.length, str2.length);
		Set<Long> set=new HashSet<Long>();
		for(int i=0;i<str.length;i++){
			set.add(str[i]);
		}
		System.out.print("追加去重後的資料是：\t"+set+"\n\t\t去重個數：\t"+(str.length-set.size()));
	}
	

	public static void main (String[] args) throws java.lang.Exception
	{
		long[] str1={10,20,30,50,10,60,40,20};
		long[] str2={50,60,90,80,70};
		disstr(str1,str2);
	}
}

2  求陣列中逆序對的總數，如輸入陣列1,2,3,4,5，6，7,0  逆序對7

Python實現

# 求陣列中逆序對的總數，如輸入陣列1,2,3,4,5，6，7,0  逆序對7
def index(str3):
	res=0
	if(len(str3)<0):	return 0
	if(len(str3)==0):	return str3[-1]
	else:
		for i in str3:
			if(str3[i]>str3[-1]):
				res+=1
	print(res)

str3=[1,2,3,4,5,6,7,0]
#func2(str1,str2)
index(str3)

Java實現

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
	public static void func2(){
		int res=0;
		int[] str={1,2,3,4,5,6,7,0};
		for(int i=0;i<str.length;i++){
			for(int j=i;j<str.length;j++){
				if(str[i]>str[j]){
					res++;	
				}
			}
		}
		System.out.print(res);
	}
	public static void main (String[] args) throws java.lang.Exception
	{
		func2();
	}
}

 3 無序陣列A，找到第K個最大值，複雜度小於O（NlgN）

Python實現

方法一：時間複雜度set()*sorted（）的複雜度

# 無序陣列A，找到第K個最大值，複雜度小於O（NlgN）
def Maxnum(str,n):
	if n>len(str) or n<0:
		print("輸入不合法")
		return 0
	numArr=sorted(set(str))
	m=-n
	print(numArr[m])


str3=[1,2,3,4,5,6,7,0]
Maxnum(str3,30)

 方法二：時間複雜度O(n)+sorted（）複雜度

def Maxnum1(str,n):
	newstr=[]
	if n>len(str) or n<=0:
		print("輸入不合法")
		return 0
	else:
		for i in str:
			if i not in newstr:
				newstr.append(i)
	print(sorted(newstr)[-n])

str3=[1,2,3,4,5,6,7,0]
Maxnum1(str3,1)

 方法三：時間複雜度O(nlogn)

def bnc_quick(arr,low,high):
	if low < high:
		key=arr[low]
		left=low
		right=high
		while low < high:
			while low < high and arr[high] >= key:
				high -= 1
			arr[low]=arr[high]
			while low < high and arr[low] <= key:
				low += 1
			arr[high]=arr[low]
		arr[low]=key
		bnc_quick(arr,left,low-1)
		bnc_quick(arr,low+1,right)
		
arr=[20,10,30,40,100,60,90,210]
print(arr)
bnc_quick(arr,0,len(arr)-1)
n=3
print(arr[-n])

 方法四：時間複雜度O（n）

from random import randint
def findKthMax(l,k):
	if k>len(l):
		return
	key=randint(0,len(l)-1)
	keyv=l[key]
	sl=[i for i in l[:key]+l[key+1:] if i<keyv]
	bl=[i for i in l[:key]+l[key+1:] if i>=keyv]
	if len(bl)==k-1:
		return keyv
	elif len(bl)>=k:
		return findKthMax(bl,k)
	else:
		return findKthMax(sl,k-len(bl)-1)

 方法五：時間複雜度O(n)

def base_quick(arr,low,high):
	if low < high:
		key=arr[low]
		left=low
		right=high
		while low < high:
			while low < high and arr[high] >= key:
				high -= 1
			arr[low]=arr[high]
			while low < high and arr[low] <= key:
				low += 1
			arr[high]=arr[low]
		arr[low]=key
		return low
		
def findmax(arr,k):
	length = len(arr)
	low = 0
	high = length - 1
	midkey = base_quick(arr, low, high)
	while midkey != k:
		if midkey > k:
			midkey = base_quick(arr, low, midkey - 1)
		elif midkey < k:
			midkey = base_quick(arr, midkey + 1, high)
	return arr[-k:]

Java實現

 方法一：時間複雜度O(NlgN)

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
	public static void quickSort(int[] arr,int low,int hight){
		if(low < hight){
			int key=arr[low];
			int left=low;
			int right=hight;
			while(low < hight){
				while(low < hight&&arr[hight] >= key){
					hight--;
				}
				arr[low]=arr[hight];
				while(low <hight&&arr[low] <= key){
					low++;
				}
				arr[hight]=arr[low];
			}
			arr[low]=key;
			quickSort(arr,left,low-1);
			quickSort(arr,low+1,right);
		}
	}
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		int[] arr={1,3,4,6,7,99,45,26};
		for(int i:arr){
			System.out.print(i+" ");
		}
		System.out.println("\n**************************************");
		quickSort(arr,0,arr.length-1);
 		for(int i:arr){
			System.out.print(i+" ");
		}
		System.out.println("\n**************************************");
		int k=3;
		for(int i=0;i<arr.length;i++){
			if(i==arr.length-k){
				System.out.print("\n第"+k+"個最大數是："+arr[arr.length-k]);
			}
	
		System.out.println("\n***************	}***********************");
		int n=3;
		System.out.print("前"+n+"個最大數是：\n");
		for(int i=arr.length-1;i>=arr.length-n;i--){
			System.out.print(arr[i]+" ");
		}
	}
}

4 排序演算法

Python實現氣泡排序

def buttle(arr):
	length = len(arr)
	for i in range(0,length):
		for j in range(i+1,length):
			if(arr[i]>arr[j]):
				arr[i],arr[j]=arr[j],arr[i]
	print(arr)
			
str3=[1,2,13,4,15,6,7,0]
buttle(str3)

Java實現氣泡排序

	public static void buttle(int[] arr){
		int temp=0;
		for(int i=0;i<arr.length;i++){
			for(int j=i+1;j<arr.length;j++){
				if(arr[i]>arr[j]){
					temp=arr[j];
					arr[j]=arr[i];
					arr[i]=temp;
				}
			}
		}
		for(int n:arr){
			System.out.print(n+" ");
		}
	}

Python實現快排：

def bnc_quick(arr,low,high):
	if low < high:
		key=arr[low]
		left=low
		right=high
		while low < high:
			while low < high and arr[high] >= key:
				high -= 1
			arr[low]=arr[high]
			while low < high and arr[low] <= key:
				low += 1
			arr[high]=arr[low]
		arr[low]=key
		bnc_quick(arr,left,low-1)
		bnc_quick(arr,low+1,right)
		
arr=[20,10,30,40,100,60,90,210]
print(arr)
bnc_quick(arr,0,len(arr)-1)
print(arr)

Java實現快排：

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
	public static void quickSort(int[] arr,int low,int hight){
		if(low < hight){
			int key=arr[low];
			int left=low;
			int right=hight;
			while(low < hight){
				while(low < hight&&arr[hight] >= key){
					hight--;
				}
				arr[low]=arr[hight];
				while(low <hight&&arr[low] <= key){
					low++;
				}
				arr[hight]=arr[low];
			}
			arr[low]=key;
			quickSort(arr,left,low-1);
			quickSort(arr,low+1,right);
		}
	}
	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
		int[] arr={1,3,4,6,7,99,45,26};
		for(int i:arr){
			System.out.print(i+" ");
		}
		System.out.println("\n**************************************");
		quickSort(arr,0,arr.length-1);
 		for(int i:arr){
			System.out.print(i+" ");
		}
	}
}

簡單選擇排序：

def select(arr):
	for i in range(0,len(arr)):
		min=i
		for j in range(i+1,len(arr)):
			if arr[min] > arr[j]:
				min=j
		arr[min],arr[i]=arr[i],arr[min]
	return arr

5 不借助中間變數的兩數字交換：

方法一：

    private static void swapBySelf(int a, int b) {  
        // 在不引入其它變數的情況下交換兩個數，利用兩數之和來做  
        a = a+b;   //a儲存兩數之和  
        b = a-b;    //兩數之和-b，即為a  
        a = a-b;    //兩數之和-b，此時的b已經變成了a，所以相當於sum-a=b  
    }

方法二：

        //還有另一種方法,利用兩數之差，即兩數之間的距離  
        a = b-a;   //a=兩者的差  
        b = b-a;    //b = 原來的b-兩數的距離==原來的a  
        a = a+b;    //最終的a=兩者之差+原來的a==原來的b  
        System.out.println("swapBySelf second function:a="+a+",b="+b);//又換回來了

方法三：

    //已知x^k^k==x，即一個數與任意一個數作兩次異或運算都會變成原來的自己  
    private static void swapByXOR(int a, int b) {  
        // 在不引入其它變數的情況下交換兩個數，利用異或來做  
        a = a^b;   //a儲存兩數異或的中間結果  
        b = a^b;    //a兩次異或b就變成原來的a，並將其賦值給了b  
        a = a^b;    //b兩次異或a就變成原來的b，並且將其賦值給了a  
        System.out.println("swapByXOR first function:a="+a+",b="+b);  
          
    }

相關推薦

【演算法】資料結構面試演算法題目

1 陣列去重 python實現 #呼叫內建函式去重 def func(str): len1=len(str) len2=len(list(set(str))) print("去重後的結果是：",list(set(str)),"\t去重個數是：",(len1-len2)) #for 迴圈

【3】資料結構與演算法---快速入門

第 2 章 快速入門 2.1 入門案例 案例：如果 a+b+c=1000，且 a^2+b^2=c^2(a,b,c 為自然數)，求出所有a、b、c可能的組合? 解決方案： 1.猜三個，條件匹配 2.猜兩個，另一個計算 演算法五特性： 輸入、輸出、有窮性、

【5】資料結構與演算法--- 演算法 進階

第 4 章 演算法 進階 4.1 排序 4.1.1 排序演算法簡介 排序：把無序的佇列變成有序的佇列 排序演算法：排序演算法是一種將一串無規律資料依照特定順序進行排列的一種方法或思路。 排序演算法的穩定性：佇列中有相同的元素，排序前後，這兩個相同元素的順序有沒

【專欄】資料結構和演算法之美-為什麼很多程式語言中的陣列都是從 0 開始的

學習筆記 陣列的特徵 1.線性表 資料排成像一條線一樣的結構，資料之間只是簡單的前後關係。除了陣列是一種線性表結構外，連結串列、佇列和棧也是。與之對應的像二叉樹、堆、圖等就是非線性表。 2.使用連續

【練習】資料結構和演算法複習題

題目：a=10,b=15，將a / b的值互換。 通常我們的做法是（尤其是在學習階段）：定義一個新的變數，藉助它完成交換。程式碼如下： int a,b; a=10; b=15; int t; t=a; a=b; b=t; 這種演算法易於理解，特別適合幫助初學者瞭解計算機程式的特點，是賦值語句的經典應用。在實際

【演算法】資料結構與演算法基礎總覽（中）——刷Leetcode等演算法題時一些很實用的jdk輔助方法錦集

        最近重新學習資料結構與演算法以及刷leetcode演算法題時，發現不少jdk自帶的方法可以提升刷題的效率。這些小技巧不僅僅對刷演算法題帶來便利，對我們平時開發也是很有幫助的。本文以java語言為基礎，記錄了目前已經使用或看到過的一些小技巧，後續在刷題過程

【極客時間】資料結構與演算法總結

【極客時間】資料結構與演算法總結： 02| 資料結構是為演算法服務的，演算法要作用在特定的資料結構之上。 20個最常用的最基礎的資料結構與演算法： 10個數據結構：陣列、連結串列、棧、佇列、散列表、二叉樹、堆、跳錶、圖、Trie樹 10個演算法：遞迴、排序、二分

【軟體設計師】資料結構與演算法

陣列與矩陣 陣列的儲存地址計算 一維陣列a[n]：a[i]=a+i*len 二維陣列a[m][n]：     按行儲存：a[i][j]=a+(i*n+j)*len     按列儲存：a[i][j]=a+(j*m+i)*len*

【java版】資料結構與演算法分析學習之路【一】前言

一.資料結構和演算法概述？【框範圍】 基礎資料結構主要包括表【陣列+連結串列】、棧、佇列【散列表】、樹、圖、堆。高階資料結構包括伸展樹、紅黑樹、確定性跳躍表、AA樹、treap樹、k-d樹、配對堆。

【課程說明】資料結構與演算法課程要求--選課學生必讀

一、計劃安排        根據課程進度安排上機，預計總共上機五次，平均每三週上機一次。 每次上機分三節： a.知識點講解，對上機所要的知識點做個簡要概述。 b.疑難解答，對課程遺留難點進行重點解答，期間大家有什麼問題可以當場提出來。 c.三道左右習題，根據課程進度按難易等

【？】資料結構/演算法中一些常見的數學符號

∑     求和符號，其結構如下 max ∑  代數式  min式i的最低值，max是i的最大值。把i從最小值遞增到最大值，依次代入代數式，每一次代入代數式的值的和。 i=min 例: n

【重點，要考的】資料結構及演算法基礎--雜湊圖（HashMap）

HashMap可以說是java中最常見的幾種集合了。 在瞭解HashMap前我們要先了解Object的兩個方法：Equals和h

【自考】 資料結構知識總結【CH7】

 CH7 排序   1. 基本概念       排序就是將一組物件按照規定的次序重新排列的過程， 排序往往是為檢索服務的。       穩定性：相同鍵值兩個記錄在排序前後相對位置的變化情況。

【自考】 資料結構考前總結【CH4-CH6】

CH4 樹和二叉樹   1. 基本概念       結點的度 ：樹上任一結點所擁有的子樹的數目稱為該樹的度。       葉子：度為0的結點稱為葉子或終端結點。 &nbs

【自考】 資料結構考前總結 【CH1-CH3】

CH1   資料結構概論 1.  邏輯結構：集合（CH6 查詢表），線性結構（CH2 線性表 、CH3 棧、佇列、陣列），樹形結構（CH4 樹和二叉樹），圖結構（CH5 圖） 2.  儲存結構：順序儲存、鏈式儲存（程式碼：初始化、插入、刪除）、索引

【PTA】——資料結構——01-複雜度2 Maximum Subsequence Sum

01-複雜度2 Maximum Subsequence Sum （25 分） Given a sequence of K integers { N​1​​, N​2​​, ..., N​K​​ }. A continuous subsequence is define

【作業】資料結構【線性表】

【題目】： 順序儲存的線性表A，其資料元素為整型，試編寫一演算法，將A拆成B和C兩個表，使A中元素值大於等於0的元素放入B，小於0的放入C中，要求： （1）、表B和表C另外設定儲存空間。 （2）、表B和表C不另外設定空間，而利用A的空間。 【分析】： 對於第一問，其

javascript十大經典排序演算法 js資料結構與演算法

排序演算法是《資料結構與演算法》中最基本的演算法之一 排序演算法中的複雜度與穩定性如下圖所示： 1.氣泡排序  氣泡排序（Bubble Sort）也是一種簡單直觀的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。

【自考】 資料結構考前總結 【CH1-CH3】

CH1   資料結構概論 1.  邏輯結構：集合（CH6 查詢表），線性結構（CH2 線性表 、CH3 棧、佇列、陣列），樹形結構（CH4 樹和二叉樹），圖結構（CH5 圖） 2.  儲存結構：順序儲存、鏈式儲存（程式碼：初始化、插入、刪除）、索引儲存、雜湊儲存。 3.

【自考】資料結構導論-線性表

前言 總覺得這次的自考才是真正準備自考的樣子，你付出了多少一定會有多少的回報，最終的感覺還是迴歸課本，做多少題最終還是要以課本為主啊，不管多細，反正是課本上的內容，還有課後題，非常重要了 在組長的帶領下，我們把書看的已經很熟悉了，但是對於我來說邏輯上的東西好理解，但是程式碼題真的是一