大白话排序和查找

排序

默认采用降序排列

1.冒泡排序

每次把最小的元素像泡泡一样，放到数组末尾。

基本原理：外层循环次数有字符串长度-1决定。内层循环，后一个如果比自己小，就交换位置，第一轮就把最小的放到了最后一个元素位置上。那么下一次循环只需要把第二小的放到倒数第二个位置上，所以内层循环次数随外层循环变量一样变化。

优化原理：在内层设置一个检测是否发生数据交换的标致变量，如果某一次循环没有元素交换发生，那么说明剩余数据已经有序。则直接跳出循环。

void bubble_sort(T arr[], int len)
{
    int i, j;  T temp;
    for (i = 0; i < len - 1; i++)
        for (j = 0; j < len - 1 - i; j++)
        if (arr[j] > arr[j + 1])
        {
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
}
--------------------- 
作者：关耳_12X 
来源：CSDN 
原文：https://blog.csdn.net/sunshine_12x/article/details/80987227 
版权声明：本文为博主原创文章，转载请附上博文链接！

end

2.选择排序

循环更新最小值的下标，并记录下来。最后将这个最小值和第一个元素交换。下一次从第二个元素开始循环，选出的自然是次小值。

基本原理：外层循环决定了选出的是第i小的值，min记录下最小值的小标，每层循环结束后，将第i个元素和第min个元素交换位置。

public static void sort(int[] a){
    int N=a.length;
    for(int i=0;i<N;i++){
        int min=i;
        for(int j=i+1;j<N;j++){
            if(a[j]<a[min]){  
                min=j;
            }
        }
        int temp=a[i];
        a[i]=a[min];
        a[min]=temp;
    }
}
--------------------- 
作者：cuit_cuit_cuit 
来源：CSDN 
原文：https://blog.csdn.net/cuit_cuit_cuit/article/details/80552641 
版权声明：本文为博主原创文章，转载请附上博文链接！

end

3.插入排序

从第二个元素开始循环，现将第二个元素保存在V中，1-2中循环，如果第一个元素比第二个元素大，就把第一个元素赋值给第二个元素，退出第二层循环后，在把v赋值给最后移动的那个元素。

原理：从第1个元素开始，只要比外层循环的值大的数都往后移一位，并记下break的J，将值插入到A[j]

5 4 3 2 1
for1: i= 1;j=i=1;v = a[1]
for2:a[j-1] > v ; a[j] = a[j-1];//5 5 3 2 1  
      j-- =0//break;
     a[j] = v;//4 5 3 2 1 //j =1

for1: i= 2;j=i=2;v = a[2]
for2:a[j-1] > v ; a[j] = a[j-1];//4 5 5 2 1 
       j--;//j=1
     a[j-1] > v ; a[j] = a[j-1];//4 4 5 2 1 
       j--;//j=0
     a[j] = v;//3 4 5 2 1 

 

void Insertion_Sort(int a[],int n)
{
    int i,j;
    for(i=1;i<n;i++)
    {
        int temp=a[i];
        for(j=i;j>0&&a[j-1]>temp;--j)
            a[j]=a[j-1];
        a[j]=temp;
    }
}
--------------------- 
作者：L_Aster 
来源：CSDN 
原文：https://blog.csdn.net/gl486546/article/details/53052933 
版权声明：本文为博主原创文章，转载请附上博文链接！

end

4.希尔排序

略

5.快速排序

原理：分区交换排序，分而治之。选择数组最左边的元素将数组分成两个部分，一部分大于枢轴，一部小于枢轴，再对这个两个数组递归调用算法。

template<class T>
void Print(T* arr, size_t n)
{
	for (int i = 0; i < n; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}
template<class T>
int PartSort(T* arr, int left, int right)
{
	int key = arr[right];
	while (left < right)
	{
		while (left < right && arr[left] <= key)
		{
			++left;
		}
		swap(arr[left], arr[right]);
		while (left < right && arr[right] > key)
		{
			--right;
		}
		if (arr[left] != arr[right])
		{
			swap(arr[left], arr[right]);
		}
	}
	//arr[left] = key;
	return left;
}
 
void QuickSort(int* arr, int left, int right)
{
	assert(arr);
	if (left < right)
	{
		int div = PartSort(arr, left, right);
		QuickSort(arr, left, div - 1);
		QuickSort(arr, div + 1, right);
	}
}

--------------------- 
作者：double_happiness 
来源：CSDN 
原文：https://blog.csdn.net/double_happiness/article/details/72303309 
版权声明：本文为博主原创文章，转载请附上博文链接！

这个写法，实质每次都是左右两边分别和key交换。最后key在中间位置。

6.归并排序

分而治之p

7.树排序
将数据一个一个的添加到树种，使用第一个元素作为根节点，如果之后的元素比第一个小，则放到左子树，否则放到右子树，之后按中序遍历。就会按照升序输出啦。

8.计数排序

前提条件，输入的数据在一个范围内。

根据数据粒度，建立一个数组或者<key,value>.每个key的value决定最后排序此key的个数。

9.桶排序

桶排序跟基数排序相当。桶排序假设待排序的一组数均匀独立的分布在一个范围中，并将这一范围划分成几个子范围（桶）。

然后基于某种映射函数f ，将待排序列的关键字 k 映射到第i个桶中 ，那么该关键字k 就作为 B[i]中的元素 (每个桶B[i]都是一组大小为N/M 的序列 )。

接着将各个桶中的数据有序的合并起来 : 对每个桶B[i] 中的所有元素进行比较排序 (可以使用快排)。然后依次枚举输出 B[0]….B[M] 中的全部内容即是一个有序序列。

10.基数排序

略；

查找

二分查找

https://blog.csdn.net/qq78442761/article/details/73012452

散列

 https://blog.csdn.net/duan19920101/article/details/51579136  拉链法 

负载因子讨论

https://bbs.csdn.net/topics/350237871