Linux与数据结构 2019-3-31下午

1.算法

1.1 计数排序

• 1.应用场景：用于元素比较多并且最大值元素和最小值元素相差不大的情况下，各元素之间可以相等且可以有多个；
• 2.核心思想：使用一个计数数组来统计所有的元素的个数，之后按照下标的位置来将元素放到之前的数组中去；
• 3.排序之前的数组和排序之后的数组理论上来说不是同一个数组，因为我们对其进行了赋值操作；

void CountSort(int arr[], int len)
{
	if(arr == NULL || len <= 0)return;

	// 查找数组中的最大值和最小值
	int i;
	int n_min = arr[0];
	int n_max = arr[0];
	for(i=0; i<len; i++)
	{
		if(arr[i] < n_min)
			n_min = arr[i];
		if(arr[i] > n_max)
			n_max = arr[i];
	}

	// 申请一个辅助数组来存储各元素的个数
	int count_buffer = NULL;
	count_buffer = (int*)malloc(sizeof(int)*(n_max-n_min+1));
	memset(count_buffer, 0, sizeof(int)*(n_max-n_min+1));

	// 统计个数
	for(i=0; i<len; i++)
	{
		count_buffer[arr[i]-n_min]++;
	}

	// 重新将其放到数组上
	int j = 0;
	for(i=0; i<n_max-n_min; i++)
	{
		while(count_buffer[i])
		{
			arr[j] = n_min + i;
			j++;
			count_buffer[i]--;
		}
	}
}

1.2 二分查找

• 1.这个算法类似于之前删除BST中的某个节点时查找的部分；
• 2.这个算法是基于排好序的数组进行的；

int BinarySearch(int arr[], int len, int num)
{
	if(arr == NULL || len <= 0)return -1;

	int low = 0;
	int high = len-1;
	int middle;
	while(low <= high)
	{
		middle = low + (high-low)/2;

		if(arr[middle] > num)
		{
			high = middle - 1;
		}
		else if(arr[middle] < num)
		{
			low = middle + 1;
		}
		else
		{
			return middle;
		}
	}

	return -1;
}

1.3 快速排序

• 1.挖坑填补法类型的快速排序法：主要思想是找一个标准值，比它小的放到左侧，比它大的放到右侧；
• 2.需要用到迭代的思想；

int Sort(int arr[], int low, int high)
{
	int temp;
	temp = arr[low];
	while(low < high)
	{
		// 从后向前找比标准值小的
		while(high > low)
		{
			if(arr[high] < temp)
			{
				arr[low] = arr[high];
				low++;
				break;
			}
			high--;
		}

		// 从前向后找比标准值大的
		while(low < high)
		{
			if(arr[low] > temp)
			{
				arr[high] = arr[low];
				high--;
				break;
			}
			low++;
		}
	}

	// 将标准值放入坑中
	arr[low] = temp;
	return low;
}

void QuickSort(int arr[], int low, int high)
{
	if(arr == NULL || low >= high)return;

	// 找基准位置
	int n_middle = Sort(arr, low, high);

	// 根据标准值将当前数组分为两个部分，对这两个部分分别进行以上操作
	QuickSort(arr, low, n_middle-1);
	QuickSort(arr, n_middle+1, high);
}