数据结构顺序表与链表

顺序表：

是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将
表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

1、静态分配方式

#include <stdio.h>
#define MaxSize 10     //定义最大长度
 
typedef struct{
    int data[MaxSize];    //存放数据元素 
    int length;    //当前长度 
}SqList;    //顺序表的类型定义 
 
 
void InitList(SqList &L){
    for(int i=0; i<MaxSize; i++)
        L.data[i]=0; //初始化为0 
    L.length=0; //初始长度为0 
}
 
 
int main(){
    SqList L;
    InitList(L);
    
    for(int i=0; i<MaxSize; i++)
        printf("%d ", L.data[i]);
    
    printf("length=%d", L.length);
    
    return 0;
}

动态分布方式

#include <stdio.h>
#include <stdlib.h>
#define InitSize 10 //默认最大长度
 
typedef struct{
    int *data;    //指示动态分配数组的指针 
    int MaxSize; //最大容量 
    int length; //顺序表的当前长度 
}SeqList; 
 
d InitList(SeqList &L){
    //用 malloc 函数申请一片连续的存储空间 
    L.data=(int *)malloc(InitSize*sizeof(int));
    L.length=0;
    L.MaxSize=InitSize;
    
    for(int i=0; i<InitSize; i++)
        L.data[i]=0; //初始化为0 
}
 
void IncreaseSize(SeqList &L, int len){
    int *p=L.data;
    L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));
    
    for(int i=0; i<L.length; i++){
        L.data[i]=p[i];    //将数据复制到新区域 
    }
    
    L.MaxSize=L.MaxSize+len; //扩大长度 
    free(p); //释放原来的内存空间 
} 
 
int main(){
    SeqList L;
    InitList(L);
    
    for(int i=0; i<L.MaxSize; i++)
        printf("%d ", L.data[i]);
    printf("\n原来size=%d", L.MaxSize);
    
    IncreaseSize(L, 5);
    printf("\n当前size=%d\n", L.MaxSize);
    
    return 0;
}
 

查找

#include<stdio.h>
int Search_seq(int R[],int length,int key)
{
    int i;
    R[0]=key; //哨兵 
    for(i=length-1;R[i]!=key;--i);//找不到时i为0,否则R[i]就是要找的结点； 
    return i; //查找成功，返回元素下标。反之查找失败，返回0； 
}
 
int main()
{
    int R[11]={0,13,29,18,27,6,15,34,33,2,1}; //表长度为11； 
    int k=Search_seq(R,11,27);
    
    printf("%d ",k); //输出对应的下标数 
    getchar(); //读入函数 
}

插入与删除

#include <stdio.h>
#include <stdlib.h>
int main() 
{
    int X;   
    int i=0,Y; 
    int a[11]={3,5,7,9,12,23,45,56,77,89};
    printf("原线性表为:\n");   
    for(i=0;i<10;i++)     
    {
        printf("%d ",a[i]);
    } 
    printf("\n");
    printf("输入插入数据X:");    
    scanf("%d",&X);
    int j;
    for(i=0;i<10;i++)   
    {
        if(X<a[i])        
        {
            for(j=9;j>=i;j--)                
            {
                a[j+1]=a[j];
            }
            a[i]=X;
            break;
        }
        else a[10]=X;
    }         
    printf("\n");
    printf("插入后的线性表为:");
    for(i=0;i<11;i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
    printf("输入需要删除的数据的下标Y:");
    scanf("%d",&Y);
    if(Y<=10)
    {
        for(i=0;i<11 ;i++)   
        {
            if(Y<10)        
            {
                for(j=Y+1;j<11;j++)                
                {
                    a[j-1]=a[j];
                }
                break;   
            }  
        }
        printf("\n");
        printf("删除后的线性表为:");    
        for(i=0;i<10;i++)
        {
            printf("%d ",a[i]);
        }
    }
    else printf("Error\n\n");
}

 链表

链表，别名 链式存储结构 或 单链表 ，用于存储逻辑关系为 "一对一" 的数据。 与 顺序表 不同，链表不限制数据的物理存储状态，换句话说，使用链表存储的数据元素，其物理存储位置是随机的。

插入：

按位序插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, ElemType e)
{
    if(i<1)  //插入的位序不合法 
        return false;
    LNode *p;  //指针p指向当前扫描到的结点
    int j=0;  //当前p指向的是第几个结点
    p = L;   //L指向头结点，头结点是第0个结点（不存数据）
    while(p!=NULL && j<i-1){  //循环找到第i-1个结点，方便在后面插入结点 
        p=p->next;
        j++;
    } 
    if(p==NULL) //i值不合法
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode)); 
    s->data = e;
    s->next = p->next;
    p->next = s;   //将结点s连到p之后
    
    return true;   //插入成功 
} 

删除：

按位序删除
bool ListDelete(LinkList &L, int i, ElemType &e)
{
    if(i<1)
        return false;
    LNode *p;  //临时结点，用来指向当前扫描到的结点
    int j=0;  //当前p指向的第j个结点
    p = L; //L指向头结点，即第0个结点(不存数据)
    while(p!=NULL && j<i-1){ //循环找到第i-1个结点 
        p=p->next;
        j++;
    } 
    if(p==NULL) //i值不合法
        return false;
    if(p->next == NULL) //在第i-1个结点后已无其他结点
        return false;  
    LNode *q=p->next;  //令q指向被删除结点 
    e = q->data;    //用e返回元素的值 
    p->next = q->next;  //将*q结点从链中断开
    free(q);   //释放被删除结点的内存空间 
    
    return true; 
 } 

查找

按位序查找元素 
1、LNode* GetElem(LinkList L, int i)
{
    int j=1;
    LNode *p = L->next;
    if(i==0)
        return L;
    if(i<1)
        return NULL;
    while(p!=NULL && j<i)
    {
        p=p->next;
        j++;
    }
    
    return p;
} 
 
2、按值查找位置
LNode * LocateElem(LinkList L, ElemType e)
{
    LNode *p = L->next;
    while(p != NULL && p->data != e)
        p = p->next;
    
    return p;  //要么找到该节点并返回，要么没找大返回NULL值 
}