JAVA-数组和排序算法

JAVA-数组和排序知识点整理

数组相关知识点

数组的索引
假设要查找的数据，在数组中就是不存在的

int index = -1
for(int i:arr){
	if(num == arr[i]){
	index = i;
	break;
		}
	}

index就为这个数在此数组中的下标
for(int i =0; i<arr.length; i++){ i--;}
可以用i–进行指针回调，在输入错误的情况下重新输入

数组最大值，最小值，都是先定义 数组第一个数为最大值或最小值，然后从第二个数开始遍历
数组总和 sum+=arr[i];

数组的优点:
1、按照索引查询元素速度快(内存地址固定，连续的位置)
2、能存储大量数据
3、按照索引遍历数组方便

缺点：
1、根据内容查找元素速度慢
2、数组的大小一经确定不能改变。
3、数组只能存储一种类型的数据
4、增加、删除元素效率慢
5、未封装任何方法，所有操作都需要用户自己定义。

二分查找

        int[] arr= {};
        int step = arr.length, t;
        while ((step = step/2) >=2){
            for (int i = 0; i+step <arr.length ; i++) {
                if (arr[i]>arr[i+step]){
                    t = arr[i];
                    arr[i] = arr[i+step];
                    arr[i+step] = t;
                }
            }
        }

冒泡排序

相邻的两个数比较

  		int[] arr = new int[10];
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

选择排序

每一次循环找到数组中最小的数和前一个个数对比，如果小于前一个数就对调位置

	int length = array.length;

	for (int i = 0; i < length - 1; i++) {
		// 保存最小数的索引
		int minIndex = i;

		for (int j = i + 1; j < length; j++) {
			// 找到最小的数
			if (array[j] < array[minIndex]) {
				minIndex = j;
			}
		}

		// 交换元素位置
		if (i != minIndex) {
			swap(array, minIndex, i);
		}
	}

插入排序

1:从第一个元素开始，该元素可以认为已经被排序；
2:取出下一个元素，在已经排序的元素序列中从后向前扫描；
3:如果该元素（已排序）大于新元素，将该元素移到下一位置；
4:重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5:将新元素插入到该位置后；
6:重复步骤2~5。

        for (int i = 0,t,j ; i < arr.length; i++) {
            t=arr[i];
            for (j = i-1; j>=0 && arr[j]>t ; j--) {   //从左边第一个位置开始
                arr[j+1]=arr[j];
            }
            arr[j+1] = t;
        }

希尔排序

比如把10个数的数组分为5组，两两对比

int length = array.length;

	// temp为临时变量，gap增量默认是长度的一半，每次变为之前的一半，直到最终数组有序
	int temp, gap = length / 2;

	while (gap > 0) {
		for (int i = gap; i < length; i++) {
			// 将当前的数与减去增量之后位置的数进行比较，如果大于当前数，将它后移
			temp = array[i];
			int preIndex = i - gap;

			while (preIndex >= 0 && array[preIndex] > temp) {
				array[preIndex + gap] = array[preIndex];
				preIndex -= gap;
			}

			// 将当前数放到空出来的位置
			array[preIndex + gap] = temp;

		}
		gap /= 2;
	}

快速排序

(来自https://blog.csdn.net/ThinkWon/article/details/101543580)
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

• 从数列中挑出一个元素，称为 “基准”（pivot）；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

桶排序

(来自https://blog.csdn.net/ThinkWon/article/details/101544356)

	int length = array.length;
	
	LinkedList<Integer>[] bucket = (LinkedList<Integer>[]) new LinkedList[length];

	// 待排序数组中的最大值
	int maxValue = Arrays.stream(array).max().getAsInt();
	// 根据每个元素的值，分配到对应范围的桶中
	for (int i = 0; i < array.length; i++) {
		int index = toBucketIndex(array[i], maxValue, length);
		// 没有桶才建立桶(延时)
		if (bucket[index] == null) {
			bucket[index] = new LinkedList<>();
		}
		// 有桶直接使用
		bucket[index].add(array[i]);
	}

	// 对每个非空的桶排序，排序后顺便存入临时的List，则list中已经有序）
	List<Integer> temp = new ArrayList<>();
	for (int i = 0; i < length; i++) {
		if (bucket[i] != null) {
			Collections.sort(bucket[i]);
			temp.addAll(bucket[i]);
		}
	}

	// 将temp中的数据写入原数组
	for (int i = 0; i < length; i++) {
		array[i] = temp.get(i);
	}
}

快速排序

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

• 从数列中挑出一个元素，称为 “基准”（pivot）；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

public static void quickSort(int[] a, int lo, int hi) {
        if (lo < hi) {
            int pivot = partition(a, lo, hi);
            quickSort(a, lo, pivot - 1);
            quickSort(a, pivot + 1, hi);
        }
    }

public static int partition(int[] a, int lo, int hi) {
        int x = a[lo];
        int j = hi + 1;

        for (int i = hi; i > lo; i--) {
            if (a[i] >= x) {
                j--;
                swap(a, i, j);
            }
        }
        swap(a, lo, j - 1);
        return j - 1;
    }
    (转载自https://blog.csdn.net/xlinsist/article/details/49657885?utm_medium=distribute.pc_relevant.none-task-blog-title-4&spm=1001.2101.3001.4242)