经典算法回顾

一、排序  ref

<1> quicksort及partition相关问题

1. quicksort

code1:[首选]

int partition(vector<int> &arr, int low, int high)
{
    int pivot = arr[low];
    int i = low;
    for (int j = low + 1; j <= high; j++)
    {
        if (arr[j] <= pivot)
        {
            i++;
            swap(arr[i],arr[j]);
        }
    }
    swap(arr[i],arr[low]);
    return i;
}
void quicksort(vector<int>& arr, int low, int high)
{
    if (low < high)
    {
        int r = partition(arr,low,high);
        quicksort(arr,low,r-1);
        quicksort(arr,r+1,high);
    }
}

i总指向当前遍历过的元素当中最后一个<=pivot的元素；j就不断向前探寻，当发现有<=pivot的元素时，就让i前移一位，让i和j所指元素互换。

ref:算法导论，编程珠玑

code2: [不够简洁]

int partition(int s[], int l, int r)
{
    int i = l, j = r;
    int x = s[l];
    while (i < j)
    {
        while (s[j] >= x&&i < j)
            j--;
        if (i < j)
        {
            s[i] = s[j];
            i++;
        }
        while (s[i] <= x&&i < j)
            i++;
        if (i < j)
        {
            s[j] = s[i];
            j--;
        }
    }
    s[i] = x;
    return i;
}
void quicksort(int s[], int l, int r)
{
    if (l < r)
    {
        int pos = partition(s, l , r);
        quicksort(s, l, pos - 1);
        quicksort(s, pos + 1, r);
    }
}

需要注意的：

每一步都要判断i<j是否成立。

用l和r标识出左右区间。每一次调用l和r都不一样。

ref: http://blog.csdn.net/morewindows/article/details/6684558

迭代版本：

C++（迭代版本）

//参考：http://www.dutor.net/index.php/2011/04/recursive-iterative-quick-sort/
struct Range {
    explicit Range(int s = 0, int e = 0) : start(s), end(e) {}
    int start, end;
};
void quicksort(int n, int arr[]) {
    if (n <= 0) return;
    stack<Range> st;
    st.push(Range(0, n - 1));
    while (!st.empty()) {
        Range range = st.top();
        st.pop();
        int pivot = arr[range.end];
        int pos = range.start - 1;
        for (int i = range.start; i < range.end; ++i)
            if (arr[i] < pivot)
                std::swap(arr[i], arr[++pos]);
        std::swap(arr[++pos], arr[range.end]);
        if (pos - 1 > range.start)
            st.push(Range(range.start, pos - 1));
        if (pos + 1 < range.end)
            st.push(Range(pos + 1, range.end));
    }
}

http://zh.wikipedia.org/zh/%E5%BF%AB%E9%80%9F%E6%8E%92%E5%BA%8F

另外，加入了randomization的快排：

 

2. 重新排列数组，使得数组左边为奇数，右边为偶数【时间O(n) 】

void rePartition(vector<int> &arr,int low,int high)
{
    int i = low-1;
    for (int j = low; j <= high; j++)
    {
        if (arr[j] % 2 == 1)
        {
            i++;
            swap(arr[i], arr[j]);
        }
    }
}

和上面quicksort code1里的partition一个模子，仅仅修改下判断条件即可。

3. 重新排列数组，使得数组左边为负数，右边为正数【时间O(n) 】

void rePartition2(vector<int> &arr, int low, int high)
{
    int i = low - 1;
    for (int j = low; j <= high; j++)
    {
        if (arr[j] < 0)
        {
            i++;
            swap(arr[i], arr[j]);
        }
    }
}

和上面一样，依然沿袭一个模子。

4. 升级版：在不改变元素相对顺序的基础上，完成2,3.

 根据ref1和ref2 ,应该是不能在O(n)时间，O(1)空间并保持stable顺序的限制下完成。这是荷兰国旗问题的一个变种。如果能借助O(n)空间的话应该很简单。

想一下如何在O(nlogn)的时间内保证相对顺序完成partition吧。ref2里july有提到。

5. 交错正负数n

ref

6. Kth Largest Element in an Array

快速选择（QuickSelection）：

class Solution {
public:
    int partition(vector<int> &nums, int lo, int hi) {
        int pivot = nums[lo];
        int i = lo;
        for (int j = lo + 1; j <= hi; j++) {
            if (nums[j] <= pivot) {
                i++;
                swap(nums[i], nums[j]);
            }
        }
        swap(nums[lo], nums[i]);
        return i;
    }
    
