面試題總結-算法部分

• 最大連續子序列和

public void maxSum(int[] nums) {
        int start = 0;
        int end = 0;
        int max = 0;

        int temp = 0;
        int ts = 0;
        for(int i = 0; i < nums.length; i++) {
            temp += nums[i];
            if(temp < 0) {
                ts = i + 1;
                temp = 0;
            } else {
                if(temp > max) {
                    start = ts;
                    end = i;
                    max = temp;
                }
            }
        }

        System.out.println("maxSum = " + max + ", start : " + start + ", end = " + end);
    }
複製代碼

• 單鏈表逆序

• 排序方法

• 快排序算法

//時間複雜度：nlg(2n)
public void sort(int[] a,int low,int high){
         int start = low;
         int end = high;
         int key = a[low];
         
         
         while(end>start){
             //從後往前比較
             while(end>start&&a[end]>=key)  //若是沒有比關鍵值小的，比較下一個，直到有比關鍵值小的交換位置，而後又從前日後比較
                 end--;
             if(a[end]<=key){
                 int temp = a[end];
                 a[end] = a[start];
                 a[start] = temp;
             }
             //從前日後比較
             while(end>start&&a[start]<=key)//若是沒有比關鍵值大的，比較下一個，直到有比關鍵值大的交換位置
                start++;
             if(a[start]>=key){
                 int temp = a[start];
                 a[start] = a[end];
                 a[end] = temp;
             }
         //此時第一次循環比較結束，關鍵值的位置已經肯定了。左邊的值都比關鍵值小，右邊的值都比關鍵值大，可是兩邊的順序還有多是不同的，進行下面的遞歸調用
         }
         //遞歸
         if(start>low) sort(a,low,start-1);//左邊序列。第一個索引位置到關鍵值索引-1
         if(end<high) sort(a,end+1,high);//右邊序列。從關鍵值索引+1到最後一個
     }
複製代碼

• 冒泡排序

/**
     * 冒泡排序   時間複雜度：n^2
     * 比較相鄰的元素。若是第一個比第二個大，就交換他們兩個。  
     * 對每一對相鄰元素做一樣的工做，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。  
     * 針對全部的元素重複以上的步驟，除了最後一個。
     * 持續每次對愈來愈少的元素重複上面的步驟，直到沒有任何一對數字須要比較。 
     * @param numbers 須要排序的整型數組
     */
    public static void bubbleSort(int[] numbers)
    {
        int temp = 0;
        int size = numbers.length;
        for(int i = 0 ; i < size-1; i ++) {
            for(int j = 0 ;j < size-1-i ; j++) {
                //交換兩數位置
                if(numbers[j] > numbers[j+1]) {
                    temp = numbers[j];
                    numbers[j] = numbers[j+1];
                    numbers[j+1] = temp;
                }
            }
        }
    }
複製代碼

• 選擇排序

/**
     * 選擇排序算法  時間複雜度：n^2
     * 在未排序序列中找到最小元素，存放到排序序列的起始位置  
     * 再從剩餘未排序元素中繼續尋找最小元素，而後放到排序序列末尾。 
     * 以此類推，直到全部元素均排序完畢。 
     * @param numbers
     */
    public static void selectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i; // 用來記錄最小值的索引位置，默認值爲i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j; // 遍歷 i+1~length 的值，找到其中最小值的位置
                }
            }
            // 交換當前索引 i 和最小值索引 minIndex 兩處的值
            if (i != minIndex) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
            // 執行完一次循環，當前索引 i 處的值爲最小值，直到循環結束便可完成排序
        }
    }
複製代碼

• 插入排序

/**  
     * 插入排序 時間複雜度：n^2
     * 
     * 從第一個元素開始，該元素能夠認爲已經被排序
     * 取出下一個元素，在已經排序的元素序列中從後向前掃描 
     * 若是該元素（已排序）大於新元素，將該元素移到下一位置  
     * 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置  
     * 將新元素插入到該位置中  
     * 重複步驟2  
     * @param numbers  待排序數組
     */  
    public static void insertSort(int[] numbers) {
        int size = numbers.length;
        int temp = 0 ;
        int j =  0;
        for(int i = 0 ; i < size ; i++) {
            temp = numbers[i];
            //假如temp比前面的值小，則將前面的值後移
            for(j = i ; j > 0 && temp < numbers[j-1] ; j --) {
                numbers[j] = numbers[j-1];
            }
            numbers[j] = temp;
        }
    }
