数据结构[一]

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

单链表

 

链表是种动态分配内存空间，多个节点链接而成，每一节点包括数据和指向链表的下一个节点的指针

struct link{

 int data;

 struct link *next;

};

 

typedef struct link Node;

typedef Node *node;

 

单链表建立就是将每一个节点单各地串连起来

 

单链表创建

（动态分配空间后）新建一个头节点Head,用pointer标识节点指向新建的节点，把Head的next置空，再循环新其他节点，把新建都串连起来，next指针都为NULL，把pointer指每一个新建立的节点，最后返头节点Head。

pointer = head;

pointer->next = NULL;

while(pointer != NULL)

{

scanf(...);

new->next = NULL;

pointer->next = new;

pointer = new;

}

单链表输出

找到头节点Head，用pointer指向它，当pointer不为空时，一个接一个打印。

pointer = Head;

while(pointer != NULL)

{

printf(...);

pointer = pointer->next;

}

 

单链表释放

找到头节点Head，用pointer指向它，当pointer不为NULL时，一个接一个释放。

pointer = Head;

while(pointer != NULL)

{

Node link;

link = pointer;

pointer = pointer->next;

free(link);

}

 

 

 

单链表的插入方式：

1.插入在链表开头

要点需要将新节点的指针的next指针指向链表的首链节点，将将链表的首节点设为新节

点

New->next = pointer;

Head = New;

2.插入在链表中间

要点需要先在中间找到一节点link_ex,把新节点的next指针指向link_ex原来指向的位置，link_ex的next指针指向这个新节点，把新节点插在它后面.

New->next = link_ex->next;

link_ex->next = New;

 

3.插入在链表尾部

1.找到尾部节点，也就是节点的next指针为NULL

2.然后把new节点插入后即可

3.假如找尾部节点为link_ned,把new节点的next指针指向link_ned原来指向的位置（link_ned的下一个节点),link_end 的next指针指向new节点

 

 

New->next = link_end->next;

link_end->next = New;

 

链表的删除

1.删除头节点

要点找到头节点Head，如pointer正指向头节点的位置，把头节点往后移动一个位置，然后释放Head

 

Head = pointer->next;

free(Head);

2.删除中间节点，和尾部节点

要点需要找到要删除的节点pointer,和它的上一个节点back,把back的next指针指向pointer原来指的位置，也就是pointer的下一个节点，然后释放pointer

 

back->next = pointer->next

free(pointer);

 

链表反转

要点:假如头节点为head，用back节点指向head,在把head头节点变成尾节点之前，用一个pointer节点指向head的下一个节点，把head置NULL，这是pointer也就第一个节点了。

back = head;

pointer = back->next;

back->next = NULL;

 

再用一个节点Next指向pointer的下一个节点，因为要操作pointer节点，先记住它的下一节点.把pointer的next指针指向前面back指向的节点，然后把back,pointer都向后移动一个节点

 

Next = pointer->next;

pointer->next = back;

back = pointer;

pointer = Next;

 

当pointer这个第一节点的next不为NULL，也就是pointer不是最后一个节点，重复上面操作，若是最后一节点，就把最后节点指向前面一节点，把head指向这个节点

while(pointer->next != NULL)

{

Next = pointer->next;

pointer->next = back;

back = pointer;

pointer = Next;

}

pointer->next = back;

Head = pointer;

 

 

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

循环单链表创建

（动态分配空间后）新建一个头节点Head,用pointer标识节点指向新建的节点，把Head的next置空，再循环新其他节点，把新建都串连起来，next指针都为NULL，把pointer指每一个新建立的节点，当输入的条件不满足，路出循环，把最后一个节点指向头节点Head,最后返头节点Head。

pointer = head;

pointer->next = NULL;

while(pointer != NULL)

{

scanf(...);

new->next = NULL;

pointer->next = new;

pointer = new;

}

pointer->next = Head;

 

循环单链表输出

找到头节点Head的下一个节点，用pointer指向它，当pointer不是头节点Head时，一个接一个打印，最后把头节点也打印。

pointer = Head->next;

while(pointer != Head)

{

printf(...);

pointer = pointer->next;

}

循环单链表释放

找到头节点Head的下一个节点，用pointer指向它，当pointer不是头节点Head时，一个接一个释放，最后把头节点也释放。

