c语言 *next和c,数据结构和算法C语言实现（未完）

struct Node

{

Node

*mpNext;

int

mData;

};

删除链表中值为Value的所有元素(

[Head]->[node1]->[node2]->...[noden]

)

void DeleteFromList( Node *pHead, int Value

)

{

Node *pPrev =

pHead;

Node *pNext =

pHead->mpNext;

while( nullptr != pNext

)

{

if( pNext->mData != Value

)

{

pPrev =

pNext;

pNext =

pNext->mpNext;

}

else

{

pPrev->mpNext =

pNext->mpNext;

delete

pNext;

pNext =

pPrev->mpNext;

}

}

}

在链表Index位置插入新的值为Value的元素

void InsertFromList( Node *pHead, int Index, int Value

)

{

Node *pIter =

pHead;

for( int i = 0; i <

Index && nullptr != pIter; ++i, pIter = pIter->mpNext

);

assert( nullptr != pIter

);

Node *pNew = new

Node;

pNew->mData =

Value;

pNew->mpNext =

pIter->mpNext;

pIter->mpNext =

pNew;

}

将链表逆序

Node* InvertedFromList( Node *pHead )

{

//A->B->C

Node *pPrev =

pHead; //A

Node *pNext =

pHead->mpNext; //B

Node *pNextNext =

nullptr; //C

while( nullptr != pNext

)

{

pNextNext = pNext->mpNext; //C =

B->C

pNext->mpNext = pPrev; //B->A

pPrev = pNext; //A =

B

pNext = pNextNext; //B =

C

}

pHead->mpNext =

nullptr;//C->B->A->null

return

pPrev; //return

C( new head )

}

网络

tcp_cli：

int sockfd = socket(AF_INET, SOCK_STREAM, 0);

struct sockaddr_in cli_addr;

cli_addr.sin_family = AF_INET;

cli_addr.sin_port = htons(8080);

cli_addr.sin_addr.s_addr = inet_addr("10.220.3.59");

int ret = connect(sockfd, (struct sockaddr*)&cli_addr,

sizeof(cli_addr));

if(ret != 0)

{

perror("connect");

close(sockfd);

exit -1;

}

tcp_ser:

int sockfd = socket(AF_INET, SOCK_STREAM, 0);

struct sockaddr_in ser_addr;

bzero(&ser_addr, sizeof(ser_addr));

ser_addr.sin_family = AF_INET;

ser_addr.sin_port = htons(8080);

ser_addr.sin_addr.s_addr = htonl(0);

int ret = bind(sockfd, (struct sockaddr*)&ser_addr,

sizeof(ser_addr));

if(ret != 0)

{

perror("bind");

close(sockfd);

exit -1;

}

ret = listen(sockfd, 10);

if(ret != 0)

{

perror("listen");

close(sockfd);

exit -1;

}

struct sockaddr_in acc_addr;

bzero(&acc_addr, sizeof(acc_addr));

socklen_t acc_len = sizeof(acc_addr);

acc_fd = accpet(sockfd, (struct sockaddr*)&acc_addr,

&acc_len);

if(acc_fd < 0)

{

perror("accept");

close(sockfd);

exit -1;

}

udp_cli:

int sockfd = socket(AF_INET, SOCK_DGRAM, 0);

struct sockaddr_in to;

bzero(&to, sizeof(to));

to.sin_family = AF_INET;

to.sin_port = htons(8080);

inet_pton(AF_INET, "10.220.3.59", &to.sin_addr);

char buf[1024] = "";

fgets(buf, 1024, stdin);

buf(strlen(buf)-1) = '\0';

sendto = (sockfd, buf, strlen(buf), 0, (struct

sockaddr*)&to, sizeof(to));

close(sockfd);

udp_ser:

int sockfd = socket(AF_INET, SOCK_DGRAM, 0);

struct sockaddr_in from;

bzero(&from, sizeof(from));

from.sin_family = AF_INET;

from.sin_port = htons(8080);

from.sin_addr.s_addr = htonl(0);

int bindfd = bind(sockfd, (struct sockaddr*)&from,

sizeof(from));

if(bindfd != 0)

{

perror("bind");

close(sockfd);

exit -1;

}

int recv_len;

char recv_buf[1024] = "";

struct sockaddr_in cli_addr;

char cli_ip[16] = "";

socklen_t cli_len = sizeof(cli_addr);

recv_len = recvfrom(sockfd, recv_buf, sizeof(recv_buf), 0,

(struct sockaddr*)&cli_addr, &cli_len);

inet_ntop(AF_INET, &cli_addr.sin_addr, cli_ip, 16);

close(sockfd);

单向链表

typedef struct student

{ //数据域

int num; //学号

int score; //分数

char name[20];

struct student *next;//指针域

}STU;

void link_creat_head(STU **p_head,STU *p_new)

{

STU *p_mov=*p_head;

if(*p_head==NULL) //当第一次加入链表为空时，head执行p_new

{

*p_head=p_new;

p_new->next=NULL;

}

else //第二次及以后加入链表

{

while(p_mov->next!=NULL)

{

p_mov=p_mov->next; //找到原有链表的最后一个节点

}

p_mov->next=p_new; //将新申请的节点加入链表

p_new->next=NULL;

}

}

