国产探花免费观看_亚洲丰满少妇自慰呻吟_97日韩有码在线_资源在线日韩欧美_一区二区精品毛片,辰东完美世界有声小说,欢乐颂第一季,yy玄幻小说排行榜完本

首頁 > 學(xué)院 > 開發(fā)設(shè)計 > 正文

數(shù)據(jù)結(jié)構(gòu)C語言實現(xiàn)系列——線性表

2019-11-17 05:02:58
字體：大 中 小
供稿：網(wǎng)友
Word-BREAK: break-all; PADDING-TOP: 4px; BORDER-BOTTOM: windowtext 0.5pt solid">
#include <stdio.h>
#include <stdlib.h>
typedef int elemType;
/************************************************************************/
/*                以下是關(guān)于線性表順序存儲操作的16種算法                        */
/************************************************************************/
strUCt List{
    elemType *list;
    int size;
    int maxSize;
};

void againMalloc(struct List *L)
{    
    /* 空間擴展為原來的2倍，并由p指針?biāo)赶颍瓋?nèi)容被自動拷貝到p所指向的存儲空間 */
    elemType *p = realloc(L->list, 2 * L->maxSize * sizeof(elemType));
    if(!p){    /* 分配失敗則退出運行 */
                exit(1);
    }
    L->list = p;    /* 使list指向新線性表空間 */
    L->maxSize = 2 * L->maxSize;    /* 把線性表空間大小修改為新的長度 */
}

/* 1.初始化線性表L，即進行動態(tài)存儲空間分配并置L為一個空表 */
void initList(struct List *L, int ms)
{
    /* 檢查ms是否有效，若無效的則退出運行 */
    if(ms <= 0){
        printf("MaxSize非法！ ");
        exit(1);    /* 執(zhí)行此函數(shù)中止程序運行，此函數(shù)在stdlib.h中有定義 */
    }
    L->maxSize = ms;    /* 設(shè)置線性表空間大小為ms */
    L->size = 0;
    L->list = malloc(ms * sizeof(elemType));
    if(!L->list){
        printf("空間分配失敗！ ");
        exit(1);
    }
    return;
}

/* 2.清除線性表L中的所有元素，釋放存儲空間，使之成為一個空表 */
void clearList(struct List *L)
{
    if(L->list != NULL){
        free(L->list);
        L->list = 0;
        L->size = L->maxSize = 0;
    }
    return;
}

/* 3.返回線性表L當(dāng)前的長度，若L為空則返回０ */
int sizeList(struct List *L)
{
    return L->size;
}

/* 4.判定線性表L是否為空，若為空則返回1, 否則返回0 */
int emptyList(struct List *L)
{
    if(L->size ==0){
        return 1;
    }
    else{
        return 0;
    }
}

/* 5.返回線性表L中第pos個元素的值，若pos超出范圍，則停止程序運行 */
elemType getElem(struct List *L, int pos)
{
    if(pos < 1  pos > L->size){    /* 若pos越界則退出運行 */
        printf("元素序號越界！ ");
        exit(1);
    }
    return L->list[pos - 1];    /* 返回線性表中序號為pos值的元素值 */
}

/* 6.順序掃描（即遍歷）輸出線性表L中的每個元素 */
void traverseList(struct List *L)
{
    int i;
    for(i = 0; i < L->size; i++){
        printf("%d ", L ->list[i]);
    }
    printf(" "); 
    return;
}

/* 7.從線性表L中查找值與x相等的元素，若查找成功則返回其位置，否則返回-1 */
int findList(struct List *L, elemType x)
{
    int i;
    for(i = 0; i < L->size; i++){
        if(L->list[i] == x){
            return i;
        }
    }
    return -1;
}

/* 8.把線性表L中第pos個元素的值修改為x的值，若修改成功返回1，否則返回0 */
int updatePosList(struct List *L, int pos, elemType x)
{
    if(pos < 1  pos > L->size){    /* 若pos越界則修改失敗 */
        return 0;
    }
    L->list[pos - 1] = x;
    return 1;
}

