常用算法总结

反转数组/字符串

void reverseArray( int * a, int len )
{
    for( int i = 0; i < len/2; i++ )
    {
        int tmp = a[i];
        a[i] = a[len-1-i];
        a[len-1-i] = tmp;
    }
}

反转单向链表

方法一：双指针

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head){

    if( (head == NULL) || (head->next == NULL) )
    {
        return head;
    }

    struct ListNode *prev, *cur, *next;

    prev = NULL;

    cur = head;

    while( cur )
    {
        next = cur->next; //保存下一个结点
        cur->next = prev;
        
        prev = cur; //移动指针直到cur指向null，prve指向最后一个
        cur = next;
    }

    
    return prev;

}

方法二：递归

struct ListNode* reverseList(struct ListNode* head){

    if(head == NULL || head->next == NULL )
    {
        return head;
    }

    struct ListNode* ret = reverseList(head->next);

    head->next->next = head;
    head->next = NULL;

    return ret;

}

快速排序算法

void swap( int* arr, int i, int j )
{
    int tmp;
    tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

void QuickSort( int* arr, int l, int r )
{
    int base;
    base = l;
    int i = l;
    int j = r;
    
    if( i >= j) //递归出口
        return;

    while( i < j)
    {
        while( i < j && arr[j] >= arr[base] ) j--; //找到比arr[base]小的
        while( i < j && arr[i] <= arr[base] ) i++; //找到比arr[base]大的
        
        if( i < j )
        {
            swap(arr, i, j);
        }
    }
    
    swap(arr, base, i); //交换base和中间元素
    QuickSort(arr, l, i-1);
    QuickSort(arr, i+1, r);
}

归并排序算法

void merge_sort(int a[], int s[], int left,int right){
	if(left<right){
		int mid = (left + right) / 2;//从中间截开
		merge_sort(a, s, left, mid);//排序左边 [left, mid ]
		merge_sort(a, s, mid + 1, right);//排序右边[mid+1, right]
		merge(a, s,left, right, mid);//合并左右
	}
}
void merge(int a[],int s[], int left,int right,int mid) {
	
	int i = left, j = mid + 1;//两个变量分别指向左边和右边两组数的第一个数
	int sor = left;
	while (i <= mid && j <= right) {
		if (a[i] < a[j]) {//归并的过程
			s[sor++] = a[i++];
		}
		else {
			s[sor++] = a[j++];
		}
	}
	while (i <= mid) s[sor++] = a[i++];//当一组数已经全部排进去之后，再将另外一组数的全部数字都排进去
	while (j <= right)  s[sor++] = a[j++];
	sor = left;
	while (sor <= right) {//把排好序的新数组全部放回原数组里
		a[sor] = s[sor];
		sor++;
	}
}

二叉树的前中后序遍历

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 * };
 */


void PreOrder( struct TreeNode * root )//前序遍历
{
    if( root == NULL )
    return;

        XXX;               //1. 对根节点做操作
    PreOrder(root->left);  //2. 左子树
    PreOrder(root->right); //3. 右子树
    

}


void InOrder( struct TreeNode * root )//前序遍历
{
    if( root == NULL )
    return;

    InOrder(root->left);    //1. 左子树
               XXX;         //2. 对根节点做操作
    InOrder(root->right);   //3. 右子树
    
}


void PostOrder( struct TreeNode * root )//后序遍历
{
    if( root == NULL )
    return;

    PostOrder(root->left);  //1.左子树
    PostOrder(root->right); //2.右子树
               XXX;         //3.对根节点做操作

}