线性表：顺序表和链表六种基本操作：

InitList(&L) //构造一个空的线性表L
ListLength(L) //获取线性表L的元素个数
GetNode(L, i) //获取线性表L第i个元素
LocateNode(L, e) //查找线性表值为e的元素的位置
ListInsert(L, i, &e) //在线性表L的第i个位置插入元素e
DeleteNode(L, i) //删除线性表L的第i个元素

一、顺序表

#define OK 1
#define ERROR -1
#define MAX_SIZE 100    //MAX_SIZE大小需根据具体情况而定，这里假设是100
#typedef int Status;
#typedef int ElemType;
typedef struct sqlist{
    ElemType Elem_array[MAX_SIZE];
    int length;
}SqList;

1.1 初始化

Status Init_SqList(SqList *L)
{
    L->Elem_array = (ElemType *)malloc(MAX_SIZE*sizeof(ElemType));
    if(!L->Elem_array)
        return ERROR;
    else
    {
        L->length = 0;
        return OK;
    }
}

1.2 查找

int Locate_SqList(SqList *L, ElemType x) 
{ 
    int i=0; 
    while(i<L->length) 
        if(L_Elem_array[i] != x) 
            i++; 
        else 
            return ++i;                    //要查找的值在线性表L第++i个位置 
     if(i>L->length) 
    { 
        printf(“要删除的数据元素不存在！\n”);
        return ERROR; 
    }
}

1.3 插入

Status Insert_SqList(SqList *L, int i, ElemType e) //在顺序表L中第i个位置插入元素e
{
    int j;
    if(i<0||i>L->length-1)
        return ERROR;
    if(L->length>=MAX_SIZE)
    {
        printf("线性表溢出！\n");
        return ERROR;
    }
    for(j=L->length-1; j>=i-1; --j)
        L->Elem_array[j+1] = L->Elem_array[j]; //i-1位置以后的所以结点后移
    L->Elem_array[i-1] = e; //在i-1位置插入结点e
    L->length++;
    return OK;
}

1.4 删除

ElemType Delete_SqList(SqList *L, int i)
{
    int k;
    ElemType x;
    if(L->length == 0)
    {
        printf("线性表L为空！\n");
        return ERROR;
    }
    else if(i<1||i>L->length)
    {
        printf("要删除的数据元素不存在！\n");
        return ERROR;
    }
    else
    {
        x = L->Elem_array[i-1];                      //保存结点的值
        for(k=i; k<L->length; k++)
            L->Elem_array[k-1] = L->Elem_array[k];  //i位置以后的所有结点前移
        L->length--;
        return x;
    }
}

二、单链表

typedef struct Lnode{
    ElemType data;        //数据域，保存结点的值
    struct Lnode *next;   //指针域
}LNode;                  //结点类型

2.1 头插入法建表

/*头插入法创建单链表，链表的头结点head作为返回值*/
LNode *create_LinkList(void)
{
    int data;
    LNode *head, *p;
    head = (LNode *)malloc(sizeof(LNode));
    head->next = NULL;                        //创建单链表头结点head
    while(1)
    {
        scanf("%d", &data);                  //data值和类型可以根据具体情况得到
        if(data == 32767)                    //32767定义为判断创建链表结束条件
            break;
        p = (LNode *)malloc(sizeof(LNode));
        p->data = data;                      //数据域赋值
        p->next = head->next;
        head->next = p;                      //钩链，新创建的结点总是作为第一个结点
    }
    return head;
}

2.2 尾插入法建表

/*尾插入法创建单链表，链表的头结点head作为返回值*/
LNode *create_LinkList(void)
{
    int data;
    LNode *head, *p, *q;
    head = p = (LNode *)malloc(sizeof(LNode));
    p->next = NULL;                         //创建单链表头结点head
    while(1)
    {
        scanf("%d", &data);                 //data值和类型可以根据具体情况得到
        if(data == 32767)                   //32767定义为判断创建链表结束条件
            break;
        q = (LNode *)malloc(sizeof(LNode));
        q->data = data;                     //数据域赋值
        q->next = p->next;
        p->next = q;
        p = q;                              //钩链，新创建的结点总是作为第一个结点
    }
    return head;
}

2.3 按序号查找

Elem_Type Get_Node(LNode *L, int i)  //在单链表L中查找第i个结点
{
    int j;
    LNode *p;
    p = L->next;
    j = 1;         //使p指向第一个结点
    while(p!=NULL && j<i)   //p为NULL表示i太大；j>i表示i为0；
    {
        p = p->next;
        j++;       //移动指针p，j计数
    }
    if(j!=i)
        return -32768;
    else
        return p->data;
}

2.4 按值查找

LNode *Locate_Node(LNode *L, int key)  //在单链表L中查找值为key的结点
{
    LNode *p = L->next;
    while(p!=NULL && p->data != key)
        p = p->next;
    if(p->data == key)
        return p;
    else
    {
        printf("所要查找的结点不存在！\n");
        return NULL;
    }
}

2.5 插入

