经典问题

Eg：判断数组是否重复

    package reviewDemo;

/**
 * 判断数组是否重复
 */
public class Demo3 {
    public static void main(String[] args) {
        int[] age = {1, 2, 3, 4, 5, 6, 5};
        for (int i = 0; i < age.length - 1; i++) {//双层循环，定住一个，
            再考虑下一个！
            for (int j = i + 1; j < age.length; j++) {
                if (age[ i ] == age[ j ]) {
                    System.out.println("有重复的！" + i + " " + j);
                    break;
                }
            }
        }
    }
}

数组去重

package com.zxj.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Test {

    public static void main(String [] args) {
        //数组去重：以下是开发过程中使用较多且较快的2种方法
        String [] arrStr = {"Java", "C++", "Php", "C#", "Python", "C++", "Java"};
        //方法一：
        testA(arrStr);
        System.out.println("----------------------------");
        //方法二：
        testB(arrStr);
    }

    //方法一：通过list去重
    public static void testA(String [] arrStr) {
        List<String> list = new ArrayList<String>();
        for (int i=0; i<arrStr.length; i++) {
            if(!list.contains(arrStr[i])) {
                list.add(arrStr[i]);
            }
        }
        //返回一个包含所有对象的指定类型的数组
        String[] newArrStr =  list.toArray(new String[1]);
        System.out.println(Arrays.toString(newArrStr));
    }
    
    //方法二：通过map去重
    public static void testB(String [] arrStr) {
        Map<String, Object> map = new HashMap<String, Object>();
        for (String str : arrStr) {
            map.put(str, str);
        }
        //返回一个包含所有对象的指定类型的数组
        String[] newArrStr =  map.keySet().toArray(new String[1]);
        System.out.println(Arrays.toString(newArrStr));
    }

}

冒泡排序

class Something {

    private static void main(String[] arg) {
 		boolean bChange = false; 
        int[] array = {1, 3, 7, 9, 10, 21};
        for (int i = 0; i < array.length - 1; i++) {
        	 bChange = false;
            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[ j ] > array[ j + 1 ]) {
                    int emp = array[ j ];
                    array[ j ] = array[ j + 1 ];
                    array[ j + 1 ] = emp;
                    bChange = true;
                }
            }
              if (false == bChange)
             		 break;
        }

    }
}

选择排序

//选择排序

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr={1,3,2,45,65,33,12};
        System.out.println("交换之前：");
        for(int num:arr){
            System.out.print(num+" ");
        }        
        //选择排序的优化
        for(int i = 0; i < arr.length - 1; i++) {// 做第i趟排序
            int k = i;
            for(int j = k + 1; j < arr.length; j++){// 选最小的记录
                if(arr[j] < arr[k]){ 
                    k = j; //记下目前找到的最小值所在的位置
                }
            }
            //在内层循环结束，也就是找到本轮循环的最小的数以后，再进行交换
            if(i != k){  //交换a[i]和a[k]
                int temp = arr[i];
                arr[i] = arr[k];
                arr[k] = temp;
            }    
        }
        System.out.println();
        System.out.println("交换后：");
        for(int num:arr){
            System.out.print(num+" ");
        }
    }

}

二分法

package cn.sunzn.dichotomy;

public class DichotomySearch {
   public static void main(String[] args) {
       int[] arr = new int[] { 12, 23, 34, 45, 56, 67, 77, 89, 90 };
       System.out.println(search(arr, 12));
       System.out.println(search(arr, 45));
       System.out.println(search(arr, 67));
       System.out.println(search(arr, 89));
       System.out.println(search(arr, 99));
   }

   public static 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;
   }
}

快排

public int division(int[] list, int left, int right) {
   // 以最左边的数(left)为基准
   int base = list[left];
   while (left < right) {
       // 从序列右端开始，向左遍历，直到找到小于base的数
       while (left < right && list[right] >= base)
           right--;
       // 找到了比base小的元素，将这个元素放到最左边的位置
       list[left] = list[right];

       // 从序列左端开始，向右遍历，直到找到大于base的数
       while (left < right && list[left] <= base)
           left++;
       // 找到了比base大的元素，将这个元素放到最右边的位置
       list[right] = list[left];
   }

   // 最后将base放到left位置。此时，left位置的左侧数值应该都比left小；
   // 而left位置的右侧数值应该都比left大。
   list[left] = base;
   return left;
}

private void quickSort(int[] list, int left, int right) {

   // 左下标一定小于右下标，否则就越界了
   if (left < right) {
       // 对数组进行分割，取出下次分割的基准标号
       int base = division(list, left, right);

       // 对“基准标号“左侧的一组数值进行递归的切割，以至于将这些数值完整的排序
       quickSort(list, left, base - 1);

       // 对“基准标号“右侧的一组数值进行递归的切割，以至于将这些数值完整的排序
       quickSort(list, base + 1, right);
   }
}复制代码