C单链表

2014-11-04 05:37:40 305 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

基于奥比中光Orbbec Astra Pro与ROS实现实时3D环境建模：orb_slam2实战指南本文提供了一份详细的实战指南，介绍如何使用奥比中光Orbbec Astra Pro深度摄像头与ROS系统，部署并运行ORB-SLAM2算法，实现实时3D环境建模与定位。内容涵盖从驱动安装、环境配置、算法编译到摄像头标定与性能调优的全流程，旨在帮助开发者快速搭建一套高性价比的视觉SLAM系统。阅读详情

c的纯新手，看了两天书，对于指针链表还是搞不清楚，觉得再怎么想也无济于事，于是动手开始写，花了一下午把下面的单链表操作写完了，希望各位给些帮助，支出不妥和优化的地方，在此谢谢各位帮助了

#include <stdio.h>

#include <stdlib.h>



typedef struct node{

	int data;

	struct node *next;

}NODE ;

//创建链表

NODE *CreateLink(int len);

//查看链表

void DisplayLink( NODE *head );

//查看链表长度

int GetLinkLen( NODE *head );

//根据位置查找

void FindItemByPosition( NODE *head, int position );

//根据内容查找

void FindItem( NODE *head ,int value );

//插入节点

NODE *InsertItem( NODE *head, int position, int value );

//删除节点

NODE *DelItem( NODE *head, int value );

//根据位置删除节点

NODE *DelItemByPosition( NODE *head, int position );

//删除链表

void DelLink( NODE *head );



/**创建链表**/

NODE *CreateLink( int len ){

	NODE *head,*current,*temp;//头节点指针，当前指针,创建指针

	if( len == 0 ) return NULL;//长度为零，返回空指针

	head = (NODE *)malloc( sizeof (NODE));

	head->data = 0;

	head->next = NULL;

	if( len == 1 ) return head;//长度为1，返回头节点

	current = head;//当前指针指向头节点

	for( int i =1; i < len; i++ ){ 

		temp = (NODE *)malloc( sizeof (NODE));//分配内存,并将当前指针的next指向内存

		temp->data = i;

		temp->next = NULL;

		current->next = temp;//表示将current所指向的节点的next指向temp

		current = temp;//表示将current指针移向新生成的节点temp

	}

	return head;

}



/**查看指针长度**/

int GetLinkLen( NODE *head ){

	NODE *current;//当前指针

	current = head;//将当前指针指向头结点

	int len = 0;

	while( current != NULL ){

		len++;

		current = current->next;//指针后移

	}

	return len;

}



/**查看链表**/

void DisplayLink( NODE *head ){

	NODE *current;//当前指针

	current = head;//将当前指针指向头结点

	while( current!= NULL ){

		printf("data = %d\n", current->data);

		current = current->next;//指针后移

	}

}



/**根据位置查找**/

void FindItemByPosition( NODE *head, int position ){

	int len = GetLinkLen( head );//查看链表长度

	if( len < position+1 ) {

		printf("position error link len is %d\n", len);

		return;

	}

    NODE *current;//当前指针

    current = head;//将当前指针指向头结点

    //int size = sizeof(NODE);//计算结构体大小

    //current = head+position*size;//指针指向所查位置

    for( int i =0 ; i< position ; i++ ){

    	current = current->next;

    }

    printf("position %d data is %d\n", position,current->data);

}



/**根据内容查找**/

void FindItem( NODE *head ,int value ){

	NODE *current;//当前指针

	current = head;//将当前指针指向头结点

	int position = 0;

	while( current ){

		if( current->data == value ){

			printf("The %d position is %d\n", value,position);

			return ;

		}

		position++;

		current = current->next;//指针后移

	}

	printf("Don't find %d position\n", value);

	return;

}



/**插入节点**/

NODE *InsertItem( NODE *head, int position, int value ){	

	int len = GetLinkLen( head );//链表长度

	NODE *insert;//需要插入的

	insert = (NODE *)malloc( sizeof (NODE) );//内存分配

	insert->data = value;

	//1.查找要插入的位置

	//插入头

	if( position == 0 ){

		insert->next = head;

		return insert;

	}

	//插入尾部

	if( len < position + 1 ){

		position = len;

	}

	NODE *current,*prev;//当前指针，前驱指针

	current = head;//当前指针指向头结点

	for( int i=0; i<position; i++ ){

		prev = current;//前驱指针定位

		current = current->next;//指针后移

	}

	prev->next = insert;

	insert->next = current;

	return head;

}



/**删除节点**/

NODE *DelItem( NODE *head, int value ){

	NODE *current,*prev;//当前指针,前驱指针

	current = head;

	int position = 0;

	while (current){

		if( current->data == value ){

			if( position == 0 ){//头结点被删除

				NODE *newhead = head->next;

				free( head );

				return newhead;

			}

			prev->next = current->next;//将前驱指针定位到删除节点的下一个节点

			free( current );

			return head;

		}else{

			prev = current;//定位前驱指针

			current = current->next;	//指针后移

		}



	}

	printf("%d not exist in link\n", value);

	return head;

}



