嵌入式常用算法

 

1、冒泡排序

1、两两之间对比，要是顺序排，一轮过后最大的就是最后一个

2、下一轮参加排序的数比上一轮少一个

#include<iostream>
using namespace std;
void paixu(int *a, int len)
{
	for (int i = 0; i < len-1; i++) {
	  
		for (int j = 0; j < len - i-1; j++)
		{
			if (a[j] > a[j + 1])
			{
				int temp = a[j+1];
				a[j + 1] = a[j];
				a[j] = temp;
				
			}
		}
	}
}
int main()
{
	int a[6]= {1,4,5,0,2,3};
	int len = 6;
	paixu(a, len);
	for (int i = 0; i < len; i++)
	{
		cout << a[i] << endl;
	}
	system("pause");
	return 0;

}

2、快速排序

#include<iostream>
using namespace std;
void quick_sort(int *arr, int l,int r)
{
	//如果待排序的区间长度是1，则已经有序，直接返回
	if (l >= r) return;
	
	//取最左边的数作为中轴
	int key = arr[l];

	//初始化左右指针
	int i = l, j = r;

	//第一轮快排
	while (i < j )
	{
		while (i < j && arr[j] >=key)//由往左找第一个小于key的元素
			j--;
		
		//将找到的小于key元素存放在左边
		arr[i] = arr[j];

		while (i < j && arr[i] <= key)//由左往右找第一个大于等于key的元素
			i++;

		//将找到的大于等于key元素存放在右边
		arr[j] = arr[i];

		// 将枢轴元素放到最终的位置
			arr[i] = key;
	}
	// 递归处理左右两个子区间
		quick_sort(arr, l, i - 1);
	quick_sort(arr, i + 1, r);
}
int main()
{
	int a[6]= {1,4,5,0,2,3};
	int len = 6;
	quick_sort(a, 0,5);
	for (int i = 0; i < len; i++)
	{
		cout << a[i] << endl;
	}
	system("pause");
	return 0;

}

3、二分查找
 

查找符合的左边界

#include<iostream>
using namespace std;


int leftBound(int* arr, int n, int target)
{
	int left = 0;//左指针

	int right = n - 1;//右指针

	while (left <= right)//左指针小于等于右指针
	{
		int mid = left + (right - left) << 1;//求出中间值
		if (arr[mid] < target) left = mid + 1;
		else if (arr[mid] > target) right = mid - 1;
		//这个适合是target = mid ，但是不能结束，我们要找符合条件最左边的数
		else  right = mid - 1;

	}
	if (left >= n || arr[left] != target) return -1;

	return left;
}

int main()
{
	int arr[10] = { 1, 3, 6, 8, 11, 13, 13, 13, 86, 100 };
	int ans = leftBound(arr,10, 13);
	cout << ans;  // 7 
	return 0;
}

查找符合的有边界

#include <stdio.h>

// 在有序数组 arr 中查找目标数 target 的右边界
int binarySearch(int *arr, int n, int target) {
    int left = 0, right = n - 1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] < target) 
            left = mid + 1;  // 目标数在右半部分，更新左边界
        
        else if (arr[mid] >target)  
            right = mid - 1; // 目标数在左半部分，更新右边界
        else
              left = mid + 1;   //目标是中间但是继续查找右边的
     
        }

     if(right < 0 || arr[right] != target) return -1;
    return right; // 返回右边界
}
int main() {
    int arr[] = { 1, 2, 2, 2, 3, 4, 5, 5, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int target = 2;
    int right = binarySearch(arr, n, target);
    printf("Target %d right bound: %d\n", target, right);
    return 0;
}