STU * link_search_name(STU *head,char *name)

{

STU *p_mov;

p_mov=head;

while(p_mov!=NULL)

{

if(strcmp(p_mov->name,name)==0)//找到了

{

return p_mov;

}

p_mov=p_mov->next;

}

return NULL;//没有找到

}

void link_delete_name(STU **p_head,char *name)

{

STU *pb,*pf;

pb=pf=*p_head;

if(*p_head ==NULL)//链表为空，不用删

{

printf("链表为空，没有您要删的节点");\

return ;

}

while( (strcmp(pb->name,name)!=0) && (pb->next !=NULL))//循环找，要删除的节点

{

pf=pb;

pb=pb->next;

}

if(strcmp(pb->name,name)==0)//找到了一个节点的num和num相同

{

if(pb == *p_head)//要删除的节点是头节点

{

*p_head = pb->next;

}

else

{

pf->next = pb->next;

}

free(pb);

}

else//没有找到

{

printf("没有您要删除的节点\n");

}

}

双向链表

void double_link_creat(STU **p_head, STU *p_new)

{

STU *p_mov = *p_head;

if(*p_head == NULL)

{

*p_head = p_new;

p_new->front = NULL;

p_new->next = NULL;

}

else

{

while(p_mov->next != NULL)

{

p_mov = p_mov->next;

}

p_mov->next = p_new;

p_new->next = NULL;

p_new->front = p_mov;

}

}

void double_link_delete(STU **p_head, int num)

{

STU *pb,*pf;

pb = *p_head;

if(*p_head == NULL)

{

printf("链表为空\n");

return;

}

while((pb->num != num) && (pb->next !=

NULL))

{

pb = pb->next;

}

if(pb->num == num)

{

if(pb == *p_head)

{

if((*p_head)->next == NULL)

{

*p_head == pb->next;

}

else

{

*p_head == pb->next;

*p_head->front == NULL;

}

}

else

{

if(pb->next != NULL)

{

pf = pb->front;

pf->next = pb->next;

pb->next->front = pf;

}

else

{

pf = pb->front;

pf->next = NULL;

}

}

free(fb);

}

else

{

printf("没有要删除的节点\n");

return;

}

}

STU * link_search_name(STU *p_head, char *name)

{

STU *p_mov;

p_mov = p_head;

while(p_mov != NULL)

{

if(strcmp(p_mov->name, name) == 0)

{

return p_mov;

}

p_mov = p_mov->next;

}

return NULL;

}

STU *link_reverse(STU *head)

{

STU *pf, *pb, *r;

pf = head;

pb = pf->next;

while(pb != NULL)

{

r = pb->next;

pb->next = pf;

pf = pb;

pb = r;

}

head->next = NULL;

head = pf;

return head;

}

void link_free(STU **p_head)

{

STU *pb = *p_head;

while(*p_head != NULL)

{

pb = *p_head;

*p_head = (*p_head)->next;

free(pb);

}

}

生产者消费者

#include

#include

#define MAX 5

pthread_mutex_t mutex =

PTHREAD_MUTEX_INITIALIZER;

pthread_cond_t notfull =

PTHREAD_COND_INITIALIZER; //是否队满

pthread_cond_t notempty =

PTHREAD_COND_INITIALIZER; //是否队空

int top = 0; //队尾

int bottom = 0; //队头

void* produce(void*

arg)

{

int i;

for ( i = 0; i < MAX*2;

i++)

{

pthread_mutex_lock(&mutex);

while ((top+1)%MAX ==

bottom)

{

printf("full! producer is

waiting\n");

pthread_cond_wait(&notfull,

&mutex);//等待队不满

}

top = (top+1) % MAX;

printf("now top is %d\n",

top);

pthread_cond_signal(&notempty);//发出队非空的消息

pthread_mutex_unlock(&mutex);

}

return (void*)1;

}

void* consume(void*

arg)

{

int i;

for ( i = 0; i < MAX*2;

i++)

{

pthread_mutex_lock(&mutex);

while ( top%MAX ==

bottom)

{

printf("empty! consumer is

waiting\n");

pthread_cond_wait(&notempty,

&mutex);//等待队不空

}

bottom = (bottom+1) %

MAX;

printf("now bottom is %d\n",

bottom);

pthread_cond_signal(&notfull);//发出队不满的消息

pthread_mutex_unlock(&mutex);

}

return (void*)2;

}

int main(int argc, char

*argv[])

{

pthread_t thid1;

pthread_t thid2;

pthread_t thid3;

pthread_t thid4;

int ret1;

int ret2;

int ret3;

int ret4;

pthread_create(&thid1, NULL, produce,

NULL);

pthread_create(&thid2, NULL, consume,

NULL);

pthread_create(&thid3, NULL, produce,

NULL);

pthread_create(&thid4, NULL, consume,

NULL);

pthread_join(thid1,

(void**)&ret1);

pthread_join(thid2,

(void**)&ret2);

pthread_join(thid3,

(void**)&ret3);

pthread_join(thid4,

(void**)&ret4);

return 0;

}