/**根据位置删除节点**/

NODE *DelItemByPosition( NODE *head, int position ){

	NODE *current,*prev;//当前指针,前驱指针

	current = head;

	if( position == 0 ){//删除头节点

		NODE *newhead = head->next;

		free( head );

		return newhead;

	}

	int len = GetLinkLen( head );//获取列表长度

	if( len < position + 1 ){

		position = len;

	}

	for( int i = 0 ; i < position ; i++ ){

		prev = current;//定位前驱指针

		current = current->next;//指针后移

	}

	prev->next = current->next;

	free( current );

	return head;

}



/**删除整个链表**/

void DelLink( NODE *head ){

	NODE *current,*prev;//当前指针，前驱指针

	current = head;

	while( current != NULL ){

		prev = current;//将当前指针指向头结点

		current = current->next;//指针后移

		free( prev );//删除前驱节点

	}

	printf("Del Link Done\n");

}

...全文

HP MSA 2050磁盘阵列配置步骤一、盘阵与服务器直接连接 1.1 单控制器配置：一台服务器/ 一个 HBA/ 单路径 1.2 双控制器配置：两台服务器/ 每台服务器一个 HBA/ 双路径二、通过交换机（一般光纤交换机） 2.1 双控制器配置：两台服务器/ 两台交换机三、配置MSA2050 3.1在完成硬件安装后，可以访问控制器模块的基于 Web 的管理界面 SMU （存储管理实用程序），以便监视和管理此存储系统。首先... 阅读详情

蟲蟲O_O

C语言 70,039 成员 243,237 内容

+ 关注 + 加入社区

切换为时间正序

赵4老师 2014-11-05

打赏
举报

//不带表头结点的单向链表
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>
#include <locale.h>
struct NODE {
    int          data;
    struct NODE *next;
} *head,*p,*q,*s,*p1,*p2,*q1,**ta;
int i,k,n,t,m,v,N=10;
int main() {
    setlocale(LC_ALL,"chs");
    srand(time(NULL));

    head=NULL;

    printf("创建%d个节点的单链表:",N);//创建N个节点的单链表
    p=head;
    for (i=0;i<N;i++) {
        q=(struct NODE *)malloc(sizeof(struct NODE));
        if (NULL==q) exit(1);
        q->data=rand()%100;//填写0..99的随机值
        q->next=NULL;
        if (NULL==p) {
            head=q;
            p=head;
        } else {
            p->next=q;
            p=q;
        }
    }

    //输出整个单链表
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    k=3;
    v=5;
    printf("将值为%d的结点插入到单链表的第%d个结点前:",v,k);//将值为v的结点插入到单链表的第k个结点前
    n=0;
    p=head;
    while (1) {
        if (NULL==p) {
            break;
        }
        n++;
        if (k==1) {
            q=(struct NODE *)malloc(sizeof(struct NODE));
            if (NULL==q) exit(1);
            q->data=5;
            q->next=head;
            head=q;
            break;
        } else {
            if (k-1==n) {
                q=(struct NODE *)malloc(sizeof(struct NODE));
                if (NULL==q) exit(1);
                q->data=5;
                q->next=p->next;
                p->next=q;
                break;
            }
        }
        p=p->next;
    }

    //输出整个单链表
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    k=5;
    printf("删除第%d个节点:",k);//删除第k个节点
    n=0;
    p=head;
    while (1) {
        if (NULL==p) {
            break;
        }
        n++;
        if (k==1) {
            q=head;
            head=head->next;
            free(q);
            break;
        } else {
            if (k-1==n) {
                q=p->next;
                if (q) {
                    p->next=q->next;
                    free(q);
                }
                break;
            }
        }
        p=p->next;
    }

    //输出整个单链表
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    printf("从小到大排序:");//从小到大排序
    for (p=head,p1=NULL;p!=NULL;p1=p,p=p->next) {
        for (q=p->next,q1=p;q!=NULL;q1=q,q=q->next) {
            if (p->data > q->data) {

                //交换data
//              printf("swap %02d %02d\n",p->data,q->data);
//              t=p->data;p->data=q->data;q->data=t;

                //或者

                //交换next
//              printf("swap %02d %02d\n",p->data,q->data);
                if (p==head) {//p是头
                    if (p->next==q) {//pq挨着
                        head=q;
                        p->next=q->next;
                        q->next=p;
                        q=p;
                        p=head;
                    } else {//pq不挨着
                        head=q;
                        p2=p->next;
                        p->next=q->next;
                        q->next=p2;
                        q1->next=p;
                        q=p;
                        p=head;
                    }
                } else {//p不是头
                    if (p->next==q) {//pq挨着
                        p1->next=q;
                        p->next=q->next;
                        q->next=p;
                        q=p;
                        p=p1->next;
                    } else {//pq不挨着
                        p1->next=q;
                        p2=p->next;
                        p->next=q->next;
                        q->next=p2;
                        q1->next=p;
                        q=p;
                        p=p1->next;
                    }
                }

                //输出整个单链表
//              s=head;
//              while (1) {
//                  if (NULL==s) {
//                      printf("\n");
//                      break;
//                  }
//                  printf("%02d->",s->data);
//                  s=s->next;
//              }
//              getchar();
            }
        }
    }

    //输出整个单链表并计算链表长度n
    n=0;
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        n++;
        s=s->next;
    }

    printf("将整个链表逆序:");//将整个链表逆序
    if (n>=2) {
        ta=(struct NODE **)malloc(n*sizeof(struct NODE *));
        if (NULL==ta) exit(1);
        s=head;
        for (i=0;i<n;i++) {
            ta[i]=s;
            s=s->next;
        }
        head=ta[n-1];
        for (i=n-1;i>0;i--) {
            ta[i]->next=ta[i-1];
        }
        ta[0]->next=NULL;
        free(ta);
    }

    //输出整个单链表
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    m=4;
    n=6;
    printf("将单链表中前%d个结点和后%d个结点进行互换:",m,n);//将单链表中前m个结点和后n个结点进行互换,m+n为链表总长
    k=0;
    p=head;
    while (1) {
        if (NULL==p) {
            break;
        }
        k++;
        if (m==k) {
            q=p;
        }
        s=p;
        p=p->next;
    }
    q1=head;
    head=q->next;
    s->next=q1;
    q->next=NULL;

    //输出整个单链表
    s=head;
    while (1) {
        if (NULL==s) {
            printf("\n");
            break;
        }
        printf("%02d->",s->data);
        s=s->next;
    }

    //释放所有节点
    p=head;
    while (1) {
        if (NULL==p) {
            break;
        }
        q=p->next;
        free(p);
        p=q;
    }

    return 0;
}
//创建10个节点的单链表:08->74->07->23->03->99->31->56->88->16->
//将值为5的结点插入到单链表的第3个结点前:08->74->05->07->23->03->99->31->56->88->16->
//删除第5个节点:08->74->05->07->03->99->31->56->88->16->
//从小到大排序:03->05->07->08->16->31->56->74->88->99->
//将整个链表逆序:99->88->74->56->31->16->08->07->05->03->
//将单链表中前4个结点和后6个结点进行互换:31->16->08->07->05->03->99->88->74->56->
//

