数据结构备忘一

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