几种常用的数据结构算法

1.冒泡排序：时间复杂度为O(n * n)

NSArray *array ;
int i ,j;
for(i = 0, i < array.count -1, i++)
{
    for( j = i , j < array.count -1,j++){
     if(array[i] > array[j]){
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
}
}
}

2.二分查找（折半查找），时间复杂度为o(log n )

int search(int array[], int low, int high, int target)
{

    
    if (low > high) return -1;//第一次，low为0，high为数组的个数。这是用递归实现的。
    
    int mid = (low + high)/2;
    if (array[mid]> target)
        return    search(array, low, mid -1, target);
    if (array[mid]< target)
        return    search(array, mid+1, high, target);
    
    //if (midValue == target)
        return mid;
}

3.单链表反转

使用3个指针遍历单链表，逐个链接点进行反转。

ActList* ReverseList2(ActList* head)
{
	//ActList* temp=new ActList;
 if(NULL==head|| NULL==head->next) return head;    //少于两个节点没有反转的必要。
    ActList* p;
	ActList* q;
	ActList* r;
    p = head;  
    q = head->next;
    head->next = NULL; //旧的头指针是新的尾指针，next需要指向NULL
    while(q){
        r = q->next; //先保留下一个step要处理的指针
        q->next = p; //然后p q交替工作进行反向
        p = q; 
        q = r; 
    }
	head=p; // 最后q必然指向NULL，所以返回了p作为新的头指针
    return head;    
}

4.判断一个链表是否为循环链表

判断一个单向链表是否是循环链表比较简单,只要将一个指针p指向表的第一个节点，而另外一个指针q指向
p的下一个节点，然后让q向后滑动，直到q为0或q等于p(此时表是循环链表)为止。

5.判断一个单链表是否存在环

设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。(当然，fast先行头到尾部为NULL，则为无环链表)程序如下：

bool IsExitsLoop(slist *head)
{
    slist *slow = head, *fast = head;

    while ( fast && fast->next ) 
    {
        slow = slow->next;
        fast = fast->next->next;
        if ( slow == fast ) break;
    }

    return !(fast == NULL || fast->next == NULL);
}