蟲蟲O_O 2014-11-05

打赏
举报

引用 2 楼 cfjtaishan 的回复:

对于初学链表，建议在写对应操作函数时，可以考虑在草稿纸上画一画，搞清节点指针的指向。你这个好像没写demo测试程序哦，自己写个测试一下吧。对不对，只有测试了才能知道。

有写测试了也通过了，希望大家给点优化的指点

707wk 2014-11-05

打赏
举报

仅供参考

http://yun.baidu.com/s/17yIcQ

自信男孩 2014-11-04

打赏
举报

对于初学链表，建议在写对应操作函数时，可以考虑在草稿纸上画一画，搞清节点指针的指向。你这个好像没写demo测试程序哦，自己写个测试一下吧。对不对，只有测试了才能知道。

自信男孩 2014-11-04

打赏
举报


//楼主是否想创建len个节点呢？尝试一下这样：
NODE *CreateLink(int len)
{
      if (0 == len)
          return NULL;
     NODE *phead = *cur = *tmp = NULL;
     for (i = 0; i < len; i++) {
         if (NULL == phead) {
             phead = InitNode(i);
             cur = phead;
          }
         else
         {
              tmp = InitNode(i);
              cur->next = tmp;
              cur = tmp;
         }
     }
     return phead;
}

NODE *InitNode(int val)
{
      NODE *p = (NODE *)malloc(sizeof(NODE));
      if (NULL == p) {
              fprintf(stderr, "malloc error\n");
              exit(EXIT_FAILURE);
      }
      p->data = val;
       p->next = NULL;
}

NODE *CreateLink( int len ){
    NODE *head,*current,*temp;//头节点指针，当前指针,创建指针
    if( len == 0 ) return NULL;//长度为零，返回空指针
    head = (NODE *)malloc( sizeof (NODE));
    head->data = 0;
    head->next = NULL;
    if( len == 1 ) return head;//长度为1，返回头节点
    current = head;//当前指针指向头节点
    for( int i =1; i < len; i++ ){ 
        temp = (NODE *)malloc( sizeof (NODE));//分配内存,并将当前指针的next指向内存
        temp->data = i;
        temp->next = NULL;
        current->next = temp;//表示将current所指向的节点的next指向temp
        current = temp;//表示将current指针移向新生成的节点temp
    }
    return head;
}

C单链表

相关推荐