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);
}
}
}
複製程式碼
//利用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
}
}
複製程式碼