线性表 顺序链式实现

线性表 顺序存储实现

（1）如何存储

//如何存储
typedef struct
{
    ElementType Data[MAXSIZE];
    int Last;
}List;
List L, *PtrL;

访问下标为i的元素：L.Data[i] 或 PtrL->Data[i]

线性表的长度：L.Last+1 或者 PtrL->Last+1

（2）初始化（建立空的顺序表）

List *MakeEmpty()
{
    List *PtrL;
    PtrL = (List *)malloc(sizeof(List));
    PtrL->Last = -1;
    return PtrL;
}

（3）查找

int Find(ElementType X, List *PtrL)
{
    int i = 0;
    while(i<=PtrL->Last && PtrL->Data[i]!=X)
        i++;
    if (i > PtrL->Last)
        return -1;
    else
        return i;
}

查找成功的平均比较次数为（n+1）/ 2（第一次比较就找到或者最后一次比较才找到），平均时间性能为O（n）。

（4）插入

插入到第 i 个位置（即下标+1：1<=i<=n+1）上插入一个值为X的新元素）

//插入
void Insert(ElementType X, int i, List *PtrL){
    if (PtrL->Last == MAXSIZE-1){
        printf("表满");
        return;
    }
    if (i < 1 || PtrL->Last+2){
        printf("位置不合法");
        return;
    }
    for (int j = PtrL->Last; j >= i-1; --j){
        PtrL->Data[j+1] = PtrL->Data[j]; //将 an~a1 依次向后移动一位
    }  
    PtrL->Data[i-1] = X;//插入新元素
    PtrL->Last++; //Last仍指向最后元素
return;
}

平均移动次数为n/2，平均时间性能为O(n)。

（5）删除

//删除
void Delete(int i, List *PtrL){
    if (i < 1 || i > PtrL->Last+1){
        printf("不存在第 %d 个元素", i );
        return；
    }
    for (j = i; j <= PtrL->Last; ++j){
        PtrL->Data[j-1] = PtrL->Data[j]; //将ai+1~an顺序向前移动
    }
    PtrL->Last--;
    return;
}

平均移动次数为(n-1)/2，平均时间性能为O(n)。

线性表 链式存储实现

基本操作

Node* applyNode();   //分配节点
Node* addNodeH(Node* Head,Node* InsertNode);       //在头部添加节点
Node* addNodeT(Node* Head,Node* InsertNode);       //在尾部添加节点
Node* addNodeSort(Node* Head, Node* InsertNode);   //以升序方式添加节点

Node* createList(int n,int choose);   //构造链表
void printList(Node*Head);            //打印链表
void freeList(Node*& Head);           //释放链表
int numOfNodes(Node* Head);           //求表长（节点数）

Node* locateNodeI(Node*Head,int i);   //定位
int SearchList(Node*Head,int value);    //查找
bool insertNodeI(Node* Head, int i);     //插入
bool deleteNodeI(Node*&Head,int i);   //删除
void sortList(Node*& Head);              //排序

1、构造节点

//定义节点类型

struct Node{
    int value;
    Node*next;
};

2、分配节点

//将分配内存和初始化该节点放在一个函数中
Node* applyNode(){
  Node* newNode;
  if( ( newNode = (Node*)malloc(sizeof(Node)) )==NULL ){
    cout << "分配内存失败!" << endl;
    exit(0);
  }
  cin >> newNode->value;
  newNode->next = NULL;
  return newNode;
}

3、在头部添加节点

Node* addNodeH(Node* Head){  
   Node* InsertNode = applyNode();
   if(Head==NULL)
      Head = InsertNode;
   else{
      InsertNode->next = NULL;
      Head->next = InsertNode;
   }
   return Head;
}

4、在尾部添加节点

Node* addNodeT(Node* Head){
   Node* InsertNode = applyNode();
   if(Head==NULL)
      Head=InsertNode;
   else{
      Node* p=Head;
      while(p->next!=NULL)
         p=p->next;
      p->next = InsertNode;
   }
   return Head;
}

5、以升序方式添加节点

Node* addNodeSort(Node* Head){
   Node* InsertNode = applyNode(); //分配节点
   if(Head==NULL){
      Head=InsertNode;
   }
   else{
      Node* p=Head;
      while( (p->value)<(InsertNode->value) && p->next!=NULL )
         p=p->next;
      if( (p->value)>=(InsertNode->value)){
         InsertNode->next = p->next; //先在p后增加节点
         p->next = InsertNode;
         swap(p->value, InsertNode->value); //再交换p和InsertNode的value值
      }
      else{   //因为（p->next==NULL）而退出循环！表示在尾部增加节点
         p->next = InsertNode;
      }
   }
   return Head;
}

