Java—排序、查找与递归

Java—排序与查找

1、冒泡排序

冒泡排序算法的运作：
   (1)比较相邻的元素。如果第一个比第二个大，就交换他们两个。
   (2)对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后 的元素应该会是最大的数。
   (3)针对所有的元素重复以上的步骤，除了最后一个。
   (4)持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
冒泡排序最好的时间复杂度为O(n),最坏时间复杂度为O(n^2),平均时间复杂度为O(n^2)。

package com.hwadee;

public class TestSort {

    public static void main(String[] args) {
        int[] intArray= {1,6,2,9,4,16,3};
        bubble(intArray);
    }
    public static void bubble(int[] intArray) {
        for(int i=0;i<intArray.length-1;i++) {
            for(int j=0;j<intArray.length-i-1;j++) {
                if(intArray[j]>intArray[j+1]) {
                    swap(intArray,j,j+1);
                }
            }
        }
        print(intArray);
    }
    public static void print(int[] intArray) {
        for(int i=0;i<intArray.length;i++) {
            System.out.print(intArray[i]+" ");
        }
    }
    public static void swap(int[] intArray,int i,int j) {
        int temp;
        temp=intArray[i];
        intArray[i]=intArray[j];
        intArray[j]=temp;
    }

}

2、简单选择排序

简单选择排序算法的过程：
   选择第i小的记录并交换到位 在L.r[l,L.length]中选择key最小的记录，与第i个记录交换。
   简单选择排序进行比较操作的时间复杂度为O(n^2),进行移动操作的时间复杂度为O(n)。简单选择排序过程中需要进行的比较次数与初始状态下待排序的记录序列的排列情况无关。

package com.hwadee;

public class TestChooseSort {

    public static void main(String[] args) {
        int[] intArray= {1,6,2,9,4,16,3};
        chooseSort(intArray);
    }
    public static void chooseSort(int[] intArray) {
        for(int i=0;i<intArray.length-1;i++) {
            for(int j=i+1;j<intArray.length;j++) {
                if(intArray[i]>intArray[j]) {
                    swap(intArray,i,j);
                }
            }
        }
        printArray(intArray);
    }
    public static void printArray(int[] intArray) {
        for(int i=0;i<intArray.length;i++) {
            System.out.print(intArray[i]+" ");
        }
    }
    public static void swap(int[] intArray,int i,int j) {
        int temp;
        temp=intArray[i];
        intArray[i]=intArray[j];
        intArray[j]=temp;
    }

}

3、二分查找

二分查找的基本思想:首先将节点按关键字排序，然后将区间中间位置记录的关键字与给定值比较，若相等，则查找成功，若不等，则缩小范围，直至新的区间中间位置记录的关键字等于给定值或者查找区间的大小小于零时(表明查找不成功)为止。
二分查找算法的时间复杂度为O(logn)。

package com.hwadee;

public class TestSearch {

    public static void main(String[] args) {
        int[] intArray= {1,2,3,5,7,9,13,16};
        search(intArray, 16);
    }
    public static int search(int[] intArray,int value) {
        int min=0;
        int max=intArray.length-1;
        int mid=(min+max)/2;      //置区间初值
        while(intArray[mid]!=value) {   //找到待查元素
            if(min>max) {
                return -1;
            }   //顺序表中不存在待查元素
            if(intArray[mid]>value) {   //继续在前半区间进行查找
                max=mid-1;
            }else if(intArray[mid]<value) {    //继续在后半区间进行查找
                min=mid+1;
            }
            mid=(min+max)/2;
        }
        System.out.println("索引值="+mid+",value值="+intArray[mid]);
        return mid;
    }
}

4、递归

构成递归需具备的条件:
    子问题须与原始问题为同样的事，且更为简单;
    不能无限制地调用本身，须有个出口，化简为非递归状况处理。
递归算法一般用于解决三类问题:
    数据的定义是按递归定义的(Fibonacci函数)。
    问题解法按递归算法实现。这类问题虽则本身没有明显的递归结构，但用递归求解比迭代求解更简单，如Hanoi问题。
    数据的结构形式是按递归定义的，如二叉树、广义表等，由于结构本身固有的递归特性，则它们的操作可递归地描述。
递归的缺点:运行效率低，递归次数过多容易造成栈溢出等。

(1)用斐波那契数列展示递归的思想:

package com.hwadee;

import javax.naming.spi.DirStateFactory.Result;

/**
 *斐波那契数列：0、1、1、2、3、5、8、13、21这样一个数列 
 *
 */
public class TestFibonacci {

    public static void main(String[] args) {
        System.out.println(fbnc(7));
    }
    public static int fbnc(int value) {
        if(value>=0) {
            if(value==0) {
                return 0;
            }else if(value==1) {
                return 1;
            }else{
                int result=fbnc(value-1)+fbnc(value-2);
                return result;
            }
        }else {
            System.out.println("输入错误，无结果");
            return -1;
        }
    }

}

(2)用阶乘算法展示递归的思想

package com.hwadee;

public class Dgui {        //阶乘的计算

    public static void main(String[] args) {
        System.out.println(jc(4));
    }
    public static int jc(int i) {
        System.out.println("阶乘经过计算的次数");
        if(i>=0) {
            if(i==0||i==1) {
                return 1;
            }else {
                int result=i*jc(i-1);
                return result;
            }
        }else {
            System.out.println("输入有误，无阶乘");
            return -1;
        }
    }

}