常用算法积累

数组a，count为维数。

冒泡排序:每次交换相邻2个数，使最大的数放到a[j+1]

　　for(int i = 0; i < count; i++)

　　　　for(int j = 0;j < count - i - 1;j++)　　　　//每次交换只到倒数第二个，最后一次为倒数第二个和倒数第一个交换

　　　　　　if(a[j] < a[j+1]){

　　　　　　　　//交换a[j]和a[j+1]

　　　　　　}

选择排序:每次选择最小的数，使最小的放到a[i]。外层只循环count-1次，剩下一个自然是最大的，不用选择。

　　for(int i = 0;i < count - 1; i++)

　　　　int k = i;　　//临时变量，保存最小值的index

　　　　for(int j = i + 1;j < count;j++)

　　　　　　if(a[j] < a[i])　　k = j;

　　　　if(k != i){　　//交换a[i]和a[k]　}

 

链表，数据域和指向节点的指针

定义

struct node{

　　char name[20];

　　struct node *next;

};

struct node *XXX;

为简化使用，使用typedef

typedef struct node{

　　char name[20];

　　struct node *link;

} Node;　　//type MMMM Node;

Node *XXX;

创建

Node * create(int n){

　　Node *head,*next,*pre;　　//pre保存上一个节点

　　head= malloc(sizeof(Node));

　　if(head== NULL)

　　　　return NULL;

　　head->name = '\0';　　head->link = NULL;　　pre = head;

　　for(int i = n; i > 0;i--){

　　　　next = malloc(sizeof(Node));　　next->name = 'dfdf\0';　　next->link = NULL;

　　　　pre->link = next;

　　　　pre = next;

　　}

　　return head;

}

//删除，先取得要删除节点的next节点，不然删除后无法取得

删除b节点

a-next = b->next;

//插入，b节点

b->next = a->next;

a-next = b;

 

循环链表，尾节点的next指向head节点。

双向链表，每个节点有指向它的前一节点和后一节点指针，方便查找链表。

定义

typedef struct node{

　　char name[20];

　　struct node *pre, *next;

} Node;　　//type MMMM Node;

Node *XXX;

创建

Node * create(int n){

　　Node *head,*new,*previous;　　//pre保存上一个节点

　　head= malloc(sizeof(Node));

　　if(head== NULL)

　　　　return NULL;

　　head->name = '\0';　　head->next= NULL;　　head->pre = NULL;

　　previous= head;

　　for(int i = n; i > 0;i--){

　　　　new= malloc(sizeof(Node));　　new->name = 'dfdf\0';　　new->next = NULL;

　　　　previous->next= new;　　new->pre = previous;

　　　　previous= new

　　}

　　return head;

}

//删除

b->pre->next = b->next;

b->next->pre = b->pre;

//添加

　　//操作c

b->next = a->next;

a->next->pre = b;

　　//操作a

a->next = b;

b->pre = a;