6、构造链表

//建立n个节点的链表
//choose=0：在表头加入；  choose=1：在表尾加入；  choose=2：按value值升序加入
Node* createList(int n, int choose){
   Node *Head=NULL, *p=NULL;
   for(int i=0; i<n; i++){
        p = applyNode(); //分配节点
        cin >> choose;
        switch(choose){
        case 0:
             Head = addNodeH(Head, p); //头插
             break;
        case 1:
             Head = addNodeT(Head, p); //尾插
             break;
        case 2:
             Head = addNodeSort(Head, p); //升序插
             break;
        default:
             printf("default");
             break;
   }
   return Head;
}

7、打印链表

//遍历链表并输出
void printList(Node* Head){
   Node* p=Head;
   while(p!=NULL){
      cout << p->value << "->";
      p=p->next;
   }
   cout << "NULL" << endl;
}

8、释放链表

void freeList(Node* Head){
   Node* tmp=Head;
   while(tmp!=NULL){
      Head = Head->next;
      free(tmp);
      tmp = Head;
   }
   Head=NULL; 
}

9、求表长（节点数）

//求节点个数
int numOfNodes(Node* Head){     
   Node* temp = Head;
   int count=0;
   while(temp!=NULL){
      count++;
      temp=temp->next;
   }
   return count;
}

10、定位

//定位（指向）第i个节点，i从1开始
Node* locateNodeI(Node* Head, int i){
   Node* pos=NULL;
   int count = numOfNodes(Head);
   if(i<=0 || i>count){
      cout << "定位越界！" << endl;
   }
   else {
      pos=Head;
      for(int j=1; j<i; j++)
          pos=pos->next;
   }
   return pos;
}

11、查找

1）按照序号查找：FindKth

List *FindKth(int K, List *PtrL){
    List *p = PtrL;
    int i = 1;
    while(p!=NULL && i< k){
        p = p->Next;
        i++;
    }
    if (i==k)
        return p; //找到第K个，返回指针
    else
        return NULL;
}

2）按照值查找：Find

List *Find(ElementType X, List *PtrL){
    List *p = PtrL;
    while(p!=NULL && p->Data!=X)
        p = p->Next;
    return p;
}

3）按照值查找，返回其序号：SearchList

//查找值value并返回第一个出现该值的位置
//如果需要引用其指针，可以再locate该位置
int SearchList(Node* Head, int value){
   Node* p=Head;
   int pos=0;
   bool find=false;
   while(p!=NULL){
      pos++;
      if(p->value==value){
         find=true;
         break;
      }
      p=p->next;
   }
   if(find)
      return pos;
   else 
      return -1;
}

12、插入

//新节点插入到某位置i
bool insertNodeI(Node* Head, int i){
   Node* s = applyNode();
   if(i==1){   //新节点插入在表头
      s->next = Head;
      Head = s;
      return true;
   }
   Node* p = locateNodeI(Head, i-1);
   if(p==NULL){
      return false;
   }
   else{
      s->next = p->next;
      p->next = s;
      return true;
   }
}

13、删 除

//删除某位置i的节点
bool deleteNodeI(Node* Head, int i){
   Node* s = locateNodeI(Head, i);
   if(s==NULL){
      return false;
   }
   else{
      if(s==Head){   //要删除的是头节点
         Head = s->next;
         free(s);
      }
      else{
         Node* p = locateNodeI(Head, i-1); //定位前一个节点，必定存在
         p->next = s->next;
         free(s);
      }
      return true;
   }
}

14、排序

//链表排序
//方法：只进行value的交换，不破坏链表结构
void sortList(Node* Head){
   int count = numOfNodes(Head);
   if(count==0 || count==1)
      return ;
   //冒泡排序
   bool exchange;
   for(int i=2; i<=count; i++){   
      exchange=false;
      for(int j=count;j>=i; j--){
         Node* p1 = locateNodeI(Head, j);
         Node* p2 = locateNodeI(Head, j-1);
         if(p1->value < p2->value){
            exchange=true;
            swap(p1->value, p2->value); //交换数据
         }
      }
      if(!exchange)
         break;
   }
}