/*在以L为头结点的单链表的第i个位置插入值为e的结点*/
void Insert_LNode(LNode *L, int i, ElemType e)
{
    int j = 0;
    LNode *p, *q;
    p = L->next;
    while(p!=NULL && j<i-1)
    {
        p = p->next;
        j++;
    }
    if(j!=i-1)
        printf("i太大或i为0！\n");
    else
    {
        q = (LNode *)malloc(sizeof(LNode));
        q->data = e;
        q->next = p->next;
        p->next = q;
    }
}

2.6 按序号删除

/*删除以L为头结点的单链表中的第i个结点*/
void Delete_LinkList(LNode *L, int i)
{
    int j=1;
    LNode *p = L, *q = L->next;
    while(p->next!=NULL && j<i)
    {
        p = q;
        q = q->next;
        j++;
    }
    if(j!=i)
        printf("i太大或i为0！\n");
    else
    {
        p->next = q->next;
        free(q);
    }
}

2.7 按值删除

/*删除以L为头结点的单链表中值为key的第一个结点*/
void Delete_LinkList(LNode *L, int key)
{
    LNode *p = L, *q = L->next;
    while(q!=NULL && q->data!=key)
    {
        p = q;
        q = q->next;
    }
    if(q->data == key)
    {
        p->next = q->next;
        free(q);
    }
    else
        printf("所要删除的结点不存在！\n");
}

/*按值删除值为key的所有结点*/
void Delete_LinkList_Node(LNode *L, int key)
{
    LNode *p = L, *q = L->next;
    while(q!=NULL)
    {
        if(q->data==key)
        {
            p->next = q->next;
            free(q);
            q = p->next;
        }
        else
        {
            p = q;
            q = q->next;
        }
    }
}

/*删除以L为头结点的单链表中所有值相同的结点*/
void Delete_Node_value(LNode *L)
{
    LNode *p = L->next, *q, *ptr;
    while(p!=NULL)                    //检查链表中所有结点
    {
        q = p;
        ptr = p->next;
        while(ptr != NULL)            //检查结点p的所有后继结点ptr
        {
            if(ptr->data == p->data)
            {
                q->next = ptr->next;
                free(ptr);
                ptr = q->next;
            }
            else
            {
                q = ptr;
                ptr = ptr->next;
            }
        }
        p = p->next;
    }
}

2.8 合并

/*合并以La，Lb为头结点的两个有序单链表*/
LNode *Merge_LinkList(LNode *La, LNode *Lb)
{
    LNode *Lc, *pa, *pb, *pc, *ptr;
    Lc = La;
    pc = La;
    pa = La->next;
    pb = Lb->next;
    while(pa!=NULL &&pb!=NULL)
    {
        //将pa所指的结点合并，pa指向下一个结点
        if(pa->data < pb->data)
        {
            pc->next = pa;
            pc = pa;
            pa = pa->next;
        }
        
        //将pb所指的结点合并，pb指向下一个结点
        if(pa->data > pb->data)
        {
            pc->next = pb;
            pc = pb;
            pb = pb->next;
        }
        
        //将pa所指的结点合并，pb所指的结点删除
        if(pa->data == pb->data)
        {
            pc->next = pa;
            pc = pa;
            pa = pa->next;
            ptr = pb;
            pb = pb->next;
            free(ptr);
        }
    }
    
    if(pa != NULL)
        pc->next = pa;
    else
        pc->next = pb;   //将剩余的结点链上
    free(Lb);
    return Lc;
}

三、循环链表

判断是否空链表： head->next == head;
判断是否表尾结点： p->next == head;

四、双向链表

typedef struct Dulnode{
    ElemType data;
    struct Dulnode *prior, *next;
}DulNode;

4.1 插入

插入时仅仅指出直接前驱结点，钩链时必须注意先后次序是：“先右后左”。部分语句组如下：
```
S = (DulNode *)malloc(sizeof(DulNode));
S->data = e;
S->next = p->next;
p->next->prior = S;
p->next = S;
S->prior = p;
```
插入时同时指出直接前驱结点p和直接后继结点q，钩链时无须注意先后次序。部分语句组如下：
```
S = (DulNode *)malloc(sizeof(DulNode));
S->data = e;
p->next = S;
S->next = q;
S->prior = p;
q->prior = S;
```

4.2 删除

设要删除的结点为p，删除时可以不引人新的辅助指针变量，可以直接先断链，再释放结点。部分语句组如下：

p->prior->next = p->next;
p->next->prior = p->prior;
free(p);

线性表

线性表：顺序表和链表六种基本操作：

一、顺序表

1.1 初始化

1.2 查找

1.3 插入

1.4 删除

二、单链表

2.1 头插入法建表

2.2 尾插入法建表

2.3 按序号查找

2.4 按值查找

2.5 插入

2.6 按序号删除

2.7 按值删除

2.8 合并

三、循环链表

四、双向链表

4.1 插入

4.2 删除

Madplay移植到OK6410全過程詳解

線性表

冒泡排序

ok6410按鍵驅動與測試

smdk6410:uboot內存分配

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結