void *malloc(size_t size);
void *free(void *pointer);

int *a_pointer = (int*)malloc(sizeof(int) * 100);
if (a_pointer == NULL)
  return -1; // 在函数内提前退出并返回错误值-1

void *calloc(size_t num_elements, size_t element_size);
void *realloc(void *ptr,size_t new_size);

int *pi;
...
pi = malloc(100); // 如果分配成功，在整型为 4 个字节大小的机器上被当作25个整型元素的数组
pi = malloc(25 * sizeof(int)); // 这种分配方式更好一些因为它是可移植的
...
// 使用内存：为内存分配元素
int *pi2, i;

pi2 = pi;
for(;pi2 != pi + 25;)
  *pi2++ = 0;

// 使用下标
for(i = 0; i < 25; i++)
  pi[i] = 0;

pi = malloc(10 * sizeof(int));
free(pi + 5); // 释放部分内存

typedef struct NODE{
  struct NODE *link; // 指向下一个节点的指针
  int         value; // 存储数据的变量 
} Node;

// 插入到一个有序的单链表。函数的参数是一个指向链表第一个节点的指针以及需要插入的值。

#include <stdlib.h>
#include <stdio.h>
#include "sll_node.h"

#define FALSE 0
#define TRUE  1

int sll_insert(Node *current, int new_value)
{
  Node *previous;
  Node *new;

  // 寻找正确的插入位置，方法是按顺序访问链表，直到到达其值大于或等于新插入值的节点。
  
  while(current->value < new_value)
  {
    previous = current;
    current = current->link;
  }
  // 为新节点分配内存，并把新值存储到新节点中，如果内存分配失败。
  // 函数返回false
  new = (Node*)malloc(sizeof(Node));
  if (new == NULL)
    return FALSE;
  new->value = new_value;

  // 把新节点插入到链表中，并返回true 
  new->link = current;
  previous->link = new; 
  return TRUE;
}

result = sll_insert(root,12); // 假设有一个节点存储15，插入在这个节点前

#include <stdlib.h>
#include <stdio.h>
#include "sll_node.h"

#define FALSE 0
#define TRUE  1

int sll_insert(Node **rootp, int new_value)
{
  Node *current;
  Node *previous;
  Node *new;
  
  // 得到指向第一个节点的指针
  current = *rootp;
  previous = NULL;
  
  // 寻找正确的插入位置，方法是按序访问链表，直到到达一个其值大于或等于新值的节点
  while(current != NULL && current->value < new_value)
  {
    previous = current;
    current = current->link;
  }

  // 为新节点分配内存，并把新值存储到新节点中，如果内存分配失败，
  // 函数返回false
  new = (Node*)malloc(sizeof(Node));
  if (new == NULL)
    return FALSE;
  new->link = current;
  if (previous == NULL)
    *rootp = new;
  else
    previous->link = new;
  return TRUE;
}

int sll_insert_ease(Node **head, int new_value)
{
  Node *new_node;
  
  // current_ptr 现在指向的是一个指针 (head 或 link 字段)
  // 初始时指向调用者的 head 指针变量
  Node **current_ptr = head;
  
  // 1. 寻找插入位置：循环直到指针指向NULL(末尾)或指向的值 >= new_value
  while (*current_ptr != NULL && (*current_ptr)->value < new_value)
    current_ptr = &(*current_ptr)->link;
  
  // 2. 分配新节点
  new_node = (Node*)malloc(sizeof(Node));
  if (new_node == NULL)
    return FALSE;
  new_node->value = new_value;
  
  // 3. 插入：新节点指向 current_ptr 当前指向的那个节点
  new_node->link = *current_ptr;
  
  // 4. 核心：更新current_ptr 指向的指针变量，让它指向新节点
  *current_ptr = new_node; // *current_ptr 其实就是上一个节点的link
  return TRUE;
}
// 书上的优化
int sll_insert(register Node **linkp, int new_value)
{
  register Node *current;
  register Node *new;
  
  while ((current = *linkp) != NULL && current->value < new_value)
    linkp = &current->link;

  new = (Node*)malloc(sizeof(Node));
  if (new == NULL)
    return FALSE;
  new->value = new_value;
  
  new->link = current;
  *linkp = new;
  return TRUE;
}

typedef struct NODE {
  struct NODE   *fwd;
  struct NODE   *bwd;
  int           value;
};

