数据结构复习之开题篇（持续更新）

在复习数据结构之前有必要复习一下C语言的指针

1.指针

int* p;
一个指针类型，名为p，代表的是一个整形所存放的地址编号

1.1一个使用的实例

【注】对变量使用&操作符，意为取它所在的地址

#include <stdio.h>
 
int main()
{
   int var = 20;   /* 实际变量的声明 */
   int* ip;        /* 指针变量的声明 */
 
   ip = &var;  /* 在指针变量中存储 var 的地址 */
 
   printf("Address of var variable: %p
", &var  );
 
   /* 在指针变量中存储的地址 */
   printf("Address stored in ip variable: %p
", ip );
 
   /* 使用指针访问值 */
   printf("Value of *ip variable: %d
", *ip );
 
   return 0;
}

1.2一个容易搞混的东西

int* p = NULL;
意为对指针p赋值为NULL，而不是对*p赋值

1.3指针的算术运算

假设p是一个指向地址为1000的整形指针，是一个32位整数
让我们对该指针执行下列的算术运算：
    p++;

在执行完上述的运算之后，p 将指向位置 1004，因为 p 每增加一次，它都将指向下一个整数位置，即当前位置往后移 4 个字节。这个运算会在不影响内存位置中实际值的情况下，
移动指针到下一个内存位置。如果 p 指向一个地址为 1000 的字符，上面的运算会导致指针指向位置 1001，因为下一个字符位置是在 1001

1.3.1递增一个指针

当一个指针指向一个数组时，当递增该指针时，表示指向数组的下一项
#include <stdio.h>

const int MAX = 3;

int main ()
{
   int  var[] = {10, 100, 200};
   int  i, *ptr;

   /* 指针中的数组地址 */
   ptr = var;
   for ( i = 0; i < MAX; i++)
   {

      printf("存储地址：var[%d] = %x
", i, ptr );
      printf("存储值：var[%d] = %d
", i, *ptr );

      /* 移动到下一个位置 */
      ptr++;
   }
   return 0;
}

/*    输出的结果为    */
存储地址：var[0] = bf882b30
存储值：var[0] = 10
存储地址：of var[1] = bf882b34
存储值： var[1] = 100
存储地址：of var[2] = bf882b38
存储值：var[2] = 200

1.3.2指针的比较

指针可以用关系运算符进行比较，如 ==、< 和 >。如果 p1 和 p2 指向两个相关的变量，比如同一个数组中的不同元素，则可对 p1 和 p2 进行大小比较

下面的程序修改了上面的实例，只要变量指针所指向的地址小于或等于数组的最后一个元素的地址 &var[MAX - 1]，则把变量指针进行递增

#include <stdio.h>

const int MAX = 3;

int main ()
{
   int  var[] = {10, 100, 200};
   int  i, *ptr;

   /* 指针中第一个元素的地址 */
   ptr = var;
   i = 0;
   while ( ptr <= &var[MAX - 1] )
   {

      printf("Address of var[%d] = %x
", i, ptr );
      printf("Value of var[%d] = %d
", i, *ptr );

      /* 指向上一个位置 */
      ptr++;
      i++;
   }
   return 0;
}

 ==========================================================================================

看视频杂乱总结

1.第一章

1.存储结构分为=>(顺序存储结构，链式存储结构)，数据的存储结构是指=>数据的逻辑结构在计算机中的表示。

所以要区分，顺序就是顺序，链式就是链式

2.“堆”是顺序存储=>虽然堆是二叉树方式，但是在编写代码时只能以顺序表示

3.循环队列只能顺序存储（？？？？why，循环队列不是可以用链表表示吗）

2.第二章

1.线性表是n个具有相同特性的数据元素的有限序列，可以为空。有直接前驱和后继。是一个逻辑结构

注意区别：

1. 数组就是相同数据类型的元素按一定顺序排列的集合。

   一句话：就是物理上存储在一组联系的地址上。也称为数据结构中的物理结构。

2. 线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。

   一句话：线性表是数据结构中的逻辑结构。可以存储在数组上，也可以存储在链表上。

3.  线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法。用顺序存储方法存储的线性表简称为顺序表。

   一句话：用数组来存储的线性表就是顺序表。

4. 总结：你被这几个概念混淆，是因为你没搞懂数据结构里的逻辑结构和物理存储结构。

我的总结：

　　线性结构：有直接的前驱后继

　　非线性结构：比如图，树，广义表。这组概念是逻辑上的，是逻辑结构。

　　顺序存储：占用一片连续的存储空间，例如顺序表可以通过计算直接获得第i个单元的地址（数组）

　　链式存储：可以跳跃的占用空间，有随机性

　　例如二叉树在逻辑上是非线性的，但是在计算机上可以顺序存储（数组模拟二叉树），也可以链式存储（二叉链表）。a

算法之单链表的就地逆置:要求空间复杂度为O(1)。

void Reverse_L(LinkList &L)
{
    LinkList p, q;
    p = L->next;
    while(p->next != NULL) {
        p = p->next;
    }
    while(L->next != p)
    {
        q = p->next;
        p->next = L->next;
        l->next = l->next->next;
        p->next->next = q; 
    }
}   

 堆排序之JavaScript实现

function swap(h, a, b) {
    let t = h[a];
    h[a] = h[b];
    h[b] = t;
}

// 调整第lo个节点的堆结构，并向下递归调整
function heapAdjust(h, lo, hi) {
    let temp = h[lo];
    let i;
    for (i = (lo << 1) + 1; i <= hi; i = (i << 1) + 1) {
        if (i < hi && h[i + 1] > h[i]) i++;
        if (h[i] < temp) break;
        h[lo] = h[i];
        lo = i;
    }
    h[lo] = temp;
}

// 堆排序
function heapSort(h) {
    let range = h.length
    // 先将整个堆调整至大根堆
    for (let i = (range - 1) >> 1; i >= 0; i--) {
        heapAdjust(h, i, range - 1)
    }
    // 开始堆排序
    // 大小大
    // 小大小
    for (let i = 1; i < range; i++) {
        // swap(h, 0, range - i);
        // [h[0], h[range - i]] = [h[range - i], h[0]]经测试这种写法没有swap快
        heapAdjust(h, 0, range - i - 1);
    }
}

let array = new Array();

for (let i = 0; i < 10000000; i++) array.push(Math.round(Math.random() * 100 + 1));

// array.sort()经测试数组提供的原生sort函数应该是快速排序没有我写的快
// console.log(array);
heapSort(array);
// console.log(array);

 

堆算法之插入新元素

编写一算法：在含有 n 个元素的小顶堆中增加一个元素且调整为新的小顶堆。提示：堆在物理内存上是用顺序表存取的，A[1]至 A[n]分别存放堆中的 n 个元素，堆在逻辑上又可以看作是一棵完全二叉树。A[n+1]表示新增加的一个元素。要求，新加入这个元素后，使得 n＋1 个元素还是小顶堆。

// 顺序存储结构，起始为1，结束为n
void insertElement(datatype heap[], datatype e, int n) {
    int i, j;
    j = ++n;
    while(i > 1) {
        i = (j >> 1);             //寻找父节点
        if(heap[i] <= e) break;   //如果父节点比e小，说明j就是要插入的位置
        else {
            heap[j] = heap[i];    //否则将父节点下移
            j = i;                //将指向当前节点的指针指向父节点进行下一轮的判断
        }
    }
    heap[j] = e;
}