数据结构-数组排序与查找

一、排序

1、选择排序

思路：
选择排序是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置（或结束为止），直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法.
时间复杂度： O(N^2)
空间复杂度： O(1)
代码如下：

/*================================================================
||函数功能：选择排序
||输入参数：num-数组首地址；len-数组中元素个数
||输出参数：无
||===============================================================*/
void Select_Sort(int *num, int len)
{
    int i = 0, j = 0, tmp = 0;

    for(i = 0; i < len - 1; ++i)
    {
        for(j = i + 1; j < len ; j++)
        {
            if(num[i] > num[j])
            {
                tmp = num[i];
                num[i] = num[j];
                num[j] = tmp;
            }
            j++;
        }
    }
}

2、冒泡排序

思路：
左边大于右边交换一趟排下来最大的在右边。
时间复杂度：
      最坏情况下为O(N^2)
      最好情况下为O(N)
空间复杂度： O(1)
代码如下：

/*================================================================
||函数功能：冒泡排序
||输入参数：num-数组首地址；len-数组中元素个数
||输出参数：无
||===============================================================*/
void Bubble_Sort(int *num, int len)
{
    int i = 0, j = 0;
    int tmp = 0;

    for(j = len-1; j > 0 ; --j)
    {
        for(i = 0; i < j ; ++i)
        {
            if(num[i] > num[i+1])
            {
                tmp = num[i];
                num[i] = num[i+1];
                num[i+1] = tmp;
            }
        }
    }
}

3、插入排序

步骤：
1.从第一个元素开始，该元素可以认为已经被排序
2.取下一个元素tem，从已排序的元素序列从后往前扫描
3.如果该元素大于tem，则将该元素移到下一位
4.重复步骤3，直到找到已排序元素中小于等于tem的元素
5.tem插入到该元素的后面，如果已排序所有元素都大于tem，则将tem插入到下标为0的位置
6.重复步骤2~5
时间复杂度：
      最坏情况下为O(N*N)，此时待排序列为逆序，或者说接近逆序
      最好情况下为O(N)，此时待排序列为升序，或者说接近升序。
空间复杂度： O(1)

/*================================================================
||函数功能：插入排序
||输入参数：num-数组首地址；len-数组中元素个数
||输出参数：无
||===============================================================*/
void Inser_Sort(int *num, int len)
{
    int i = 0, j = 0;
    int tmp = 0;

    for(i = 1; i < len ; i++)
    {
        tmp = num[i];
        j = i;
        while(j > 0 && num[j-1] > tmp)
        {
            num[j] = num[j-1];
            --j;
        }
        num[j] = tmp;
    }
}

4、快排

思路：
1、选出一个key，一般是最左边或是最右边的。
2、定义一个begin和一个end，begin从左向右走，end从右向左走。（需要注意的是：若选择最左边的数据作为key，则需要end先走；若选择最右边的数据作为key，则需要bengin先走）。
3、在走的过程中，若end遇到小于key的数，则停下，begin开始走，直到begin遇到一个大于key的数时，将begin和right的内容交换，end再次开始走，如此进行下去，直到begin和end最终相遇，此时将相遇点的内容与key交换即可。（选取最左边的值作为key）
4.此时key的左边都是小于key的数，key的右边都是大于key的数
5.将key的左序列和右序列再次进行这种单趟排序，如此反复操作下去，直到左右序列只有一个数据，或是左右序列不存在时，便停止操作，此时此部分已有序

时间复杂度： O(N^2)

空间复杂度： O(1)
代码如下：

/*================================================================
||函数功能：快排
||输入参数：num-数组首地址；low-数组起始的索引； high-数组结束的索引
||函数输出：无
||===============================================================*/
void Quick_Sort(int *num, int low, int high)
{
    if(low > high)
    {
        return;
    }
    
    int i = low, j = high;
    int key = num[i];

    while(i < j )
    {
        while(i < j && num[j]>key)
            j--;
        if(i < j)
        {
            num[i] = num[j];
            ++i;
        }
        while(i < j && num[i] < key)
            i++;
        if( i < j )
        {
            num[j] = num[i];
            j--;
        }
    }
    num[i] = key;
    quick(num,low,i-1);
    quick(num,i+1,high);
}

二、查找

1、顺序查找（无序序列）

顺序查找比较简单，从数组下标 0 到 数组长度-1 一一遍历过去，找到就输出下标，不然就一直遍历，直到数组遍历结束。

/*================================================================
||函数功能：顺序查找
||输入参数：num-数组首地址；len-数组中元素个数;aim-查找的目标元素
||输出参数：目标元素在数组中的索引；-1--未查找到
||===============================================================*/
int Linear_Search(int *arr, int len, int aim)
{
	int index= 0；
	for(i = 0; i < len; i++)
	{
		if(arr[index] == aim)
		{
			return index;
		}
	}
	return -1;	//未查找到
}

2、二分查找（有序序列）

对于已按关键字排序的序列，经过一次比较，可将序列分割成两部分，然后只在有可能包含待查元素的一部分中继续查找，并根据试探结果继续分割，逐步缩小查找范围，直至找到或找不到为止。

/*================================================================
||函数功能：二分查找
||输入参数：arr-数组首地址；left-起始索引;right-结束索引；aim-查找的目标元素
||输出参数：目标元素在数组中的索引；-1--未查找到
||===============================================================*/
int binary_search(int *arr, int left, int right, int aim)
{
    if(left > right)
    {
        return -1;
    }

    int mid = (left + right) / 2;
    int midVal = arr[mid];

    if(midVal > aim)
    {
        return binary_search(arr, left, mid, aim);
    }
    else if(midVal < aim)
    {
        return binary_search(arr, mid, right, aim);
    }
    else
    {
        return mid;
    }
}