Java数组的高级部分:冒泡排序+选择排序+直接插入排序+快速排序+折半查找

1.冒泡排序

(1)冒泡排序的思想

          两两比较,大的往后放,第一次比较完毕之后,最大值就出现在了最大索引处!然后依次这样比较,就可以得到一个排好序的数组.

(2)冒泡排序的规律

 1)一定是两两比较,大的往后放,第一次比较完毕,最大值在最大索引处

 2)第一次全部都比较,确定数组的最大值

  第一次比较,有0个元素不比

  第二次比较,有1个元素不比

  第三次比较,有2个元素不比

   ......

元素比较的次数:(数组长度-1)次

(3)冒泡排序算法

public static void BubbleSort(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = 0; y < arr.length - 1 - x; y++) {
				if (arr[y] > arr[y + 1]) {
					int temp = arr[y];
					arr[y] = arr[y + 1];
					arr[y + 1] = temp;
				}
			}
		}
	}

2.选择排序

(1)选择排序的思想

          从0索引对应的元素依次和后面索引对应的元素进行比较,小的往前放,第一次比较完毕之后,最小值就出现在最小索引处,然后依次这样比较,就可以得到一个排好序的数组.

(2)选择排序的规律

 1)从0索引开始依次和后面索引对应的元素进行比较,小的数据往前放,最小值在最小索引处.

 2)用0索引对应的值依次和后面索引对应的值比较

用1索引对应的值依次和后面索引对应的值比较

......

arr.length-2索引对应的元素和arr.length-1索引对应的值比较

(3)选择排序算法

// 选择排序的功能
	public static void selectSort(int[] arr) {
		for (int x = 0; x < arr.length - 1; x++) {
			for (int y = x + 1; y < arr.length; y++) {
				if (arr[x] > arr[y]) {
					int temp = arr[x];
					arr[x] = arr[y];
					arr[y] = temp;
				}
			}
		}
	}

3.直接插入排序

(1)直接插入排序的思想

直接插入排序,是一种最简单的排序方法.他的基本操作是将一个记录插入到一个长度为m 的有序表中,使之仍保持有序,从而得到一个新的长度为m+1的有序列表.假设有一组元素{k1,k2...,kn},排序开始就认为k1是一个有序序列,让k2插入上述表长为1的有序序列,使之成为一个表长为2的有序序列,然后让k3插入上述表长为2的有序序列,使之成为一个表长为3的有序序列,以此类推,最后让kn插入表长为n-1的有序序列,得到一个表长为n的有序序列.

(2)举例

•49,38,65,97,76,13,27  原始数据

[49],38,65,97,76,13,27 从1索引开始插入

[38,49], ,65,97,76,13,27

[38,49,65] 97,76,13,27

[38,49,65,97] 76,13,27

[38,49,65,76,97]13,27

[13,27,38,49,65,76,97],27

[13,27,38,49,65,76,97]

(3)直接插入排序算法

private static void insertSort(int[] arr) {
        //外层循环 是循环的轮次
        for (int i = 1; i <= arr.length - 1; i++) {
            //当前元素,如果小于我前面的元素,交换位置
            int j = i;
            while (j > 0 && arr[j] < arr[j - 1]) {
                int t = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = t;
                j--;
            }
        }
    }

4.快速排序

(1)快速排序的基本思想

•分治法：比大小，再分区

1.从数组中取出一个数，作为基准数。

2.分区：将比这个数大或等于的数全放到他的右边，小于他的数 全放到他的左边。

3.再对左右区间重复第二步，直到各区间只有一个数。

(2)实现思路

•挖坑填数

1.将基准数挖出形成第一个坑。

2.由后向前找比他小的数，找到后挖出此数填到前一个坑中。

3.由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。

4.再重复执行2，3两步骤。

例如对 5391672408 进行排序

(3)快速排序算法

public class QuickSort {
    //start 默认是0
    //end 是数组长度-1
    public void quickSort(int[] arr, int start, int end) {
        if (start < end) {
            //获取分区索引
            int index = getIndex(arr, start, end);
            //对左右两个分区 再进行同样的步骤 ，即是递归调用
            quickSort(arr, start, index - 1);//左半部分
            quickSort(arr, index + 1, end);//右半部分
        }
    }

    private int getIndex(int[] arr, int start, int end) {
        int i = start;
        int j = end;
        //定义基准数
        int x = arr[i];
        //循环
        while (i < j) {
            //从右往左比较
            while (i < j && arr[j] >= x) {
                j--;
            }
            //从右往左找到比基准数小的数了后，填坑
            if (i < j) {
                //把这个数填到上一个坑位
                arr[i] = arr[j];
                //让 i++;
                i++;

            }

            //从左往右找
            while (i < j && arr[i] < x) {
                i++;
            }
            // 找比基准数大的数，找到后填坑
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }
        //当上面的循环结束后把基准数填到最后一个坑位，也就一基准数为界，分成了左右两部分
        arr[i] = x; //把基准数填进去
        return i; //返回基准数所在位置的索引
    }

}

5.折半查找

(1)前提:一定是数组中的元素有序的!

(2)折半查找的中心思想:

           直接将数组元素减半,方便开发者使用,计算出中心索引,大了左边找,小了右边找.

(3)核心思想:

   A:定义最小索引和最大索引
   B:计算中间索引
   C:中间索引对应的元素和需要查找的元素比较
       相等,直接返回中间索引
       不相等:
              大了,左边找  max = mid -1 ;
              小了,右边找  min = mid + 1 ;
   D:重新计算中间索引 ,回到B继续查找

(4)折半查找算法

public static int search(int[] arr,int value) {
		//1)定义数组中的最小索引和最大索引
		int min = 0 ;
		int max = arr.length -1 ;
		
		//2) 计算出中间索引
		int mid = (max+min)/2 ;
		
		//3)拿中间索引对应的元素和需要查找的元素进行比较
		//如果相等,返回
		while(arr[mid]!=value) {
			//不相等
			if(arr[mid] >value) {
				 max = mid -1 ;
			}else {
				 min = mid + 1 ;
			}
			
			//如果这value在数组中找不到,找不到返回-1
			if(min>max) {
				return -1 ;
			}
			
			//重新计算出中间索引
			mid = (max+min)/2 ;
		}
		return mid ;
	}