Java三种简单算法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 public static int[] selectionSort(int[] a){

        for (int i = 0; i < a.length; i++) {
            int min=i;

            //选出当前循环内最小数字的索引
            for (int k = 1+i; k < a.length; k++) {

                if (a[k]<a[min]){
                    min=k;
                }

            }

            //当前数字索引不等于最小索引时 两数字交换位置
            if (i!=min){
                int tem;
                tem=a[i];

                a[i]=a[min];
                a[min]=tem;
            }
        }

        return a;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public static int[] bubbleSort(int[] a){
		//循环队列长度的次数，从而选出每一种当前元素后的范围内的最大&小的元素
        for (int k = 0; k < a.length; k++) {
			//将当前元素后范围内的元素依次进行比较选出最大&小的元素并置换为当前元素位的索引
            for (int i = k; i < a.length-1; i++) {
                if (a[k]>a[k+1]){
                    int tem;
                    tem=a[k];
                    a[k]=a[k+1];
                    a[k+1]=tem;
                }
            }
        }
        return a;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//l与r分别表示需要分类的数组的左侧位置&右侧位置（初始时为数组的起点0 &终点索引 a.length）
public static int[] sortInner(int[] a,int l,int r){
		//将左侧索引&右侧索引 赋值给 low&high hole为数组的一个中间元素（可以为一个l-r内元素的随机值对应的数组位置的值）
        int high=r,low=l,hole=a[low];
        //只有左侧索引<右侧索引时 才会进行分类排序
        if (l<r){
        	//循环至high==low
            while (high>low){
            
            	//在右侧开始往左找一个比中间值heole小的元素赋值给左侧low位置的值 同时low的值++
                while (a[high]>hole){
                    high--;
                }
                if (high>low){
                    a[low]=a[high];
                    low++;
                }
				//在左侧找一个比中间值大的值赋值给high 同时high--
                while (a[low]<hole){
                    low++;
                }
                if (high>low) {
                    a[high] = a[low];
                    high--;
                }
            }
            
            //当high==low时将 中间值赋值给low(high)位置
            a[low]=hole;

			//分类后以得到的low中间值的索引为界限 得到左右两边两个队列 递归 
			//即把一个队列划分为无限个中间值左右两边对立的队列 一定次数后 即可完成整体队列的有序排序
            sortInner(a,l,low-1);
            sortInner(a,low+1,r);
        }
        return a;
    }