    int findKthLargest(vector<int> &nums, int k) {
        k = nums.size() - k;
        int hi = nums.size() - 1, lo = 0;
        while (lo < hi) {
            int j = partition(nums, lo, hi);
            if (j < k) {
                lo = j + 1;
            } else if (j > k) {
                hi = j - 1;
            } else {
                break;
            }
        }
        return nums[k];
    }
};

对于n个数的数组，一个数x如果从左往右数是第k个数，那么从右往左数的话是第(n - k + 1)个数。

这里一开始k = n - k 是按照求第k小的数的方式转换的。而且！这里是直接转换成了下标。因为如果是第x个数的话应该是第n - k + 1个数。下标为n - k.

 7. partition array

class Solution {
public:
    int partitionArray(vector<int> &nums, int k) {
        // write your code here
        int j = -1;
        for (int i = 0; i < nums.size(); i++) {
            if (nums[i] < k) {
                j++;
                swap(nums[i], nums[j]);
            }
        }
        return j + 1;
    }
};

 

<2> 堆排序

1. 堆   reference

我们一般讨论的堆都是二叉堆，它是完全二叉树（或近似完全二叉树）。

堆一般都是用数组来表示的，所以 下标为 i 的结点的父结点下标就为(i – 1) / 2，子结点下标分别为 2 * i + 1 和 2 * i + 2 。

非递归版本堆排序: [最小堆]

void minHeapFixDown(vector<int> &nums, int i, int n) {
    int j = 2 * i + 1;  // left child
    int tmp = nums[i];
    while (j < n) {
        if (j + 1 < n && nums[j + 1] < nums[j]) {  //取左右孩子中较小的那个
            j++;
        }
        if (nums[j] >= tmp) {
            break;
        }
        nums[i] = nums[j];
        i = j;
        j = 2 * i + 1;
    }
    nums[i] = tmp;
}

void makeMinHeap(vector<int> &nums) {
    int n = nums.size();
    for (int i = (n - 2) / 2; i >= 0; i--) {
        minHeapFixDown(nums, i, nums.size());
    }
}

void minHeapSort(vector<int> &nums) {
    makeMinHeap(nums);
    for (int i = nums.size() - 1; i >= 1; i--) {
        swap(nums[i], nums[0]);
        minHeapFixDown(nums, 0, i);
    }
}

此外，添加、删除节点见此：（复杂度均为O(logN) ）

void minHeapFixUp(vector<int> &nums, int i) {
    int tmp = nums[i];
    int j = (i - 1) / 2;  // parent
    while (i != 0 && j >= 0) {
        if (nums[j] <= tmp) {
            break;
        }
        nums[i] = nums[j];
        i = j;
        j = (j - 1) / 2;
    }
    nums[i] = tmp;
}

void minHeapInsert(vector<int> &nums, int x) {
    nums.push_back(x);
    minHeapFixUp(nums, nums.size() - 1);
}

int minHeapDelete(vector<int> &nums) {
    int res = nums[0];
    swap(nums[0], nums[nums.size() - 1]);    
    minHeapFixDown(nums, 0, nums.size());
    return res;
}

 注意：这个是最小堆的实现。用最小堆进行堆排序得到的是从大到小排列的递减序列。若想用堆排序得到递增序列，需要用最大堆。

最大堆实现：（只需要在最小堆基础上改两处，见注释）

void maxHeapFixDown(vector<int> & nums, int i, int n) {
    int j = i * 2 + 1;
    int tmp = nums[i];
    while (j < n) {
        if (j + 1 < n && nums[j + 1] > nums[j]) { // 1
            j++;
        }
        if (nums[j] < tmp) {  // 2
            break;
        }
        nums[i] = nums[j];
        i = j;
        j = j * 2 + 1;
    }
    nums[i] = tmp;
}

void makeMaxHeap(vector<int> &nums) {
    int n = nums.size();
    for (int i = (n - 2) / 2; i >= 0; i--) {
        maxHeapFixDown(nums, i, n);
    }
}

void maxHeapSort(vector<int> &nums) {
    makeMaxHeap(nums);
    for (int i = nums.size() - 1; i >= 1; i--) {
        swap(nums[0], nums[i]);
        maxHeapFixDown(nums, 0, i);
    }
}

 另外，建堆（初始化）的复杂度是O(N). 证明见此。

 

递归版本呢？

ref

 

求Top K个元素（nlogK）：    http://songlee24.github.io/2015/03/21/hua-wei-OJ2051/

可以用小顶堆的方式，执行n次堆调整；

也可以用快速选择。当快速选择选出第（n-k）小的元素时，它之后的都是比它大的k个元素，即Top K。

 

<3> 归并排序 Merge

