求助。正想跳槽 去面试遇到的题目

doofy

贴个测试代码~~

1. 
   
2. include <stdio.h>
   
3. #include <stdlib.h>
   
4. 
   
5. struct node_t {
   
6.         struct node_t *next;
   
7.         int index;
   
8. };
   
9. 
   
10. struct node_t *malloc_node(int index)
    
11. {
    
12.         struct node_t *pnode = malloc(sizeof(struct node_t));
    
13. 
    
14.         pnode->index = index;
    
15.        
    
16.         return pnode;
    
17. }
    
18. 
    
19. struct node_t *init_node(int num)
    
20. {
    
21.         int i =  0;
    
22.         struct node_t *node_head = malloc(sizeof(struct node_t));
    
23.         struct node_t *pnode;
    
24.         struct node_t *pre_node = node_head;
    
25. 
    
26.         for(; i < num; i++) {
    
27.                 pnode = malloc_node(i);               
    
28.                 pre_node->next = pnode;       
    
29.                 pre_node = pnode;
    
30.         }
    
31. 
    
32.         pnode->next = NULL;
    
33. 
    
34.         return node_head;
    
35. }
    
36. 
    
37. void dump_node_list(struct node_t *phead)
    
38. {
    
39.         struct node_t *p = phead;
    
40. 
    
41.         while(p->next) {
    
42.                 p = p->next;
    
43.                 printf("index: %d\n", p->index);
    
44.         }
    
45. }
    
46. 
    
47. struct node_t *convert_node(struct node_t *pre_node, struct node_t *pnode)
    
48. {
    
49.         struct node_t *tmp = pnode->next;
    
50.         struct node_t *last = NULL;
    
51. 
    
52.         if(pnode->next) {
    
53.                 last = convert_node(pnode, pnode->next);       
    
54.                 tmp->next = pnode;
    
55.                 pnode->next = pre_node;
    
56.         } else {
    
57.                 pnode->next = pre_node;
    
58.                 last = pnode;
    
59.         }
    
60.         return last;
    
61. }
    
62. 
    
63. void convert(struct node_t *phead)
    
64. {
    
65.         struct node_t *last = NULL;
    
66. 
    
67.         last = convert_node(NULL, phead->next);       
    
68.         phead->next = last;
    
69. }
    
70. 
    
71. int main()
    
72. {
    
73.         struct node_t *phead = init_node(10);
    
74. 
    
75.         dump_node_list(phead);
    
76. 
    
77.         convert(phead);
    
78. 
    
79.         dump_node_list(phead);
    
80. 
    
81.         return 0;
    
82. }
    

复制代码

kanhfshiys

1. #include <stdio.h>
   
2. struct node
   
3. {
   
4.     struct node *next;
   
5.     int data;
   
6. };
   
7. int main()
   
8. {
   
9.     int a[6];
   
10.     int i;
    
11.     struct node *node;
    
12.     struct node *root;
    
13.     struct node *tmp;
    
14.     void *b;
    
15.     void *c;
    
16.     void *d;
    
17.     int flag;
    
18.     flag=0;
    
19.     b=NULL;
    
20.     c=NULL;
    
21.     tmp = NULL;
    
22.     root=NULL;
    
23.     node=NULL;
    
24.     for ( i=0;i<6;i++ )
    
25.     {
    
26.         a[i]=i;
    
27.     }
    
28. /*创建六个节点开始*/
    
29.     for ( i=0;i<6;i++ )
    
30.     {
    
31.         node=malloc(sizeof(struct node));
    
32.         if ( 0==i )
    
33.         {
    
34.             root=node;
    
35.             node->next=NULL;
    
36.             tmp=root;
    
37.             node->data=a[i];
    
38.             continue;
    
39.         }
    
40.         node->next=NULL;
    
41.         node->data=a[i];
    
42.        ((struct node *)tmp)->next = node;
    
43.         node = NULL;
    
44.         tmp=tmp->next;
    
45.     }
    
46. /*创建六个节点结束*/
    
47.     tmp=root;
    
48.     i=0;
    
49. /*打印节点*/
    
50.     while ( NULL!=tmp )
    
51.     {
    
52.         fprintf(stderr,"%d ",tmp->data);
    
53.         tmp=tmp->next;
    
54.         i++;
    
55.     }
    
56.     i=i-3;
    
57.     fprintf(stderr,"\n");
    
58. /*倒置节点开始*/
    
59.     b=root->next->next;
    
60.     root->next->next=root;
    
61.     c=root->next;
    
62.     root->next->next->next=NULL;
    
63.     root=b;
    
64.     while ( flag!=i )
    
65.     {
    
66.         flag++;
    
67.         root=b;
    
68.         b=root->next;
    
69.         root->next=c;
    
70.         c=root;
    
71.     }
    
72.     root=b;
    
73.     root->next=c;
    
74.     tmp=root;
    
75. /*倒置节点结束*/
    
76.     while ( NULL!=tmp)
    
77.     {
    
78.         fprintf(stderr,"%d ",tmp->data);
    
79.         tmp=tmp->next;
    
80.     }
    
81.     fprintf(stderr,"\n");
    
82.     tmp=root;
    
83.     while ( NULL!=tmp)
    
84.     {
    
85.         d=tmp->next;
    
86.         free(tmp);
    
87.         tmp=d;
    
88.     }
    
89.     tmp =  NULL;
    
90.     root = NULL;
    
91. 
    
92. }

复制代码

大家帮忙看看我写的这个对不对！

kmindg

网上搜的
         typedef struct node   
        {   
                int data;   
                struct node *link;   
        }NODE;
       
        void reverse(NODE head)   
        {   
                NODE temp = null;   
                NODE p = head->link;   
                head->link = null;// 头结点变为尾结点
          
                while(p!=null)   
                {   
                   temp = p->link;   
                   p->link = head;// 当前结点指针倒置
                   head = p;   
                   p = temp;   
                }   
        }

ydfgic

节点和指针是一样的吗？一个是用户定义大小未知，一个4字节的变量

benjiam

。。。 递归的做法是有问题的， 会栈溢出的的。

zhaohongjian000

不允许用新节点，允许用指针？
asdmonster 发表于 2010-06-22 15:52

节点是节点，指针是指针....

mgqw

void reverse( struct node *head )
{
        if( head==NULL )
                return;
        struct node *pre, *cur, *nex;
        pre = head;
        cur = pre->next;

       
        while( cur )
        {
                nex = cur->next;

                cur->next = pre;

                pre = cur;
                cur = nex;
        }

        head->next = NULL;
        head = pre;


        return;
}

没本

单向链表这种数据结构，我是从来不用的，链条断裂死的很惨，而且还很不好查。

wmmy2008

17楼，是一个方法。

ssafa

不用指针，不用新节点的话就没什么办法了