複製代碼

• 將兩個有序鏈表合併成一個鏈表

public class MyList {
    /**
     * 遞歸方式合併兩個單鏈表
     *
     * @param head1 有序鏈表1
     * @param head2 有序鏈表2
     * @return 合併後的鏈表
     */
    public static Node mergeTwoList(Node head1, Node head2) {
        //遞歸結束條件
        if (head1 == null && head2 == null) {
            return null;
        }
        if (head1 == null) {
            return head2;
        }
        if (head2 == null) {
            return head1;
        }
        //合併後的鏈表
        Node head = null;
        if (head1.data > head2.data) {
            //把head較小的結點給頭結點
            head = head2;
            //繼續遞歸head2
            head.next = mergeTwoList(head1, head2.next);
        } else {
            head = head1;
            head.next = mergeTwoList(head1.next, head2);
        }
        return head;
    }
複製代碼

• 二分法查找

public int search(int[] arr, int key) {
       int start = 0;
       int end = arr.length - 1;
       while (start <= end) {
           int middle = (start + end) / 2;
           if (key < arr[middle]) {
               end = middle - 1;
           } else if (key > arr[middle]) {
               start = middle + 1;
           } else {
               return middle;
           }
       }
       return -1;
   }
複製代碼

• 二叉樹的深度遍歷和廣度遍歷

class ListNode{
      ListNode left;
      ListNode right;
      int val;
      public ListNode(int value){
            this.val=value;
      }
}
複製代碼

//廣度遍歷
public void levelOrderTraversal(LsitNode node){
      if(node==null){
            System.out.print("empty tree"); 
            return;
      }
      ArrayDeque<ListNode> deque = new ArrayDeque<ListNode>();
      deque.add(node);
      while(!deque.isEmpty()){
            ListNode rnode = deque.remove();
            System.out.print(rnode.val+" ");
            if(rnode.left!=null){
                  deque.add(rnode.left);
            }
            if(rnode.right!=null){
                  deque.add(rnode.right);
            }
      }
}
複製代碼

//深度遍歷
public void depthTraversal(ListNode node){
       if(node==null){
             System.out.print("empty tree");
             return;
       }
       Stack<ListNode> stack = new Stack<ListNode>();
       stack.push(node);
       while(!stack.isEmpty()){
             ListNode rnode = stack.pop();
             System.out.print(rnode.val);
             if(rnode.right!=null){
                   stack.push(rnode.right);
             }
             if(rnode.left!=null){
                   stack.push(rnode.left);
             }
       }
}
複製代碼

• java中集合刪除元素

//利用for循環刪除
for (int i = 0; i < aList.size(); i++) {
    if ("abc".equals(aList.get(i))) {
        // 索引回溯
        aList.remove(i--);
    }
}
複製代碼

//利用迭代器的remove()方法刪除
ListIterator<String> listIterator = aList.listIterator();
while(listIterator.hasNext()){
	String  str = listIterator.next();
	if ("abc".equals(str)) {
	    //迭代器的remove() 方法刪除
	    listIterator.remove(); 
	}
}
複製代碼

• Android 遍歷ViewGroup找出某種類型的全部子View

// 遍歷viewGroup
public void traverseViewGroup(View view) {
	if(null == view) {
		return;
	}
	if(view instanceof ViewGroup) {
		ViewGroup viewGroup = (ViewGroup) view;
		LinkedList<ViewGroup> linkedList = new LinkedList<>();
		linkedList.add(viewGroup);
		while(!linkedList.isEmpty()) {
			ViewGroup current = linkedList.removeFirst();
			//dosomething
			for(int i = 0; i < current.getChildCount(); i ++) {
				if(current.getChildAt(i) instanceof ViewGroup) {
					linkedList.addLast((ViewGroup) current.getChildAt(i));
				}else {
					//dosomething
				}
			}
		}
	}else {
		//dosomething
	}
}
複製代碼