/* 9.向線性表L的表頭插入元素x */
void inserFirstList(struct List *L, elemType x)
{
    int i;
    if(L->size == L->maxSize){
        againMalloc(L);
    }
    for(i = L->size - 1; i >= 0; i--){
        L->list[i + 1] = L ->list[i];
    }
    L->list[0] = x;
    L->size ++;
    return;
}

/* 10.向線性表L的表尾插入元素x */
void insertLastList(struct List *L, elemType x)
{
    if(L->size == L ->maxSize){    /* 重新分配更大的存儲空間 */
        againMalloc(L);
    }
    L->list[L->size] = x;    /* 把x插入到表尾 */
    L->size++;    /* 線性表的長度增加１ */
    return;
}

/* 11.向線性表L中第pos個元素位置插入元素x，若插入成功返回１，否則返回０ */
int insertPosList(struct List *L, int pos, elemType x)
{
    int i;
    if(pos < 1  pos > L->size + 1){    /* 若pos越界則插入失敗 */
        return 0;
    }
    if(L->size == L->maxSize){    /* 重新分配更大的存儲空間 */
        againMalloc(L);
    }
    for(i = L->size - 1; i >= pos - 1; i--){
        L->list[i + 1] = L->list[i];
    }
    L->list[pos - 1] = x;
    L->size++;
    return 1;
}
/* 12.向有序線性表L中插入元素x,　使得插入后仍然有序*/
void insertOrderList(struct List *L, elemType x)
{
    int i, j;
    /* 若數(shù)組空間用完則重新分配更大的存儲空間 */
    if(L->size == L->maxSize){
        againMalloc(L);
    }
    /* 順序查找出x的插入位置 */
    for(i = 0; i < L->size; i++){
        if(x < L->list[i]){ 
            break;
        }
    }
    /* 從表尾到下標(biāo)i元素依次后移一個位置， 把i的位置空出來 */
    for(j = L->size - 1; j >= i; j--)
        L->list[j+1] = L->list[j];
    /* 把x值賦給下標(biāo)為i的元素 */    
    L->list[i] = x;
    /* 線性表長度增加1 */
    L->size++;
    return;
}

/* 13.從線性表L中刪除表頭元素并返回它，若刪除失敗則停止程序運行 */
elemType deleteFirstList(struct List *L)
{
    elemType temp;
    int i;
    if(L ->size == 0){
        printf("線性表為空，不能進行刪除操作！ ");
        exit(1);
    }
    temp = L->list[0];
    for(i = 1; i < L->size; i++)
        L->list[i-1] = L->list[i];
    L->size--;
    return temp;
}

/* 14.從線性表L中刪除表尾元素并返回它，若刪除失敗則停止程序運行 */
elemType deleteLastList(struct List *L)
{
    if(L ->size == 0){
        printf("線性表為空，不能進行刪除操作！ ");
        exit(1);
    }
    L->size--;
    return L ->list[L->size];        /* 返回原來表尾元素的值 */
}
/* 15.從線性表L中刪除第pos個元素并返回它，若刪除失敗則停止程序運行 */
elemType deletePosList(struct List *L, int pos)
{
    elemType temp;
    int i;
    if(pos < 1  pos > L->size){        /* pos越界則刪除失敗 */
        printf("pos值越界，不能進行刪除操作！ ");
        exit(1);
    }
    temp = L->list[pos-1];
    for(i = pos; i < L->size; i++)
        L->list[i-1] = L->list[i];
    L->size--;
    return temp;
}
/* 16.從線性表L中刪除值為x的第一個元素，若成功返回1，失敗返回0 */
int deleteValueList(struct List *L, elemType x)
{
    int i, j;
    /* 從線性表中順序查找出值為x的第一個元素 */
    for(i = 0; i < L->size; i++){
        if(L->list[i] == x){    
            break;
        }
    }
    /* 若查找失敗，表明不存在值為x的元素，返回0 */
    if(i == L->size){
        return 0;
    }
    /* 刪除值為x的元素L->list[i] */
    for(j = i + 1; j < L->size; j++){
        L->list[j-1] = L->list[j];
    }
    L->size--;
    return 1;
}