void merge(vector<int>& nums, int lo, int mid, int hi, vector<int>& tmp) {
    int i = lo, j = mid + 1;
    int m = mid, n = hi;
    int k = 0;
    while (i <= m && j <= n) {
        if (nums[i] <= nums[j]) {
            tmp[k++] = nums[i++];
        } else {
            tmp[k++] = nums[j++];
        }
    }
    while (i <= m) {
        tmp[k++] = nums[i++];
    }
    while (j <= n) {
        tmp[k++] = nums[j++];
    }
    for (int i = 0; i < k; i++) {
        nums[lo + i] = tmp[i];
    }
}
void mergesort(vector<int>& nums, int lo, int hi, vector<int>& tmp) {
    if (lo < hi) {
        int mid = lo + (hi - lo) / 2;
        mergesort(nums, lo, mid, tmp);
        mergesort(nums, mid + 1, hi, tmp);
        merge(nums, lo, mid, hi, tmp);
    }
}

对数组进行归并排序是需要O(n)的辅助空间的，即一个tmp数组。

 

3.1 求数组中的逆序对[剑36]

//该代码还有bug
int InversePairs(vector<int> data) {
    if (data.size() < 2) {
        return 0;
    }
    vector<int> tmp(data.size(), 0);
    return countPairs(data, 0, data.size() - 1, tmp);
}

