关闭

嵌入式 用链表实现直接选择排序和直接插入排序示例

496人阅读 评论(0) 收藏 举报
分类:

mysort()为直接插入排序,mysort2()为直接选择排序;

对于直接选择排序,我一开始是直接交换的结点里的数据,这个虽然是程序简单化了,但这和一个数组还有区别吗?所以我又改了交换结点,当然这就要烦的多了,一个有4种不同的情况~~~~~

  1. #include
  2. #include
  3. typedef structnode
  4. {
  5. int data;
  6. struct node*next;
  7. }NODE;
  8. NODE * mycreate()
  9. {
  10. NODE * head = NULL;
  11. returnhead;
  12. }
  13. NODE * myinsert(NODE *head,intdata)
  14. {
  15. NODE *q = head;
  16. if(head ==NULL)
  17. {
  18. head = (NODE *)malloc(sizeof(NODE));
  19. head->data = data;
  20. head->next = NULL;
  21. }
  22. else
  23. {
  24. while(q->next !=NULL)
  25. {
  26. q = q->next;
  27. }
  28. NODE *newnode = (NODE *)malloc(sizeof(NODE));
  29. newnode->data = data;
  30. q->next = newnode;
  31. newnode->next = NULL;
  32. }
  33. returnhead;
  34. }
  35. NODE * mysort(NODE *head)
  36. {
  37. NODE *newhead = mycreate();
  38. NODE *q = head;
  39. NODE * max;
  40. NODE * tmp = NULL;
  41. max = (NODE *)malloc(sizeof(NODE));
  42. max->data = head->data;
  43. NODE *maxpre = head;
  44. while(head !=NULL)
  45. {
  46. max->data = head->data;
  47. q = head;
  48. while(q->next !=NULL)
  49. {
  50. if(q->next->data >max->data)
  51. {
  52. max->data = q->next->data;
  53. tmp = q->next;
  54. maxpre = q;
  55. }
  56. q = q->next;
  57. }
  58. newhead = myinsert(newhead,max->data);
  59. if(tmp !=NULL)
  60. {
  61. maxpre->next = tmp->next;
  62. if(tmp ==head)
  63. {
  64. head = head->next;
  65. }
  66. free(tmp);
  67. tmp = NULL;
  68. }
  69. else
  70. {
  71. free(head);
  72. head = NULL;
  73. }
  74. }
  75. returnnewhead;
  76. }
  77. NODE * mysort2(NODE *head)
  78. {
  79. NODE *q = head;
  80. NODE *last = head;
  81. NODE *p = NULL;
  82. NODE *max = NULL;
  83. NODE *premax = NULL;
  84. NODE *nextmax = NULL;
  85. NODE *prelast = NULL;
  86. NODE *lastnext = NULL;
  87. int tmp;
  88. while(last->next !=NULL)
  89. {
  90. p = last;
  91. lastnext = last->next;
  92. max = p;
  93. while(p->next !=NULL)
  94. {
  95. if(p->next->data >max->data)
  96. {
  97. max = p->next;
  98. premax = p;
  99. }
  100. p = p->next;
  101. }
  102. if(last ==head)
  103. {
  104. nextmax = max->next;
  105. if(premax ==last)
  106. {
  107. last->next = nextmax;
  108. max->next = last;
  109. head = max;
  110. }
  111. else
  112. {
  113. premax->next = last;
  114. head->next = max->next;
  115. max->next = lastnext;
  116. head = max;
  117. }
  118. last = head->next;
  119. prelast = head;
  120. }
  121. else
  122. {
  123. nextmax = max->next;
  124. prelast->next = max;
  125. if(premax ==last)
  126. {
  127. max->next = last;
  128. last->next = nextmax;
  129. }
  130. else
  131. {
  132. premax->next = last;
  133. last->next = nextmax;
  134. max->next = lastnext;
  135. }
  136. last = prelast->next;
  137. prelast = last;
  138. last = last->next;
  139. }
  140. }
  141. returnhead;
  142. }
  143. void myprint(NODE*head)
  144. {
  145. if(head ==NULL)
  146. {
  147. printf("Empty !\n");
  148. }
  149. else
  150. {
  151. while(head->next !=NULL)
  152. {
  153. printf("%d\t",head->data);
  154. head = head->next;
  155. }
  156. printf("%d\n",head->data);
  157. }
  158. }
  159. intmain()
  160. {
  161. NODE *head = mycreate();
  162. head = myinsert(head,1);
  163. head = myinsert(head,2);
  164. head = myinsert(head,3);
  165. head = myinsert(head,4);
  166. head = myinsert(head,5);
  167. head = myinsert(head,6);
  168. printf("排序前:");
  169. myprint(head);
  170. head = mysort2(head);
  171. printf("排序后:");
  172. myprint(head);
  173. return 0;
  174. }
