算法学习笔记

原创已于 2023-01-30 15:53:38 修改 · 431 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #学习 #c++

于 2022-07-05 17:05:23 首次发布

本文介绍了三种常见的算法：插入排序、递归查找最大值及堆排序。通过具体的代码实现展示了每种算法的工作原理，并讨论了其应用场景。

插入排序

#include <iostream>

#define SIZE 10

void insert(int list[], int size);

int list_size[SIZE] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

using namespace std;

int main()
{
    insert(list_size, SIZE);
    cout << endl;
    return 0;
}

void insert(int list[], int size) {
   int key = 0;
   int i = 0, j = 0, count = 0;
   for(j = 1; j < size; j++) {
       key = list[j];
       for(i = j - 1; i >= 0 && list[i] > key; i--, count++){
           list[i + 1] = list[i];
       }
       list[i + 1] = key;
   }
   for(int k = 0; k < size; k++) {
       cout << " " << list[k];
   }
   cout << endl << "loop count: " << count;
}

递归查最大值

#include <iostream>

using namespace std;

#define MAX(x,y) \
x > y ? x : y;

int mArray[] = {1,4,2,5,22,545,52,42,545,45,3,45,24,47,2,54,781,2,453,42,45,33,42,20,456,454,352,4,24111,234,5,13,435,165,35,435,435,435,435,1,43,6,13,434,3,4};

int findMax(int *array, int size) {
    cout <<"Array:" << array <<"findMax size:" << size << endl;
    if(size == 2) {
        return MAX(array[0], array[1])
    } else if (size == 1) {
        return array[0];
    } else {
        return MAX(findMax(&array[0], size/2), findMax(&array[size/2 + 1], size - (size/2 + 1)));
    }
}

int main() {
    int max = 0;
    int size = sizeof(mArray)/sizeof(int);
    max = findMax(mArray, size);
    cout << "max: " << max << " size:" << size << endl;
    return 1;
}

堆算法

#include <iostream>

using namespace std;

#define LEFT(x) x*2
#define RIGHT(x) x*2 + 1
#define MAX(x , y) \
    x > y ? x : y

void buildMaxHeap(int* array, int length);

int mHeap[10] = {1,5,9,7,6,8,10,2,4,3};

void swap(int* left, int* right) {
    int temp = 0;
    temp = *left;
    *left = *right;
    *right = temp;
}

//保持堆属性：当最大堆属性被轻微破坏时，恢复最大堆属性
void keepMaxHeap(int* array, int index, int length) {
    int left, right;
    int max = index;
    left = LEFT(index);
    right = RIGHT(index);
    if(left <= length && array[left] > array[index]) {
        max = left;
    }
    if(right <= length && array[right] > array[max]) {
        max = right;
    }
    if(max != index) {
        swap(&array[index], &array[max]);
	keepMaxHeap(array, max, length);
    }
}

//建立最大堆:从叶节点反向构建最大堆，将三个节点最大的item上升到parent
void buildMaxHeap(int* array, int length) {
    int index = 0;
    for(index = length/2; index >= 0; index --) {
        keepMaxHeap(array, index, length);
    }
}
//堆排序:每次选出最大值放在末尾,最终为从小到大
void sortMaxHeap(int* array, int length) {
    int i = 0;
    for(i = length; i>=2; i--) {
        swap(array[0], array[i]);
	length--;
	keepMaxHeap(array, 0, length);
    }
}

快速排序:在数组中选择一个参考值，大于参考值的在右，小于参考值在左，最后交换参考值数据位置到右侧大数的起始点。通过递归将数组分为最小单元排列。

#include <iostream>

using namespace std;

int mHeap[10] = {1,5,9,7,6,8,10,2,4,3};

void swap(int* left, int* right) {
    int temp = 0;
    temp = *left;
    *left = *right;
    *right = temp;
}

int partition(int* array, int begin, int end) {
    int ref, index, cursor;
    ref = array[end]; // 随机选取主元
    index = begin - 1;
    for(cursor = begin; cursor < end; cursor++) {
        if(array[cursor] <= ref) {
            index++;
	    cout << "index: " << index << endl;
	    swap(&array[index], &array[cursor]);
	}
    }
    swap(&array[index + 1], &array[end]);
    return ++index;
}

//mid作为操作值，在数组中央，左大右小
void quickSort(int* array, int begin, int end) {
    int mid;
    if (begin < end) {
        mid = partition(array, begin, end);
	cout << "mid: " << mid << endl;
        quickSort(array, begin, mid - 1);
        quickSort(array, mid + 1, end);
    }   
}

int main()
{
    int i = 0;
    quickSort(mHeap, 0, 9);//长度为length - 1
    // 打印数据
    cout << "array: ";
    for(i = 0; i < 10; i++) {
        cout << mHeap[i] << " ";
    }
    cout << endl;
    return 0;
}