/************************************************************************/

void main()
{
    int a[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
    int i;
    struct List L;
    initList(&L, 5);
    for(i = 0; i < 10; i++){
        insertLastList(&L, a[i]);
    }
    insertPosList(&L, 11, 48);        insertPosList(&L, 1, 64);
    printf("%d ", getElem(&L, 1));
    traverseList(&L);
    printf("%d ", findList(&L, 10));
    updatePosList(&L, 3, 20);
    printf("%d ", getElem(&L, 3));
    traverseList(&L);
    deleteFirstList(&L);            deleteFirstList(&L);
    deleteLastList(&L);                deleteLastList(&L);
    deletePosList(&L, 5);            ;deletePosList(&L, 7);
    printf("%d ", sizeList(&L));
    printf("%d ", emptyList(&L));
    traverseList(&L);
    clearList(&L);
    return 0;
}
更多文章 更多內(nèi)容請看C/C++進階技術(shù)文檔  數(shù)據(jù)結(jié)構(gòu)  數(shù)據(jù)結(jié)構(gòu)相關(guān)文章專題，或

#include <stdio.h>
#include <stdlib.h>
#define NN 12
#define MM 20
typedef int elemType ;
/************************************************************************/
/*             以下是關(guān)于線性表鏈接存儲（單鏈表）操作的16種算法        */
/************************************************************************/
struct sNode{    /* 定義單鏈表結(jié)點類型 */
    elemType data;
    struct sNode *next;
};

/* 1.初始化線性表，即置單鏈表的表頭指針為空 */
void initList(struct sNode* *hl)
{
    *hl = NULL;
    return;
}

/* 2.清除線性表L中的所有元素，即釋放單鏈表L中所有的結(jié)點，使之成為一個空表 */
void clearList(struct sNode* *hl)
{
    /* cp和np分別作為指向兩個相鄰結(jié)點的指針 */
    struct sNode *cp, *np;
    cp = *hl;
    /* 遍歷單鏈表，依次釋放每個結(jié)點 */
    while(cp != NULL){
        np = cp->next;    /* 保存下一個結(jié)點的指針 */
        free(cp);
        cp = np;
    }
    *hl = NULL;        /* 置單鏈表的表頭指針為空 */
    return;
}

/* 3.返回單鏈表的長度 */
int sizeList(struct sNode *hl)
{
    int count = 0;        /* 用于統(tǒng)計結(jié)點的個數(shù) */
    while(hl != NULL){
        count++;
        hl = hl->next;
    }
    return count;
}

/* 4.檢查單鏈表是否為空，若為空則返回１，否則返回０ */
int emptyList(struct sNode *hl)
{
    if(hl == NULL){
        return 1;
    }else{
        return 0;
    }
}

/* 5.返回單鏈表中第pos個結(jié)點中的元素，若pos超出范圍，則停止程序運行 */
elemType getElem(struct sNode *hl, int pos)
{
    int i = 0;        /* 統(tǒng)計已遍歷的結(jié)點個數(shù) */
    if(pos < 1){
        printf("pos值非法，退出運行！
");
        exit(1);
    }
    while(hl != NULL){
        i++;
        if(i == pos){
            break;
        }
        hl = hl->next;
    }
    if(hl != NULL){
        return hl->data;
    }else{
        printf("pos值非法，退出運行！ ");
        exit(1);
    }
}

/* 6.遍歷一個單鏈表 */
void traverseList(struct sNode *hl)
{
    while(hl != NULL){
        printf("%5d", hl->data);
        hl = hl->next;
    }
    printf(" ");
    return;
}

/* 7.從單鏈表中查找具有給定值x的第一個元素，若查找成功則返回該結(jié)點data域的存儲地址，否則返回NULL */
elemType* findList(struct sNode *hl, elemType x)
{
    while(hl != NULL){
        if(hl->data == x){
            return &hl->data;
        }else{
            hl = hl->next;    
        }
    }
    return NULL;
}

/* 8.把單鏈表中第pos個結(jié)點的值修改為x的值，若修改成功返回１，否則返回０ */
int updatePosList(struct sNode *hl, int pos, elemType x)
{
    int i = 0;
    struct sNode *p = hl;
    while(p != NULL){        /* 查找第pos個結(jié)點 */
        i++;
        if(pos == i){
            break;
        }else{
            p = p->next;
        }
    }
    if(pos == i){
        p->data = x;
        return 1;
    }else{
        return 0;
    }
}

/* 9.向單鏈表的表頭插入一個元素 */
void insertFirstList(struct sNode* *hl, elemType x)
{
    struct sNode *newP;
    newP = malloc(sizeof(struct sNode));
    if(newP == NULL){
        printf("內(nèi)存分配失敗，退出運行！
");
        exit(1);
    }
    newP->data = x;        /* 把x的值賦給新結(jié)點的data域 */
    /* 把新結(jié)點作為新的表頭結(jié)點插入 */
    newP->next = *hl;        
    *hl = newP;
    return;
}

/* 10.向單鏈表的末尾添加一個元素 */
void insertLastList(struct sNode* *hl, elemType x)
{
    struct sNode *newP;
    newP = malloc(sizeof(struct sNode));
    if(newP == NULL){
        printf("內(nèi)在分配失敗，退出運行！ ");
        exit(1);
    }
    /* 把x的值賦給新結(jié)點的data域，把空值賦給新結(jié)點的next域 */
    newP->data = x;
    newP->next = NULL;
    /* 若原表為空，則作為表頭結(jié)點插入 */
    if(*hl == NULL){
        *hl = newP;        
    }
    /* 查找到表尾結(jié)點并完成插入 */
    else{
        struct sNode *p = NULL;
        while(p->next != NULL){
            p = p->next;
        }
        p->next = newP;
    }
    return;
}

/* 11.向單鏈表中第pos個結(jié)點位置插入元素為x的結(jié)點，若插入成功返回１，否則返回０ */
int insetPosList(struct sNode* *hl, int pos, elemType x){
    int i = 0;
    struct sNode *newP;
    struct sNode *cp = *hl, *ap = NULL;
    /* 對pos值小于等于０的情況進行處理 */
    if(pos <= 0){
        printf("pos值非法，返回０表示插入失敗！ ");
        return 0;
    }
    /* 查找第pos個結(jié)點 */
    while(cp != NULL){
        i++;
        if(pos == i){
            break;
        }else{
            ap = cp;
            cp = cp->next;
        }
    }
    /* 產(chǎn)生新結(jié)點，若分配失敗，則停止插入 */
    newP = malloc(sizeof(struct sNode));
    if(newP == NULL){
        printf("內(nèi)存分配失敗，無法進行插入操作！
");
        return 0;
    }
    /* 把x的值賦給新結(jié)點的data域 */
    newP->data = x;
    /* 把新結(jié)點插入到表頭 */
    if(ap == NULL){
        newP->next = cp;        /* 或改為newP->next = *hl; */
        *hl = newP;
    }
    /* 把新結(jié)點插入到ap和cp之間 */
    else{
        newP->next = cp;
        ap->next = newP;
    }
    return 1;        /* 插入成功返回1 */
}

/* 12.向有序單鏈表中插入元素x結(jié)點，使得插入后仍然有序 */
void insertOrderList(struct sNode* *hl, elemType x)
{
    /* 把單鏈表的表頭指針賦給cp，把ap置空 */
    struct sNode *cp = *hl, *ap = NULL;
    /* 建立新結(jié)點 */
    struct sNode *newP;
    newP = malloc(sizeof(struct sNode));
    if(newP == NULL){
        printf("內(nèi)在分配失敗，退出運行！ ");
        exit(1);
    }
    newP->data = x;        /* 把x的值賦給新結(jié)點的data域 */
    /* 把新結(jié)點插入到表頭 */
    if((cp == NULL)  (x < cp->data)){
        newP->next = cp;
        *hl = newP;
        return;
    }
    /* 順序查找出x結(jié)點的插入位置 */
    while(cp != NULL){
        if(x < cp->data){
            break;
        }else{
            ap = cp;
            cp = cp->next;
        }
    }
    /* 把x結(jié)點插入到ap和cp之間 */
    newP->next = cp;
    ap->next = newP;
    return;
}

/* 13.從單鏈表中刪除表頭結(jié)點，并把該結(jié)點的值返回，若刪除失敗則停止程序運行 */
elemType deleteFirstList(struct sNode* *hl)
{
    elemType temp;
    struct sNode *p = *hl;        /* 暫存表頭結(jié)點指針，以便回收 */
    if(*hl == NULL){
        printf("單鏈表為空，無表頭可進行刪除，退出運行！
");
        exit(1);
    }
    *hl = (*hl)->next;        /* 使表頭指針指向第二個結(jié)點 */
    temp = p->data;            /* 暫存原表頭元素，以便返回 */
    free(p);                /* 回收被刪除的表頭結(jié)點 */
    return temp;            /* 返回第一個結(jié)點的值 */
}

/* 14.從單鏈表中刪除表尾結(jié)點并返回它的值，若刪除失敗則停止程序運行 */
elemType deleteLastList(struct sNode* *hl)
{
    elemType temp;
    /* 初始化cp和ap指針，使cp指向表頭結(jié)點，使ap為空 */
    struct sNode *cp = *hl;
    struct sNode *ap = NULL;
    /* 單鏈表為空則停止運行 */
    if(cp == NULL){
        printf("單鏈表為空，無表頭進行刪除，退出運行！ ");
        exit(1);
    }
    /* 從單鏈表中查找表尾結(jié)點，循環(huán)結(jié)束時cp指向表尾結(jié)點，ap指向其前驅(qū)結(jié)點 */
    while(cp->next != NULL){
        ap = cp;
        cp = cp->next;
    }
    /* 若單鏈表中只有一個結(jié)點，則需要修改表頭指針 */
    if(ap == NULL){
        *hl = (*hl)->next;        /* 或改為*hl = NULL; */
    }
    /* 刪除表尾結(jié)點 */
    else{
        ap->next = NULL;
    }
    /* 暫存表尾元素，以便返回 */
    temp = cp->data;
    free(cp);        /* 回收被刪除的表尾結(jié)點 */
    return temp;        /* 返回表尾結(jié)點的值 */
}

/* 15.從單鏈表中刪除第pos個結(jié)點并返回它的值，若刪除失敗則停止程序運行 */
elemType deletePosList(struct sNode* *hl, int pos)
{
    int i = 0;
    elemType temp;
    /* 初始化cp和ap指針，使cp指向表頭結(jié)點，使ap為空 */
    struct sNode *cp = *hl;
    struct sNode *ap = NULL;
    /* 單鏈表為空或pos值非法則停止運行 */
    if((cp == NULL)  (pos <= 0)){
        printf("單鏈表為空或pos值不正確，退出運行！
");
        exit(1);
    }
    /* 從單鏈表中查找第pos個結(jié)點，找到后由cp指向該結(jié)點，由ap指向其前驅(qū)結(jié)點 */
    while(cp != NULL){
        i++;
        if(i == pos){
            break;
        }
        ap = cp;
        cp = cp->next;
    }
    /* 單鏈表中沒有第pos個結(jié)點 */
    if(cp == NULL){
        printf("pos值不正確，退出運行！ ");
        exit(1);
    }
    /* 若pos等于1，則需要刪除表頭結(jié)點 */
    if(pos == 1){
        *hl = (*hl)->next;        /* 或改為*hl = cp->next; */
    }
    /* 否則刪除非表頭結(jié)點，此時cp指向該結(jié)點，ap指向前驅(qū)結(jié)點 */
    else{
        ap->next = cp->next;
    }
    /* 暫存第pos個結(jié)點的值，以便返回 */
    temp = cp->data;
    free(cp);        /* 回收被刪除的第pos個結(jié)點 */
    return temp;    /* 返回在temp中暫存的第pos個結(jié)點的值 */
}

/* 16.從單鏈表中刪除值為x的第一個結(jié)點，若刪除成功則返回1,否則返回0 */
int deleteValueList(struct sNode* *hl, elemType x)
{
    /* 初始化cp和ap指針，使cp指向表頭結(jié)點，使ap為空 */
    struct sNode *cp = *hl;
    struct sNode *ap = NULL;
    /* 從單鏈表中查找值為x的結(jié)點，找到后由cp指向該結(jié)點，由ap指向其前驅(qū)結(jié)點 */
    while(cp != NULL){
        if(cp->data == x){
            break;
        }
        ap = cp;
        cp = cp->next;
    }
    /* 若查找失敗，即該單鏈表中不存在值為x的結(jié)點，則返回0 */
    if(cp == NULL){
        return 0;
    }
    /* 假如刪除的是表頭或非表頭結(jié)點則分別進行處理 */
    if(ap == NULL){
        *hl = (*hl)->next;        /* 或改為*hl= cp->next */
    }else{
        ap->next = cp->next;
    }
    free(cp);        /* 回收被刪除的結(jié)點 */
    return 1;        /* 返回1表示刪除成功 */
}

/************************************************************************/

int main(int argc, char* argv[])
{
    int a[NN];
    int i;
    struct sNode *p, *h, *s;
    srand(time(NULL));
    initList(&p);
    for(i = 0; i < NN; i++){
        a[i] = rand() & MM;
    }
    printf("隨機數(shù)序列：");
    for(i = 0; i < NN; i++){
        printf("%5d", a[i]);
    }
    printf(" ");
    printf("隨機數(shù)逆序：");
    for(i = 0; i < NN; i++){
        insertFirstList(&p, a[i]);
    }
    traverseList(p);
    printf("單鏈表長度：%5d ", sizeList(p));
    for(h = p; h !
= NULL; h = h->next){
        while(deleteValueList(&(h->next), h->data)){
            ;
        }
    }
    printf("去除重復(fù)數(shù)：");
    traverseList(p);
    printf("單鏈表長度：%5d ", sizeList(p));
    h = NULL;
    for(s = p; s != NULL; s = s->next){
        insertOrderList(&h, s->data);
    }
    printf("有序表序列：");
    traverseList(h);
    clearList(&p);
    system("pause");
    return 0;
}
更多文章 更多內(nèi)容請看C/C++進階技術(shù)文檔  數(shù)據(jù)結(jié)構(gòu)  數(shù)據(jù)結(jié)構(gòu)相關(guān)文章專題，或

發(fā)表評論 共有條評論
用戶名: 密碼:
驗證碼: 匿名發(fā)表
主站蜘蛛池模板： 贺州市| 泉州市| 淅川县| 毕节市| 正安县| 红桥区| 永靖县| 靖州| 疏附县| 汤阴县| 太和县| 璧山县| 车致| 敦化市| 屏山县| 体育| 乐至县| 定安县| 闽侯县| 修水县| 静乐县| 祥云县| 普陀区| 广安市| 宜良县| 浦城县| 琼结县| 台东县| 呼和浩特市| 原阳县| 阜阳市| 满城县| 宁蒗| 扬州市| 钟山县| 皋兰县| 黑水县| 雅安市| 嘉祥县| 东阿县| 老河口市|