几种常用的数据结构算法

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);
}