数据结构|查找 排序算法

1、查找

方法：哨兵查找法和折半查找法

哨兵查找法

 折半查找法

2、排序

方法：直接插入排序；希尔排序；折半排序；快速排序；冒泡排序

直接插入排序：从第二个开始，往前插着排着

直接插入排序

折半排序

快速排序

 4、代码

using namespace std;


int search_solder(int*arr,int length, int val)//哨兵查找算法
{
	arr[0] = val;
	int i = length;
	for (i; arr[i] != val; i--);  //重点！！改变查找条件
	return i;
}

int search_bin(int* arr, int length, int val)// 折半算法 查找效率虽然高，但是只能用于 有序的、 顺序表，链表怎么找mid？
{
	int low = 0;
	int high = length;
	while (low < high)
	{
		int mid = (low + high) / 2;
		if (arr[mid] == val) //相等
		{
			return mid;
		}
		else if (val < arr[mid])
		{
			high = mid - 1;
		}
		else
		{
			low = mid + 1;
		}
	}
	return -1;
	
}
struct indexnode
{
	int data;
	int index;
};
int search_sec(int* arr, indexnode* index, int val)  //建立查找表
{
	if (val <= index[1].data)
	{
		search_bin(arr, 6, val);
	}
	if (index[1].data < val <= index[2].data)
	{
		int low = 6;
		int high = 11;
		while (low < high)
		{
			int mid = (low + high) / 2;
			if (arr[mid] == val) //相等
			{
				return mid;
			}
			else if (val < arr[mid])
			{
				high = mid - 1;
			}
			else
			{
				low = mid + 1;
			}
		}
		return -1;
	}
	if (index[2].data < val )
	{
		int low = 12;
		int high = 17;
		while (low < high)
		{
			int mid = (low + high) / 2;
			if (arr[mid] == val) //相等
			{
				return mid;
			}
			else if (val < arr[mid])
			{
				high = mid - 1;
			}
			else
			{
				low = mid + 1;
			}
		}
		return -1;
	}
	
}


void insertsort(int* arr,int length)  // 直接插入排序  后面的数忘前面插着排着
{
	int i;
	int j;
	for (i = 2; i < length; i++)
	{
		if (arr[i] < arr[i - 1])
		{
			arr[0] = arr[i];  //建立哨兵
			for (j = i - 1; arr[j] > arr[0]; j--)
			{
				arr[j + 1] = arr[j];  //向后移
			}
			arr[j + 1] = arr[0];
		}
	}
}

void Binsertsort(int* arr, int length)  //折半排序  ，分成两个子列表，子列表再排
{
	int i;
	int j;
	int low;
	int high;
	for (i = 2; i < length; i++)
	{
		low = 1;
		high = i - 1;
		int mid;
		arr[0] = arr[i];
		while (low <= high)
		{
			mid = (low + high) / 2;
			if (arr[mid] > arr[0])
			{
				high = mid - 1;
			}
			else
			{
				low = mid + 1;
			}
		}
		for (j = i - 1; j >= high + 1; j--)
		{
			arr[j + 1] = arr[j];
		}
		arr[high + 1] = arr[0];
	}
}


void selectsort(int* arr,int length) //快速排序
{
	for (int i = 0; i < length-1; i++)
	{
		int min =i;
		int j;
		for (j = i + 1; j < length; j++)
		{
			if (arr[min] > arr[j])  // switch
			{
				min = j;
			}
		}
		if (min != i)
		{
			int temp = arr[min];
			arr[min] = arr[i];
			arr[i] = temp;
		}
		
	}
} 
int partition(int* arr, int low, int high)  // low=1
{
	
	arr[0] = arr[low];
	while (low < high)
	{
		while (low < high && arr[high] > arr[0])
		{
			high--;
		}
		arr[low] = arr[high];
		while (low < high && arr[low] <= arr[0])
		{
			low++;
		}
		arr[high] = arr[low];
	}
	arr[low] = arr[0];
	return low;  //分配好的中心点，也就是刚进来的low 点
}
void Qsort(int* arr, int low, int high) //low永远是1 保留哨兵位置
{
	if (low < high)  // 只有一个元素时候可以停止
	{
		int pivotkey = partition(arr, low, high);  //
		Qsort(arr, low, pivotkey - 1); // 低子列表
		Qsort(arr, pivotkey + 1, high);  //高子列表
	}
	
}