数据结构-线性表（严书代码实现）

数据结构-线性表的顺序表示代码

//头文件内容实现
#ifndef SEQLIST_H_INCLUDED
#define SEQLIST_H_INCLUDED
#include<string.h>
#include<ctype.h>
#include<malloc.h>
#include<limits.h>
#include<stdio.h>
#include<stdlib.h>
#include<io.h>
#include<math.h>
#include<sys/timeb.h>
#include<stdarg.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
typedef int Status;
typedef int Boolean;
#define LIST_INIT_SIZE 10
#define LIST_INCREMENT 2
typedef int ElemType;
struct SqList
{
  ElemType *elem;
  int length;
  int listsize;
};

void InitList(SqList &L)
{
  L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
  if(!L.elem)
    exit(OVERFLOW);
  L.length=0;
  L.listsize=LIST_INIT_SIZE;
}
void DestroyList(SqList &L)
{
  free(L.elem);
  L.elem=NULL;
  L.length=0;
  L.listsize=0;
}
void ClearList(SqList &L)
{
  L.length=0;
}
Status ListEmpty(SqList L)
{

  if(L.length==0)
    return TRUE;
  else
    return FALSE;
}
int ListLength(SqList L)
{
  return L.length;
}
Status GetElem(SqList L, int i, ElemType &e)
{

  if(i<1 || i>L.length)
    return ERROR;
  e=*(L.elem+i-1);
  return OK;
}
int LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType))
{


  int i=1;
  ElemType *p=L.elem;
  while(i<=L.length && !compare(*p++, e))
    i++;
  if(i<=L.length)
    return i;
  else
    return 0;
}
Status PriorElem(SqList L, ElemType cur_e, ElemType &pre_e)
{


  int i=2;
  ElemType *p=L.elem+1;
  while(i<=L.length && *p!=cur_e)
  { p++;
    i++;
  }
  if(i>L.length)
    return ERROR;
  else
  { pre_e=*--p;
    return OK;
  }
}
Status NextElem(SqList L, ElemType cur_e, ElemType &next_e)
{


  int i=1;
  ElemType *p=L.elem;
  while(i<L.length && *p!=cur_e)
  { p++;
    i++;
  }
  if(i==L.length)
    return ERROR;
  else
  { next_e=*++p;
    return OK;
  }
}
Status ListInsert(SqList &L, int i, ElemType e)
{

  ElemType *newbase, *q, *p;
  if(i<1 || i>L.length+1)
    return ERROR;
  if(L.length==L.listsize)
  { 
    newbase=(ElemType*)realloc(L.elem, (L.listsize+LIST_INCREMENT)*
    sizeof(ElemType));
    if(!newbase)
      exit(OVERFLOW);
    L.elem=newbase;
    L.listsize+=LIST_INCREMENT;
  }
  q=L.elem+i-1;
  for(p=L.elem+L.length-1; p>=q; --p)
    *(p+1)=*p;
  *q=e;
  L.length++;
  return OK;
}
Status ListDelete(SqList &L, int i, ElemType &e)
{

  ElemType *p, *q;
  if(i<1 || i>L.length)
    return ERROR;
  p=L.elem+i-1;
  e=*p;
  q=L.elem+L.length-1;
  for(p++; p<=q; p++)
    *(p-1)=*p;
  L.length--;
  return OK;
}
void ListTraverse(SqList L, void(*visit)(ElemType&))
{
  ElemType *p=L.elem;
  for(int i=1; i<=L.length; i++)
    visit(*p++);
  printf("\n");
}

Status equal(ElemType c1, ElemType c2)
{
  if(c1==c2)
    return TRUE;
  else
    return FALSE;
}
int comp(ElemType a, ElemType b)
{
  if(a==b)
    return 0;
  else
    return (a-b)/abs(a-b);
}
void print(ElemType c)
{
  printf("%d ", c);
}
void print1(ElemType &c)
{
  printf("%d ", c);
}
void print2(ElemType c)
{
  printf("%c ", c);
}
#endif // SEQLIST_H_INCLUDED

#include <iostream>
#include "SeqList.h"
Status sq(ElemType c1, ElemType c2)
{
        if (c1 == c2 * c2)
                return TRUE;
        else
                return FALSE;
}
void dbl(ElemType &c)
{
        c *= 2;
}
/**
 * @brief 算法思想
 * 搜索整个顺序表，查找最小值元素并记住其位置，搜索结束后用最后一个元素补空出的原最小值的位置
 * @param L 
 * @return Status 
 */
Status Del_Min(SqList &L)
{
        if (L.length == 0)
        {
                printf("this is a Null List");
                return TRUE;
        }
        if (L.length == 1)
        {
                L.length--;
                printf("delete after is null list");
        }
        int min = *L.elem;
        int minlo = 0;
        for (int i = 1; i < L.length; i++)
        {

                if (*(L.elem + i) < min)
                {
                        min = *(L.elem + i);
                        minlo = i;
                }
        }
        *(L.elem + minlo) = *(L.elem + L.length-1);
        L.length--;
        return TRUE;
}
//逆置
void Reverse(SqList &L){
        int temp;
        for (int i = 0; i < L.length/2; i++)
        {
                temp = *(L.elem+i);
                *(L.elem+i) = *(L.elem+L.length-1-i);
                *(L.elem+L.length-1-i) = temp;
        }
        
        
}
//循环左移,算法设计思想，设计一个临时SqList链表，首先计算每个数据元素在移位后的位置，将其装入临时线性表，最后将临时线性表与传入表指针统一
void LeftMove(SqList &L,int p){
        SqList LTemp;
        InitList(LTemp);
        LTemp.length = L.length;
        int temp;
        for (int i = 0; i < L.length; i++)
        {
                if (i<p)
                {
                        *(LTemp.elem+L.length+i-p) = *(L.elem+i);

                }else{
                        *(LTemp.elem+i-p) = *(L.elem+i);
                }
                
        }
        L = LTemp;
        
}
/**
 * @brief 
 * 算法的基本设计思想
 * 分别求两个升序序列A、B的中位数，设为a和b，求序列A、B的中位数过程如下：
 * 1.若a=b，则a或b即为所求中位数，算法结束
 * 2.若a<b，则舍弃序列A中较小的一半，同时舍弃序列B中较大的一半，要求舍弃的长度相等
 * 3.若a>b，则舍弃序列A中较大的一半，同时舍弃序列B中较小的一半，要求舍弃的长度相等。
 * @param A 
 * @param B 
 * @param n 
 * @return int 
 */
int M_Search(int A[],int B[],int n){
        int s1 = 0,d1 = n-1,m1,s2 = 0,d2 = n-1,m2;
        //分别表示序列A和B的首位数、末位数和中位数
        while (s1!=d1||s2!=d2)
        {
                m1 = (s1+d1)/2;
                m2 = (s2+d2)/2;
                if (A[m1]==B[m2])
                {
                        return A[m1];
                }
                if (A[m1]<B[m2])
                {
                        if ((s1+d1)%2 == 0)
                        {
                                s1 = m1;
                                d2 = m2;
                        }
                        else{
                                s1 = m1 + 1;
                                d2 = m2;
                        }
                        
                }else{
                        if ((s2+d2)%2 == 0)
                        {
                                d1 = m1;
                                s2 = m2;
                        }else{
                                d1 = m1;
                                s2 = m2+1;
                        }
                        
                }
                
                
        }
        return A[s1]<B[s2]?A[s1]:B[s2];
}

int Majority(int A[],int n){
        int i,c,count = 1;
        c = A[0];
        for (int i = 1; i < n; i++)
        {
                if (A[i]==c)
                {
                        count ++;
                }else{
                        if (count>0)
                        {
                                count--;
                        }else{
                                c = A[i];
                                count = 1;
                        }
                        
                }   
        }
        if (count>0)
        {
                for ( count=i = 0; i < n; i++)
                {
                        if (A[i]==c)
                        {
                                count++;
                        }
                        
                }
                
        }
        if (count>n/2)
        {
                return c;
        }else
                return -1;
}
int findMissMin(int A[],int n){
        int i,*B;
        B = (int *)malloc(sizeof(int)*n);
        memset(B,0,sizeof(int)*n);
        for ( i = 0; i < n; i++)
        {
                if (A[i]>0&&A[i]<=n)
                {
                        B[A[i]-1] = 1;
                }
        }
        for ( i = 0; i < n; i++)
        {
                if(B[i]==0) break;
        }
        return i + 1;
        
        
}
#define INT_MAX 0x7fffffff;
int abs_(int a){
        if (a<0)
        {
                return -a; 
        }else
                return a;
        
}
bool xls_min(int a,int b,int c){
        if (a<=b&&a<=c)
        {
                return true;
        }return false;
        
}
int findMinofTrip(int A[],int n,int B[],int m,int C[],int p){
        int i = 0,j = 0,k = 0,D_min=INT_MAX;
        int D;
        while(i<n&&j<m&&k<p&&D_min>0){
                D=abs_(A[i]-B[j])+abs_(B[j]-C[k])+abs_(C[k]-A[i]);
                if (D<D_min)
                {
                        /* code */
                        D_min = D;
                }
                if (xls_min(A[i],B[j],C[k]))
                {
                        i++;
                }
                else if (xls_min(B[j],C[k],A[i]))
                {
                        j++;
                }
                else k++;
                        
                
                
                
        }
        return D_min;
}
int main()
{
        SqList L;
        ElemType e, e0;
        Status i,j;
        InitList(L);

        for (j = 1; j <= 5; j++)
                i = ListInsert(L, 1, j);
        for (int i = 0; i < L.length; i++)
        {
                printf("this List ele is %d\n",*(L.elem+i));
        }
        /**
         * @brief Construct a new Del_Min object
         * 删除最小元素测试
        Del_Min(L);
         */
        //Reverse(L);
        //LeftMove(L,1);
        int a[] = {1,5,5,5,9};
        int b[] = {2,4,6,8,100};
        //int M_S = M_Search(a,b,5);
        int maj = Majority(a,5);
        printf("shtisi is a maj%d\n",maj);
        return 0;
}

此为高一凡书代码，由于代码没有分化，此为分化代码。自行分割实现。后续代码看后续博客内容即可。