常见算法练习

1、线性查找

/**
 *  线性查找
 */
public void linearSearch(int value){
    for (int i = 0; i < arraySize; i++) {
        if(value == array[i]){
            System.out.print("Found a value at: "+i);
        }
    }
}

2、二分法查找,需要先对数组进行排序后，再进行二分法查找

public void binarySearchForValue(int searchNum){
    bubbleSort();
    printArray();

    int lowIndex = 0;
    int highIndex = arraySize - 1;
    while(lowIndex <= highIndex){
        int middleIndex = (lowIndex + highIndex) / 2;
        if( searchNum > array[middleIndex]){
            lowIndex = middleIndex+1;
        }
        else if(searchNum < array[middleIndex]){
            highIndex = middleIndex-1;
        }
        else{
            System.out.println("Found a searchNum "+middleIndex);
            lowIndex = middleIndex+1;
        }
    }
}

3、冒泡排序,首先要确定一个目标，然后再两两比较，向设立的目标位置进行移动

public void bubbleSort(){
    for (int i=arraySize-1; i>=0 ;i--){
        for (int j=i; j<arraySize-1; j++){
            if(array[j] > array[j+1]){
                swap(j,j+1);
            }
        }
    }
}

4、冒泡排序2

public void bubbleSort2(){
    int count = 0;
    for (int i = arraySize-1; i > 0; i--) {
        for (int j = 0; j < i; j++) {
            if(array[j] > array[j+1]){
                swap(j,j+1);

            }
            count++;
        }
    }
    System.out.println("执行次数为: "+count);
}

5、选择排序首先假设当前位置i为最小值，i代表当前需要处理的位置，然后进行比较，找到array[minmum] >array[j]的值，并记录下来，再一轮比较后获得最小的值的坐标，再把这个下标的值跟当前处理位置i进行交换。

public void selectSort(){
    for (int i = 0; i < arraySize; i++) {
        int minmum = i;
        for (int j = i; j < arraySize; j++) {
            if(array[minmum] > array[j]){
                minmum = j;
            }
        }
        swap(i,minmum);
    }
}

6、插入排序假设左边的数组是已经全部排序好的数组，因为i=0是已经排序好的，因为只有一个数字，所以序号从i=1开始，记录下当前的用于比较的key，比较前面一个数是不是比key大，如果是则array[j-1] 的值移动到array[j]。到最后，将key填入挖出来的位置也就是j。

/**
 * insertSort
 */
public void insertSort(){
    for (int i = 1; i < arraySize; i++) {
       int j = i;//currentIndex
       int key = array[j];
        while ((j > 0) && (array[j-1] > key)){
            array[j] =  array[j-1];
            j--;
        }
        array[j] = key;
    }
}

7、shell排序（希尔排序）

public class ShellSort {
    public void shell_sort(int[] arr) {
        int arraySize =  arr.length;
        int gap = 1;
        int key;//插入排序中用于比较的key值
        while (gap < arraySize / 3) {
            gap = gap * 3 + 1; // <O(n^(3/2)) by Knuth,1973>: 1, 4, 13, 40, 121, ...
            System.out.println("gap: "+gap);//get the gap
        }
        while(gap > 0) {
            for (int i = gap; i < arraySize; i++) {//因为被切割成了多个分组，需要对每个分组进行插入排序
                /**插入排序开始*/
                key = arr[i];//取得第一个数字
                //i-gap 意思是前一个元素的序号（例如插入排序的j跟j-1 这里的gap=1）
                int j = i - gap;
                while ((j >= 0) && (arr[j] > key)){
                    arr[j + gap] = arr[j];
                    j -= gap;
                }
                arr[j + gap] = key;//因为最后的j-=gap 所以需要变成j+gap否则会越界
                /**插入排序结束*/
            }
            gap /= 3;//减小跨度gap，当(gap / 3 < 1)时因为是int 类型会变为0
        }
    }

    public  void shellSort2(int[] array){
        int gap = 1;
        int keyValue = 0;
        int arraySize = array.length;

        while(gap < arraySize / 3){
            gap = gap * 3 + 1;//get gap
        }

        while(gap > 0){
            for(int i=gap; i<arraySize;i++ ){
                int j = i-gap;
                keyValue = array[i];
                while((j>=0) && (array[j] > keyValue)){
                    array[j+gap] = array[j];
                    j -= gap;
                }
                array[j+gap] = keyValue;
            }
            gap /= 3;
        }

    }



    public static void main(String[] args){
        int[] testArray = {1,3,5,2,2,4,2,3,4,5,6,7};
        ShellSort sort = new ShellSort();
        sort.shellSort2(testArray);

        for (int i = 0; i < testArray.length; i++) {
            System.out.print(testArray[i]+" | ");
        }
    }

}

猜你喜欢