/*
  把一个值插入到一个双链表，rootp是一个指向根节点的指针，
  value是欲插入的新值
  返回值：如果欲插值原先已存在于链表中，函数返回0；
  如果内存不足导致无法插入，函数返回-1；如果插入成功，函数返回1。
*/
#include <stdlib.h>
#include <stdio.h>
#include "doubly_linked_list_node.h"

int dll_insert(Node *rootp, int value)
{
  Node *this;
  Node *next;
  Node *newnode;
  
  /*
    查看value是否已经存在于链表中，如果是就返回
    否则，为新值创建一个新节点("newnode"将指向它)
    "this"将指向应该在新节点之前的那个节点。
    "next"将指向应该在新节点之前的那个节点。
  */
  for (this = rootp; (next = this->fwd) != NULL; this = next){
    if (next->value == value)
      return 0;
    if (next->value > value)
      break;
  }

  newnode = (Node*)malloc(sizeof(Node));
  if (newnode == NULL)
    return -1;
  newnode->value = value;

  // 把新值添加到链表中
  if (next != NULL)
  {
    // 情况1或2:并非位于链表尾部
    if (this != rootp) // 情况1：并非位于链表起始位置
    {
      newnode->fwd = next;
      this->fwd = newnode;
      newnode->bwd = this;
      next->bwd = newnode;
    }
    else // 情况2：位于链表的起始位置
    {
      newnode->fwd = next;
      rootp->fwd = newnode;
      newnode->bwd = NULL;
      next->bwd = newnode;
    }   
  }
  else
  {
    // 情况3或4:位于链表的尾部
    if (this != rootp) // 情况3：并非位于链表的起始位置
    {
      newnode->fwd = NULL;
      this->fwd = newnode;
      newnode->bwd = this;
      rootp->bwd = newnode;
    }
    else // 情况4：位于链表的起始位置
    {
      newnode->fwd = NULL;
      rootp->fwd = newnode;
      newnode->bwd = NULL;
      rootp->bwd = newnode;
    }
  }
  return 1;
}

if (x == 3)
{
  i = 1;
  some statement;
  j = 2;
}
else
{
  i = 1;
  some statement different;
  j = 2; 
}

i = 1; 
if (x == 3)
  some statement;
else 
  some statement different;
j = 2;

/*
  双链表部分代码使用语句提炼
*/
// 把新节点添加到链表中
if(next != NULL)
{
  newnode->fwd = next;
  if (this != rootp)
  {
    this->fwd = newnode;
    newnode->bwd = this;
  }
  else
  {
    rootp->fwd = newnode;
    newnode->bwd = NULL;
  }
  next->bwd = newnode;
}
else
{
  newnode->fwd = NULL;
  if (this != rootp)
  {
    this->fwd = newnode;
    newnode->bwd = this;
  }
  else
  {
    rootp->fwd = newnode;
    newnode->bwd = NULL;
  }
  rootp->bwd = newnode;
}

if (pointer != NULL)
  field = pointer;
else
  field = NULL;

field = pointer;

/*
  最终提炼的双链表插入函数
*/
#include <stdio.h>
#include <stdlib.h>
#include "doubly_linked_list_node.h"

int dll_insert(register Node *rootp, int value)
{
  register Node *this;
  register Node *next;
  register Node *newnode;
  
  /*
    查看value是否已经存在于链表中，如果是就返回。
    否则，为新值创建一个新节点("newnode"将指向它)。
    "this"将指向应该在新节点之前的那个节点，
    "next"将指向应该在新节点之后的那个节点。
  */
  for (this = rootp; (next = this->fwd) != NULL; this = next)
  {
    if (next->value == value)
      return 0;
    if (next->value > value)
      break;
  }
  newnode = (Node*)malloc(sizeof(Node));
  if (newnode == NULL)
    return -1;
  newnode->value = value;

  // 把新节点添加到链表中
  newnode->fwd = next;
  this->fwd = newnode;

  //if (this != rootp)
  //  newnode->bwd = this;
  //else
  //  newnode->bwd = NULL;
  newnode->bwd = (this != rootp) ? this : NULL;
  
  //if (next != NULL)
  //  next->bwd = newnode;
  //else
  //  rootp->bwd = newnode;
  (next != NULL ? next : rootp)->bwd = newnode;
  return 1;
}