数据结构备忘一

1. 字符串逆序, void invert(char *str)

void invert(char *str){    if (NULL == str || '\0' == *str || '\0' == *(str + 1))        return;    char *p = str;    char *q = str;    while(*q != '\0')        ++q;    q--;    while(q > p)    {        *q = *q ^ *p;        *p = *q ^ *p;        *q = *q ^ *p;        q--;        p++;    }}

2. 单链表逆序

    1）非递归

LinkList* ReverseList(LinkList* head){    LinkList *next;    LinkList *prev = NULL;    while(head != NULL)    {        next = head->next;        head->next = prev;        prev = head;        head = next;      }      return prev;}

    2) 递归

LinkList* RecurReverseList(LinkList* head){    LinkList* newHead;        if(head == NULL || head->next == NULL)        return head;    newHead = RecurReserveList(head->next);    head->next->next = head;    head->next = NULL;     return newHead;}

3. 排序算法

    1）插入排序：将待排序的记录，按其关键字值的大小插入到已经排好的有序序列中，直到插入完成。空间复杂度O(1)，时间复杂度O(n^2).

void insertSort(int arr[], int length){    for(int i = 1, i < length, i++) {        int value = arr[i];        int j = i;        while(j > 0 && arr[j - 1] > value]) {            arr[j] = arr[j - 1];            --j;        }        arr[j] = value;    }}

    2) 冒泡排序：一种简单的交换类排序方法，通过相邻数据元素的交换，逐步将待排序序列变成有序序列。空间复杂度O(1)，时间复杂度O(n^2).

void bubbleSort(int arr[], int length){    for(int i = length - 1; i > 0; --i) {        for(int j = 0; j < i; j++) {            if(arr[j] > arr[j + 1]) {                int temp = arr[j];                arr[j] = arr[j + 1];                arr[j + 1] = temp;            }        }    }}

    3) 希尔排序：基于直接插入排序的思想，将待排序序列分成若干子序列，子序列由相隔一定增量的元素组成，对子序列进行直接插入排序，然后依次缩小子序列增量再进行排序，待整个序列基本有序时，最后再对整个序列进行一次直接插入排序。

        在希尔排序中，各子序列排序过程是相对独立的，但具体实现时，可以不用先对一个子序列进行完全排序，再对另一个子序列进行排序。我们可以从第一个子序列的第二个元素开始，顺序扫描待排序序列，先对各子序列的第二个元素，分别在各子序列中进行直接插入排序，然后对随后出现的各子序列的第三个元素，分别在各子序列中进行直接插入排序，直到处理完所有子序列的最后一个元素。

void shellSort(int arr[], int length){    int i, delta;    for (delta = length / 2; delta > 0; delta /= 2) {        for (i = delta; i < length; i++) {            if (arr[i] < arr[i - delta]) {                int temp = arr[i];                int j = i - delta;                while (j >= 0 && arr[j] > temp) {                    arr[j + delta] = arr[j];                    j -= delta;                }                arr[j + delta] = temp;            }        }    }}

    4) 快速排序：从待排序序列中选一个记录作为基准数，然后将小于基准数的记录移到前面，而将大于基准数的记录移到后面，这样将待排序序列分成两个子序列，最后将基准数插到分界线的位置。对分割后的两个子序列按上述思想进行分割，直到所有子序列只有一个数，此时待排序序列就成为了有序序列。

       假设待排序序列为arr[left], arr[left+1], ..., arr[right], 快速排序具体过程如下：

       首先，定义两个指针low和high，low = left, high = right, 再将基准数arr[left]移至变量x，使arr[low]成为空单元。

       然后，重复进行下面两个扫描过程，直到low和high相遇。

       - high从右向左扫描，直到arr[high] < x, 将arr[high]移至空单元arr[low], 此时arr[high]成为空单元。

       - low从左向右扫描，直到arr[low] > x, 将arr[low]移至空单元arr[high], 此时arr[low]成为空单元。

       当low和high相遇时，arr[low]成为空单元，且arr[low]左边的所有元素均不大于基准数，而arr[low]右边的所有元素均不小于基准数。最后将基准数移至arr[low]中，就完成一次划分过程。

void quickSort(int arr[], int left, int right){    if (left < right) {        int low = left, high = right;        int x = arr[left];        while (low < high) {            while (low < high && arr[high] >= x) {                high--;            }            if (low < high) {                arr[low] = arr[high];                low++;            }            while (low < high && arr[low] < x) {                low++;            }            if (low < high) {                arr[high] = arr[low];                high--;            }        }        arr[low] = x;        quickSort(arr, left, low - 1);        quickSort(arr, low + 1, right);    }}