pointer = Head->next;

Node link;

while(pointer != Head)

{

link = pointer;

pointer = pointer->next;

free(link);

}

free(pointer);

 

 

循环单链表插入

头插法

首先要找到Head和Head的上一个节点back，然后把NEW节点的next指向Head,头节点就是这个NEW节点了，再把back指向NEW

pointer = Head;

NEW->next = pointer;

Head = NEW;

back->next = NEW;

 

插入在链表中间/尾部

要点需要先在中间找到一节点link_ex,把新节点的next指针指向link_ex原来指向的位置，link_ex的next指针指向这个新节点，把新节点插在它后面.

New->next = link_ex->next;

link_ex->next = New;

 

循环单链表删除

找到指Head头节点的尾部节点back,把back->next指向head的下一个节点，Head头节点是Head的下一节点，然后释放掉原来的头节点

Node pointer;

pointer = Head;

back->next = pointer->next;

Head = pointer->next;

free(pointer);

 

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

双链表

结构体

struct Link{

int Number;

char Name[]; 

struct Link *next;   //前节点

struct Link *back;   //后节点

};

typedef struct Link link;

link *Node;

 

双链表建立

分配内存单元，新建Head头节点，pointer指向头节点Head,这是pointer->next = NULL,pointer->back = NULL，循环建下面节点，把它们串连起来。每建立一个把next，back置空，把它添加到头节点的尾部,把New->back指向Head,ponter指向新建节点,返回Head,以备后面查找，删除操作

 

 

Head->back = NULL;

Head->next = NULL;

pointer = Head;

while(1)

{

NEW->back = NULL;

NEW->next = NULL;

pointer->next = New;

New->back = pointer;

pointer = New;

}

return Head;

 

 

双链表插入

头插入法

NEW新节点，找到头节点，pointer指向Head头节点，把pointer->back指向NEW，NEW->next 指向pointer,把头节点指向NEW

 

pointer = Head;

NEW-next = pointer;

pointer->bakc = NEW;

Head = NEW;

 

其他插入法与单链表同异，但注意处Back指向的前节点.

中插法

pointer 是中间的一节点，NEW是要的插入的新节点

NEW-next = pointer->next;

NEW->back = pointer;

pointer->next = New;

NEW->next->back = NEW;

 

尾部插法

找到尾部节点pointer;

NEW->next = pointer->next;

NEW->back = pointer;

pointer->next = NEW;

NEW->next = NULL;

 

删除

删除中间节点,注意把next,back指的链接，删除之间要把它们形成链表,Link是要删除的节点

pointer = Link->back;

pointer->next=Link->next;

Link->back->next = pointer;

free(Link);

 

删除尾部节点,找到最后一个节点Next

pointer = Next->back;

pointer->next = Next->next;

free(Next);

 

删除头节点

pointer = Head;

back = pointer->next;

back->back=NULL;

Head = back;

free(pointer);

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

堆栈

后进先出

struct S_node{

int data;

struct S_node *next;

};

typedef struct S_node S_link;

typedef S_link *linklist;

linklist *stack = NULL;

 

入堆栈

定义pointer 指向空stack，stack这时是最顶指针，循环输入数据，为每一节点分配内存，把新NEW->next 指向pointer,然后把pointer指向NEW节点，pointer永远指在顶指针上。

pointer = stack;

while(NEW != NULL)

{

NEW->next = pointer;

pointer = NEW;

}

 

出堆栈

找到Head头节点，把数据拿出来，

pointer = Head;

while(Head != NULL)

{

Number=pointer->data;

Next=pointer;

pointer = pointer->next;

free(Next);

}

 

 

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

队列

先进先出

struct queue{

int data;

struct queue *next;

};

typedef struct queue link;

typedef link *Link;

Link front = NULL;

Link rear = NULL;

 

其中front和rear作为队列前后端的输出、输入指针控制，由于刚建立队列为空，所以front和rear指向NULL

 

入队

NEW = (..)malloc(..);

NEW->next = NULL;

if(rear == NULL)

front = NEW;

else

rear->next = NEW;

rear = NEW;

 

 

 

出队

while(front != NULL)

{

pointer = front;

front = front->next;

free(pointer);

}