#旧代码# 算法练习：排序/字符串查找/链表反转

#include "stdafx.h"
#include <iostream>
#include <string>
#include <cassert>
using namespace std;

void print(int numbers[], int size)
{
    for (int i = 0; i < size; i++)
    {
        cout << numbers[i] << " ";
    }

    cout << endl;
}

void swap(int numbers[], int lhs, int rhs)
{
    if (lhs == rhs) return;

    int temp = numbers[lhs];
    numbers[lhs] = numbers[rhs];
    numbers[rhs] = temp;
}

void quick_sort(int numbers[], int low, int high)
{
    if (low >= high) return;

    const int init_low = low;
    const int init_high = high;

    while(low < high)
    {
        while (low < high && numbers[high] > numbers[init_low]) { high --; }
        while (low < high && numbers[low] <= numbers[init_low]  ) { low ++; }
        swap(numbers, low, high);
    }

    swap(numbers, init_low, high);    
    quick_sort(numbers, init_low, high - 1);
    quick_sort(numbers, high + 1, init_high);

    return;
}

void bubble_sort(int numbers[], int size)
{
    for (int i = 0; i < size; i ++)
    {
        for (int j = i + 1; j < size; j ++)
        {
            if (numbers[j] < numbers[i])
            {
                swap(numbers, i, j);
            }
        }
    }
}

void insert_sort(int numbers[], int size)
{
    for (int i = 1; i < size; i ++)
    {
        int new_value = numbers[i];

        int j = i;
        for (; j > 0 && numbers[j - 1] > new_value; j --)
        {
            numbers[j] = numbers[j - 1];
        }

        numbers[j] = new_value;

    }
}

void merge(int numbers[], int first, int mid, int last)
{
    int *buffer = new int[last - first + 1];
    assert(buffer);

    int lhs_first = first;
    int lhs_last = mid;

    int rhs_first = mid + 1;
    int rhs_last = last;

    int index = 0;

    while ((lhs_first <= lhs_last) && (rhs_first <= rhs_last))
    {
        if (numbers[lhs_first] <= numbers[rhs_first])
        {
            buffer[index] = numbers[lhs_first];
            lhs_first ++;
        }
        else
        {
            buffer[index] = numbers[rhs_first];
            rhs_first ++;
        }

        index ++;
    }

    while (lhs_first <= lhs_last)
    {
        buffer[index] = numbers[lhs_first];
        lhs_first ++;
        index ++;
    }

    while (rhs_first <= rhs_last)
    {
        buffer[index] = numbers[rhs_first];
        rhs_first ++;
        index ++;
    }

    for (int i = 0; i < index; i ++)
    {
        numbers[first] = buffer[i];
        first ++;
    }


    delete [] buffer;
}

void merge_sort(int numbers[], int first, int last)
{
    if (first < last)
    {
        int mid = (last + first)/2;

        merge_sort(numbers, first, mid);
        merge_sort(numbers, mid + 1, last);
        merge(numbers, first, mid, last);
    }
}


const char * normal_find(const char *source, int source_size, const char *target, int target_size)
{
    int last_cmp_pos = source_size - target_size + 1;
    for (int i = 0; i < last_cmp_pos; i++)
    {
        int k = i;
        int j = 0;

        for (; (j < target_size) && (k < source_size); j ++, k ++)
        {
            if (source[k] != target[j])
            {
                break;
            }
        }

        if (j == target_size)
        {
            return &(source[i]);
        }

        if (k == source_size)
        {
            return NULL;
        }
    }

    return NULL;
}

const char * kmp_find(const char *source, int source_size, 
                      const char *target, int target_size,
                      const int *next)
{
    assert(source != NULL);
    assert(source_size > 0);
    assert(target != NULL);
    assert(target_size > 0);
    assert(next != NULL);      


    int i = 0;
    int j = 0;

    for (; (j < target_size) && (i < source_size); )
    {
        if (j == -1 || source[i] == target[j])
        {
            j ++;
            i ++;
        }
        else
        {
            j = next[j];
        }

    }

    if (j == target_size)
    {
        return &(source[i - target_size]);
    }
    else
    {
        return NULL;
    }
}

void get_next(const char * target, const int target_size, int * next)
{
    assert(target != NULL);
    assert(target_size > 0);
    assert(next != NULL);

    int i = 0;
    int j = -1;

    next[0] = -1;

    for (; i < target_size; )
    {
        if (j == -1 || target[i] == target[j])
        {
            i ++;
            j ++;

            if (target[i] != target[j])
            {
                next[i] = j;
            }
            else
            {
                next[i] = next[j];
            }
        }
        else
        {
            j = next[j];
        }
    }
}

void print_sub_str(const char * pos)
{
    if ( pos == NULL) 
    {
        cout << "Not found!!" << endl;
        return ;
    }

    for(;*pos !=‘\0‘; pos ++)
    {
        cout << *pos << " ";
    }

    cout << endl;
}


struct Node
{
    int value;
    Node * next;
};

Node * reverse(Node * node)
{
    Node * nextNode = node->next;

    if (nextNode == NULL) 
    {
        return node;
    }

    Node * headerNode = reverse(nextNode);
    
    nextNode->next = node;
    node->next = NULL;

    return headerNode;
}

void print_list(Node * list)
{
    while (list != NULL)
    {
        cout << list->value << " " ;
        list = list->next;
    }

    cout << endl;
}


class Other : public Base
{
};
int _tmain(int argc, _TCHAR* argv[])
{
    // sort algorithm
    /*
    int numbers[] = {9, 8, 7, 6, 5, 8, 4, 3, 2, 1, 4, 2, 3, 4, 7, 8};
    int size =  sizeof(numbers)/sizeof(int);

    //quick_sort(numbers, 0, size - 1);
    //bubble_sort(numbers, size);
    //insert_sort(numbers, size);
    //merge_sort(numbers, 0, size - 1);

    print(numbers, size);
    */

    // find algorithm
    /*
    const char * source = "aaaaabababcaaa";
    const char * target = "ababc";

    int source_size = strlen(source);
    int target_size = strlen(target);

    const char * const pos = normal_find(source, source_size, target, target_size);
    print_sub_str(pos);

    int * next = new int[target_size];

    if (next != NULL)
    {
        get_next(target, target_size, next);
        kmp_find(source, source_size, target, target_size, next);
        print_sub_str(pos);
    }

    delete []next;
    */

    // list operation
    /*
    Node n1 = {1, NULL};
    Node n2 = {2, &n1};
    Node n3 = {3, &n2};
    Node n4 = {4, &n3};
    Node n5 = {5, &n4};

    Node * list = &n5;

    print_list(list);

    list = reverse(list);

    print_list(list);
    */

	return 0;
}