#include 
#include 

typedef struct node 
{
    int data;
    struct node *next;
}NODE;

NODE * mycreate()
{
    NODE * head = NULL;
    return head;
}

NODE * myinsert(NODE *head,int data)
{
    NODE *q = head;
    if(head == NULL)
    {
        head = (NODE *)malloc(sizeof(NODE));
        head->data = data;
        head->next = NULL;
    }
    else
    {
        while(q->next != NULL)
        {
            q = q->next;
        }
        NODE *newnode = (NODE *)malloc(sizeof(NODE));
        newnode->data = data;
        q->next = newnode;
        newnode->next = NULL;
    }
    return head;
}

NODE * mysort(NODE *head)
{
    NODE *newhead = mycreate();
    NODE *q = head;
    NODE * max;
    NODE * tmp = NULL;
    max = (NODE *)malloc(sizeof(NODE));
    max->data = head->data;
    NODE *maxpre = head;
    while(head != NULL)
    {
            max->data = head->data;
            q = head;
        while(q->next != NULL)
        {
            if(q->next->data > max->data)
            {
                max->data = q->next->data;
                tmp = q->next;
                maxpre = q;
            }
            q = q->next;
        }
        newhead = myinsert(newhead,max->data);
        if(tmp != NULL)
        {
            maxpre->next = tmp->next;
            if(tmp == head)
            {
                head = head->next;
            }
            free(tmp);
            tmp = NULL;
        }
        else
        {
            free(head);
            head = NULL;
        }
    }
    return newhead;
}

NODE * mysort2(NODE *head)
{
    NODE *q = head;
    NODE *last = head;
    NODE *p = NULL;
    NODE *max = NULL;
    NODE *premax = NULL;
    NODE *nextmax = NULL;
    NODE *prelast = NULL;
    NODE *lastnext = NULL;
    int tmp;
    while(last->next != NULL)
    {
        p = last;
        lastnext = last->next;
        max = p;
        while(p->next != NULL)
        {
            if(p->next->data > max->data)
            {
                max = p->next;
                premax = p;
            }
            p = p->next;
        }
        if(last == head)
        {
                nextmax = max->next;
                if(premax == last)
                {
                    last->next = nextmax;
                    max->next = last;
                    head = max;  
                }
                else
                {
                    premax->next = last;
                    head->next = max->next;
                    max->next = lastnext;
                    head = max;
                }
                last = head->next;
                prelast = head;
        }
        else
        {
            nextmax = max->next;
            prelast->next = max;
            if(premax == last)
            {
                max->next = last;
                last->next = nextmax;
            }
            else
            {
                premax->next = last;
                last->next = nextmax;
                max->next = lastnext;

            }
            last = prelast->next;
            prelast = last;
            last = last->next;
        }

    }
    return head;
}

void myprint(NODE *head)
{
    if(head == NULL)
    {
        printf("Empty !\n");
    }
    else
    {
        while(head->next != NULL)
        {
            printf("%d\t",head->data);
            head = head->next;
        }
        printf("%d\n",head->data);
    }
}
int main()
{
    NODE *head = mycreate();
    head = myinsert(head,1);
    head = myinsert(head,2);
    head = myinsert(head,3);
    head = myinsert(head,4);
    head = myinsert(head,5);
    head = myinsert(head,6);
    printf("排序前:");
    myprint(head);
    head = mysort2(head);
    printf("排序后:");
    myprint(head);
    return 0;
}


0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:979825次
    • 积分:17634
    • 等级:
    • 排名:第540名
    • 原创:741篇
    • 转载:522篇
    • 译文:0篇
    • 评论:105条
    最新评论