int countPairs(vector<int>& nums, int lo, int hi, vector<int>& tmp) {
    if (lo == hi) {
        tmp[lo] = nums[lo];
        return 0;
    }
    int mid = lo + (hi - lo) / 2;
    int len = mid - lo + 1;
    int left = countPairs(nums, lo, mid, tmp);
    int right = countPairs(nums, mid + 1, hi, tmp);
    int i = mid, j = hi, k = hi;
    int cnt = 0;
    while (i >= lo && j >= mid + 1) {
        if (nums[i] > nums[j]) {
            tmp[k--] = nums[i];

该代码还有bug。还没调好。

 

<4> 直接插入排序

void insertionSort(vector<int> &nums) {
    int j;
    for (int i = 1; i < nums.size(); i++) {
        int tmp = nums[i];
        for (j = i; j > 0 && tmp < nums[j - 1]; j--) {
            nums[j] = nums[j - 1];
        }
        nums[j] = tmp;
    }
}

 需要注意的几点，都发生在内层for循环内：

(1)内层for循环的 j 千万不能在for内部声明！因为最后nums[j] = tmp处是要用到这个j的。非常容易写顺手把j给定义了。

(2) for循环中间处是j > 0, 不是 >=0 !!! 而且是判断的 tmp < nums[j - 1]，不是nums[j]。

(3)for循环最后老是忘掉j--, 哪来的破毛病，编译都过不了。

 总之，这个内层for循环的for( ；；)三部分各有一个坑。

<5> 冒泡排序 bubbleSort

void bubbleSort(vector<int> &nums) {
    for (int i = 0; i < nums.size(); i++) {
        for (int j = 1; j < nums.size() - i; j++) {
            if (nums[j - 1] > nums[j]) {
                swap(nums[j - 1], nums[j]);
            }
        }
    }
}

 冒泡排序每次选一个最大的放到最后一个位置。

第一次选出最大的放到nums[n - 1], 第2次选出次大的放到nums[n - 2]，第3次选出第3大的放到nums[n - 3] ...

内层循环每次都是从j = 1到j < n - i 的。

<6> 选择排序

void insertionSort(vector<int> &nums) {
    int j;
    for (int i = 0; i < nums.size(); i++) {
        int tmp = nums[i];
        for (j = i; j > 0 && nums[j - 1] > tmp; j--) {
            nums[j] = nums[j - 1];
        }
        nums[j] = tmp;
    }
}

 

 

 

三、最长递增子序列 LIS

1. DP   O(N^2) 【非最优】

int LIS(vector<int> &v,vector<int> &dp)
{
    int lis=0;
    for(int i=0;i<dp.size();i++)
    {
        dp[i]=1;
        for(int j=0;j<i;j++)
        {
            if(v[j]<v[i] && dp[j]+1>dp[i])
            {
                dp[i]=dp[j]+1;
                if(dp[i]>lis) lis=dp[i];
            }
        }
    }    
    return lis;
}

dp[i]表示以v[i]作为结尾的最长递增子序列的长度。dp[i]=max{dp[j]+1, 1} where j<i && v[j]<v[i]

ref1

2. DP+二分搜索   O(NlogN) 【最优】

int biSearch(vector<int> &v,int x)
{
    int left=0,right=v.size()-1;
    while(left<=right)
    {
        int mid=left+(right-left)/2;
        if(x<v[mid])
            right=mid-1;
        else if(x>v[mid])
            left=mid+1;
        else return mid;
    }
    return left;
}

int LIS(vector<int> &v)
{
    vector<int> maxV;
    maxV.push_back(v[0]);
    int len=1;
    for(int i=0;i<v.size();i++)
    {
        if(v[i]>maxV[len-1])
        {
            len++;
            maxV.push_back(v[i]);
        }
        else
        {
            int pos=biSearch(maxV,v[i]);
            maxV[pos]=v[i];
        }    
    }
    return len;
}

ref2

以上是求出LIS的长度。关于如何输出具体序列，参考 ref1中的outputLIS。

update refer here    or    here(很简洁)

 

四、手写哈希表

#include <iostream>
#include <vector>
#include <string>
#include <fstream>
using namespace std;

class Record
{
public:
    Record();
    int getHash(int M);
    string getName();
    void setName(string key);
    void input(ifstream &fin);
private:
    string name;
    string id_number;
};
Record::Record()
{
}
void Record::input(ifstream &fin)
{

    fin >> name;
    fin >> id_number;
}
string Record::getName()
{
    return name;
}
void Record::setName(string key)
{
    name = key;
}

int Record::getHash(int M)
{
    string key = getName();
    int index = 0;
    for (int i = 0; i < key.length(); i++)
    {
        index += key[i];
    }
    index = index%M;
    return index;
}

class HashTable
{
public:
    HashTable(int tableSize);
    void insert(Record newRecord);
    Record * find(string key);
    void erase(Record* pos);
    void printTable();
private:
    vector<vector<Record>> table;
};

HashTable::HashTable(int tableSize)
{
    table.resize(tableSize);
}
void HashTable::insert(Record newRecord)
{
    int index = newRecord.getHash(table.size());
    table[index].push_back(newRecord);
}

Record* HashTable::find(string key)//体现hash性能的关键
{
    Record tmpRecord;
    tmpRecord.setName(key);
    int index = tmpRecord.getHash(table.size());
    for (int i = 0; i < table[index].size(); i++)
    {
        if (table[index][i].getName() == key)
            return &table[index][i];
    }
    return NULL;
}

void HashTable::erase(Record* pos)
{
    if (pos == NULL) return;
    int index = pos->getHash(table.size());
    int i = 0;
    while (&table[index][i] != pos && i < table[index].size())
        i++;
    for (int j = i; j < table[index].size() - 1; j++)
        table[index][j] = table[index][j + 1];
    table[index].pop_back();
}

void HashTable::printTable()
{
    cout << endl;
    for (size_t i = 0; i < table.size(); i++)
    {
        for (size_t j = 0; j < table[i].size(); j++)
        {
            cout << table[i][j].getName() << ", ";
        }
        cout << endl;
    }
}

int main()
{
    ifstream fin;
    fin.open("D:\\fin.txt");
    HashTable myHash(6);
    int n;
    fin >> n;
    while (n--)//fin里为name为a-z,id随意的26个数据
    {
        Record tmp;
        tmp.input(fin);
        myHash.insert(tmp);
    }
    myHash.printTable();
    myHash.erase(myHash.find("j"));
    myHash.printTable();
    fin.close();
}

这里对字符串取哈希时是把字符串里每一个字母对应的ASCII值累加起来，再mod tableSize。

而处理collision的方式是直接链式地址法（不过这里用的不是链表，用的是vector）。

ref1            ref2

也可以参考这里，基于编程珠玑里的hash_table实现的。 

 

五、小端、大端

判断机器是否是大端/小端

小端：低地址放低字节（权重低），高地址放高字节（权重高）。

方法1：

bool isLittleEndian() {
    int num = 0x12345678;
    char ch = *(char*)(&num);
    return ch == 0x78;
}

方法2：利用union

联合体union的存放顺序是所有成员都从低地址开始存放，利用该特性可以轻松获得CPU对内存采用Little-endian还是Big-endian模式

bool isBigEndian() {
    union NUM {
        int a;
        char b;
    }num;
    num.a = 0x12345678;
    return (num.b == 0x12);
}

 

小端大端互换

其实就是字节交换而已。就是考察位运算。

#include <iostream>
using namespace std;

void transfer(int& x) {
    char a, b, c, d;
    a = (x & 0xff);
    b = (x & 0xff00) >> 8;
    c = (x & 0xff0000) >> 16;
    d = (x & 0xff000000) >> 24;
    x = (a << 24 | b << 16 | c << 8 | d);
}

int main() {
    int x = 0x12345678;
    cout << hex << x << endl;
    transfer(x);
    cout << hex << x << endl;
}

 

 【注意：很多代码都可以参考soul的手写】