# 1.算法練習題(第一章概論)


1.算法練習題(第一章概論)


  1. 有一個含n(n>2)個整數的數組a,判斷其中是否存在出現次數超過所有元素一半的元素.

    /**
     * 	有一個含n(n>2)個整數的數組a,判斷其中是否存在出現次數超過所有元素一半的元素.
     * @author ASUS
     *
     */
    public class Test7 {
    	public static void realize(int a[],int n) {
    		System.out.println("-------------------------------------------------------------------------");
    		int b = -1; //存放滿足條件的元素
    		
    		//將每一個元素分別和所有元素相比較,得出重復次數
    		int i = 0 ;	//初始化i
    		while(i < n) {
    			int k = 0;
    			int num = 0;	//記錄某個元素出現的次數
    			while(k < n) {
    				//System.out.println("測試k="+k);
    				if(a[i] == a[k])
    					num++;
    				if((k == n - 1) && (num > (n/2 + n%2))) {
    					b = a[i];
    					break;  //已經有一個元素滿足條件,后面不可能還存在一個元素有大於一半的可能性,跳出循環
    				}
    				k++;
    			}
    			if(b != -1) {
    				break; //跳出循環
    			}
    			i++;
    		}
    		
    		//輸出結果
    		if(b == -1)
    			System.out.println("不存在這個數");
    		else
    			System.out.println("存在,這個數為:"+b);
    		System.out.println("-------------------------------------------------------------------------");
    		
    	}
    	
    	public static void main(String[] args) {
    		int a[] = new int[100];
    		int n = 21;
    		//給目標數組a賦值
    		for(int i = 0 ; i < n; i++) {
    			if((i < 6) || (i > 14))
    				a[i] = 31;
    			else {
    				a[i] = i*2;
    			}
    		}
    		
    		Test7.realize(a, n);
    	}
    }
    

  2. 一個字符串采用String對象存儲,設計一個算法判斷該字符是否是回文[^回文:例如abccba這種形式,第n個和倒數第n個字符相同]

    /**
     * 	一個字符串采用String對象存儲,設計一個算法判斷該字符是否是回文
     * @author ASUS
     *
     */
    public class Test8 {
    	/**
    	 * 	這里使用java中的charAt()方法,
    	 * 	與c++中字符串本質為數組的處理方式相似
    	 */
    	public static void realize(String str) {
    		//第n個字符和第n-1個字符相比較
    		for(int i=0,j=str.length()-1;i <= j ;i++,j--) {
    			if(str.charAt(i) != str.charAt(j)) {
    				System.out.println(str+" : 不是回文");
    				return;
    			}
    		}
    		System.out.println(str+" : 是回文");
    	}
    	
    	public static void main(String[] args) {
    		Test8.realize("abcddcba");
    	}
    }
    

  3. 有一個整數序列,設計一個算法判斷其中是否存在兩個元素的和恰好等於給定的整數k.

    /**
     * 	有一個整數序列,設計一個算法判斷其中是否存在兩個元素的和恰好等於給定的整數k.
     * @author ASUS
     *
     */
    public class Test9 {
    	/**
    	 *  	如果有多個符合的元素,只找其中的一組符合的元素
    	 * @param a 給定序列
    	 * @param n 給定序列的長度
    	 * @param k	給定數值
    	 */
    	public static void realize(int a[],int n,int k) {
    		int flag = -1; //標記
    		int i = 0 ; 
    		int j = 0; 
    		while(i < n) {
    			j = 0;
    			while(j < n) {
    				if(a[i] + a[j] == k) {
    					flag = 1;
    					break; 
    				}
    				j++;
    			}
    			if(flag == 1) {
    				break;
    			}
    			i++;
    		}
    		if(flag == -1) {
    			System.out.println("不存在這樣的兩個數使其等於"+k);
    		}else {
    			System.out.println("存在"+a[i]+"+"+a[j]+"="+k);
    		}
    	}
    	
    	public static void main(String[] args) {
    		int a[] = {1,2,3,4,5,6,7,8,9};
    		Test9.realize(a, 9, 16);
    	}
    }
    

  4. 編寫一個實驗程序,隨機產生10個1~20的整數,設計一個搞笑算法找其中的最大元素和最小元素,並統計元素之間的比較次數。調用該算法執行10次並求元素的平均比較次數.

    /**
     * 	編寫一個實驗程序,隨機產生10個1~20的整數,
     * 設計一個搞笑算法找其中的最大元素和最小元素,
     * 並統計元素之間的比較次數。調用該算法執行10次並求元素的平均比較次數
     * @author dmt
     *
     */
    public class Test1 {
    	//產生隨機數組a
    		public static void randa(int a[],int n) {
    			for(int i = 0 ; i < n ; i++) {
    				a[i] = (int)(Math.random()*20) + 1;
    			}
    		}
    		
    		//求最大最下值,和平均比較次數
    		public static int realize(int a[],int n) {
    			//flag為比較次數,max和min分別為最大最小值
    			int flag = 0,max = a[0],min = a[0];
    			
    			int i = 1;
    			//求最大最小具體的實現循環
    			while(i < n) {
    				flag++;//比較次數增加一次
    				if(a[i] > max) {
    					max = a[i];
    				}else {
    					flag++;//比較次數再增加一次
    					if(min > a[i])
    					min = a[i];
    				}
    				i++;
    			}
    			for(i = 0 ; i < n ; i++) {
    				System.out.print("  "+a[i]+ ",");
    			}
    			System.out.println("最大值:"+max+",最小值:"+min+",比較次數:"+flag);
    			return flag;
    		}
    		
    		//測試
    		public static void main(String[] args) {
    			int a[] = new int[10];
    			int n= 10;
    			int	flag = 0,count = 0,average = 0;
    			//執行10次,並求次出平均比較次數
    			for(int i = 1 ; i <= 10;i++) {
    				System.out.println("");
    				Test1.randa(a,n);//產生隨機數組
    				average = average + Test1.realize(a, n);
    			}
    			System.out.println("平均比較次數:"+average/10);
    		}
    }
    
    

  5. 編寫一個實驗程序,利用priority_queue(優先隊列)求出一個無序整數序列中第k個最小的元素.

    優先隊列:blog

    import java.util.PriorityQueue;
    
    /**
     * 利用priority_queue(優先隊列)求出一個無序整數序列中第k小的元素
     * 關於java中priorityQueue類:
     * https://www.cnblogs.com/CarpenterLee/p/5488070.html
     * @author dmt
     *
     */
    public class Test1_5_2 {
    	//第k小的元素,就是小根堆出隊的k個元素
    	public static  int thk(int a[],int n,int k) {
    		int e = -1;//默認為-1
    		PriorityQueue<Integer> pq = new PriorityQueue<>();
    		//將元素放入優先隊列中。
    		for(int i = 0; i < n ; i++) {
    			pq.add(a[i]);
    		}
    		//一直取出元素,直到取出第k個元素,並記錄
    		for(int i = 0 ; i < k ;i++) {
    			e = pq.remove();//取出並刪除首元素
    		}
    		
    		return e;
    	}
    	
    	public static void main(String[] args) {
    		int a[] = {73,32,69,90,23,57,31,66,92,52};
    		System.out.println("實驗結果:");
    		for(int k = 1; k <= a.length; k++) {
    			System.out.println("第"+k+"小的元素:"+Test1_5_2.thk, a.length, k));
    		}
    	}
    }
    
    
    
    

  6. 編寫一個實驗程序,對於一個含n(n>1)個元素的queue<int>隊列容器qu,出隊從隊頭到隊尾的k(1<=k<=n)個元素,其他隊列元素不變.

    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.LinkedList;
    import java.util.Map;
    import java.util.Queue;
    
    /**
     * 編寫一個實驗程序,對於一個含n(n>1)個元素的`queue<int>`隊列容器qu,
     * 出隊從隊頭到隊尾的k(1<=k<=n)個元素,其他隊列元素不變.
     * @author ASUS
     *
     */
    public class Test3 {
    	public int number = -1;
    	public Queue<Integer> queue= null;
    	
    	public static Test3 realize(Queue<Integer> queue,int k) {
    		Queue<Integer> record = new LinkedList<Integer>();	
    		int number = -1; //默認為-1
    		int flag = 0;
    		//將queue目標隊列中出隊的元素,全部保存在臨時記錄隊列record,當出隊元素為第k個元素時,不進行記錄到臨時隊列中,而是保存在mumber中
    		for(int num:queue) {
    			flag++;
    			if(flag != k) 
    				record.offer(num);
    			else
    				number = num;
    		}
    		Test3 test3 = new Test3();
    		test3.number = number;
    		test3.queue = record;
    		return test3;
    	}
    	
    	public static void main(String[] args) {
    		System.out.println("實驗結果:");
    		Test3 test3 = new Test3();
    		//建立一個棧,並初始化
    		Queue<Integer> queue = new LinkedList<Integer>();
    		queue.offer(23);
    		queue.offer(32);
    		queue.offer(89);
    		queue.offer(12);
    		queue.offer(34);
    		queue.offer(88);
    		//遍歷前的目標隊列:
    		System.out.print("遍歷前的目標隊列:");
    		for(int num : queue) {
    			System.out.print("  "+num +",");
    		}
    		
    		test3 = Test3.realize(queue, 3);
    		
    		System.out.print("\n遍歷后的目標隊列:");
    		//遍歷后的目標隊列:
    		for(int num : test3.queue) {
    			System.out.print("  "+num +",");
    		}
    		//移除的第k個元素值為:
    		System.out.println("\n移除的第k個元素值為:"+ test3.number);
    	}
    }
    
  7. 編寫一個實驗程序,設計一種好的數據結構盡可能高效的實現元素的插入(元素)、刪除(按值或者按下標)、按值查找(元素下標)和按序號查找(元素)(假設所有元素值都不相同).

    /**
     * 編寫一個實驗程序,設計一種好的數據結構盡可能高效的實現
     * 元素的插入、刪除、按值查找和按序號查找(假設所有元素值都不相同).
     * @author ASUS
     *
     */
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    //設計的高效數據結構MyData 假設保存元素為字符串
    class MyData{ 
    	private List<String> list = null;        //用於list集合存放元素
    	private Map<String,Integer> map = null;		//用map存放元素的下標
    	
    	//空構造方法用於實例化list集合和map
    	public MyData() {
    		list = new ArrayList<String>();
    		map = new HashMap<String, Integer>();
    	}
    
    	//插入字符串str
    	public void Insert(String str) {
    		this.getList().add(str);
    		//this.getList().size()-1  獲取元素在list中的下標,然后將其放入map中建立字符串和下標的映射
    		this.getMap().put(str,this.getList().size()-1);
    	}
    	
    	//按值查找字符串str的下標
    	public int searchStr(String str) {
    		return this.getMap().get(str) == null ? -1 : this.getMap().get(str);
    	}
    	
    	//查找下標為i的元素str
    	public String searchNumber(int i) {
    		return this.getList().get(i);
    	}
    		
    	//刪除字符串str根據字符串
    	public boolean remove(String str) {
    		//提取刪除元素的下標 
    		int i = this.searchStr(str); 
    		if(i != -1) { //如果元素存在,不存在返回false;
    			//先刪除list和map中的str這個元素
    			this.getList().remove(str);
    			this.getMap().remove(str);
    			
    			//然后重新給map建立映射
    			for(; i < this.getList().size() ; i++) {
    				this.getMap().put(this.getList().get(i), i);
    			}
    			
    			return true;
    		}else {
    			return false;
    		}
    	}
    	
    	//刪除字符串str根據下標
    	public boolean remove(int i) {
    		if(this.searchNumber(i) != null) { //如果元素存在,不存在返回false;
    			//先刪除list和map中的第i個元素
    			this.getMap().remove(this.getList().get(i));
    			this.getList().remove(i); 
    			//然后重新給map建立映射
    			for(; i < this.getList().size() ; i++) {
    				this.getMap().put(this.getList().get(i), i);
    			}
    			return true;
    		}else {
    			return false;
    		}
    	}
    	//顯示元素
    	public void show() {
    		for(String str : this.getList()) {
    			System.out.print("  "+str+",");
    		}
    	}
    	
    	
    	//geter seter方法
    	public List<String> getList() {
    		return list;
    	}
    
    	public void setList(List<String> list) {
    		this.list = list;
    	}
    
    	public Map<String, Integer> getMap() {
    		return map;
    	}
    
    	public void setMap(Map<String, Integer> map) {
    		this.map = map;
    	}
    
    }
    
    
    //測試
    public class Test4 {
    	public static void main(String[] args) {
    		MyData md = new MyData();
    		
    		//1.插入元素
    		md.Insert("Mary0");
    		md.Insert("Mary1");
    		md.Insert("Mary2");
    		md.Insert("Mary3");
    		md.Insert("Mary4");
    		md.Insert("Mary5");
    		md.Insert("Mary6");
    		// 插入元素后顯示元素
    		System.out.print("插入元素后:");
    		md.show();
    		
    		//2.刪除元素"Mary3"
    		md.remove("Mary3");
    		System.out.print("\n刪除元素后1:");
    		//刪除元素"Mary3",后顯示元素
    		md.show();
    		
    		//3.刪除元素4
    		md.remove(4);
    		System.out.print("\n個刪除元素后2:");
    		md.show();
    		
    		//4.查找下標為3的元素
    		System.out.print("\n查找下標為3的元素:"+md.searchNumber(3));
    		
    		//5.查找元素Mary6的下標
    		System.out.print("\n查找元素\"Mary6\"的下標:"+md.searchStr("Mary6"));
    	}
    }
    
    


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM