链表排序-冒泡排序

动态数组的存储和排序

 需求： C不支持动态数组，申明的时候，一定要指明动态数组的大小，不能将数组的大小设置为未知数，但是很多情况 下，数据量的大小是未知数，或者数据量的大小会随着问题的变化而变化。
   解决：使用链表结构来存储数据

// DymicArray.cpp : Defines the entry point for the console application.  
//  
  
#include "stdafx.h"  
// MyList.cpp : Defines the entry point for the console application.  
//  
  
#include "stdafx.h"  
  
#include   
#include   
#include   
#include   
  
using namespace std;  
  
  
// data  
  
typedef struct  
{  
    char key[10];  
    char name[20];  
    int age;  
}Data;  
  
typedef struct Node  
{  
    Data nodeData;  
    struct Node *nextNode;  
}CLType;  
  
// AddTail  
CLType *CLAddEnd(CLType *head, Data nodeData)  
{  
    CLType *node,*htemp;  
  
    if(!(node = (CLType*)malloc(sizeof(CLType))))  
    {  
        printf("malloc false!\n");  
        return NULL;  
    }  
    else  
    {  
        node->nodeData = nodeData;  
        node->nextNode = NULL;  
  
        if(head == NULL)  
        {  
            head = node;  
            return head;  
        }  
        htemp = head;  
        while(htemp->nextNode != NULL)  
        {  
            htemp=htemp->nextNode;  
        }  
        htemp->nextNode = node;  
        return head;  
    }  
}  
  
// InsertFirst  
CLType *CLAddFirst(CLType *head, Data nodeData)  
{  
    CLType *node = NULL;   // init  
  
    if(!(node == (CLType *)malloc(sizeof(CLType))))  
    {  
        printf("AddFirst malloc false\n");  
        return NULL;  
    }  
    else  
    {  
        node->nodeData = nodeData;  
        node->nextNode = head;  
        head = node;  
        return head;  
    }  
}  
  
// Find Key  
CLType *CLFindNode(CLType *head, char *key)  
{  
    CLType *htemp;  
    htemp = head;  
    while(htemp)  
    {  
        if(strcmp(htemp->nodeData.key, key) == 0)  
        {  
            return htemp;  
        }  
        htemp = htemp->nextNode;  
    }  
    return NULL;  
}  
  
// Insert Node  
CLType *CLInsertNode(CLType *head, char *findkey, Data nodeData)  
{  
    CLType *node = NULL, *nodetemp = NULL;  
  
     if(!(node = (CLType*)malloc(sizeof(CLType))))  
    {  
        printf("malloc false!\n");  
        return NULL;  
    }  
    node->nodeData = nodeData;  
    nodetemp = CLFindNode(head, findkey);  
  
    if(nodetemp)  
    {  
        node->nextNode = nodetemp->nextNode;  
        nodetemp->nextNode = node;  
    }  
    else  
    {  
        printf("%s Not Found\n", findkey);  
        free(node);  
    }  
    return head;  
}  
  
// DelNode  
int CLDeleteNode(CLType *head, char *key)  
{  
    CLType *node, *htemp;  
  
    htemp = head;  
    node = head;  
  
    while(htemp)  
    {  
        if(strcmp(htemp->nodeData.key, key) == 0)  
        {  
            node->nextNode = htemp->nextNode;  
            free(htemp);  
            return 1;  
        }  
        else  
        {  
            node = htemp;  
            htemp = htemp->nextNode;  
        }  
    }  
    return 0;  
}  
  
// CL length  
int CLLength(CLType *head)  
{  
    CLType *htemp = NULL;  
    int Len = 0;  
    htemp = head;  
  
    while(htemp)  
    {  
        Len++;  
        htemp = htemp->nextNode;  
    }  
    return Len;  
}  
  
// Show ALL  
void CLAllNode(CLType *head)  
{  
    CLType *htemp;  
    Data nodeData;  
    htemp = head;  
    printf("having %d node show All \n", CLLength(head));  
  
    while(htemp)  
    {  
        nodeData = htemp->nodeData;  
        printf("Node(%s,%s,%d)\n", nodeData.key, nodeData.name, nodeData.age);  
        htemp = htemp->nextNode;  
    }  
}  
  
  
// 排序 冒泡排序方法  
void DynamicSort(CLType *head)  
{  
    int i,j;  
    CLType *htemp = NULL;  
    int Len = 0;  
    htemp = head;  
    Data nodedata;  
      
    // 获取链表的长度  
    while(htemp){  
        Len++;  
        htemp = htemp->nextNode;  
    }  
    // 链表表头置为链表头  
    htemp = head;  
  
    // 冒泡排序方法：   
    //             ↓(i)  
    //   ------------------- (Len)  
    //   ↑(j)---->|(Len-i-1)  
    for (i = 0; i < Len-1; i++)  
    {  
        for (j = 0; j < Len - i - 1; j++)  
        {  
            // 按照年龄大小进行比较  
            if (htemp->nodeData.age < htemp->nextNode->nodeData.age)  
            {  
                nodedata.age = htemp->nodeData.age;  
                strcpy(nodedata.key,htemp->nodeData.key);  
                strcpy(nodedata.name, htemp->nodeData.name);  
  
                htemp->nodeData.age = htemp->nextNode->nodeData.age;  
                strcpy(htemp->nodeData.key, htemp->nextNode->nodeData.key);  
                strcpy(htemp->nodeData.name, htemp->nextNode->nodeData.name);  
                  
                htemp->nextNode->nodeData.age = nodedata.age;  
                strcpy(htemp->nextNode->nodeData.name, nodedata.name);  
                strcpy(htemp->nextNode->nodeData.key, nodedata.key);  
            }  
            htemp = htemp->nextNode;  
        }  
        htemp = head;  // 每次比较之后 将临时链表指针移到链表头  
    }  
}  
  
  
int main()  
{  
    CLType *node, *head = NULL;  
    Data nodeData;  
    char key[10], findkey[10];  
  
    cout<<"test CList enter list init data format like: key name age"<>findkey;  
    cout<<"findkey"<>nodeData.key>>nodeData.name>>nodeData.age;  
    cout<>key;  
    CLDeleteNode(head, key);  
    CLAllNode(head);  
  
    cout<<"find enter you want find key:"<>key;  
    node = CLFindNode(head, key);  
    if(node)  
    {  
        nodeData = node->nodeData;  
        cout<<"key"<