全球彩票平台_全球彩票注册平台|官网下载地址

热门关键词: 全球彩票平台,全球彩票注册平台,全球彩官网下载地址

顺序存储结构,为什么是以0作为输入结束的

线性表——顺序存储结构,线性存款和储蓄结构

一)声明

  新手上路。如果有不准绳的,不客观的地点,编码风格,算法思路有待革新的地方,还请各位大神多多教导。

二)简介  

  本文中央银行使动态开采内部存款和储蓄器的办法创建线性表,达成顺序表的基本操作。

  此代码思路相比较轻巧,毕竟只是简短的准则,未有具体的利用,仅仅看做入门学习的积淀。

三)具体贯彻解析如下:

 3.1)头文件定义如下:

全球彩票注册平台 1 1 #ifndef LinearList_SqList_h 2 #define LinearList_SqList_h 3 4 #include <stdio.h> 5 #include <stdlib.h> 6 7 #define OK 1 8 #define ERROR 0 9 10 #define LIST_INIT_SIZE 100 11 #define SIZE_INCREMENT 10 12 13 typedef int Status; 14 typedef int ElemType; 15 16 typedef struct { 17 ElemType *pElem; 18 int nLength; 19 int nListSize; 20 }SqList; 21 22 23 void InitSqList(SqList *L); 24 Status InsertSqList(SqList *L, int nIndex, ElemType eValue); 25 Status AssignSqList(SqList *L); 26 Status DeleteSqList(SqList *L, int nIndex, ElemType *pValue); 27 Status ClearSqList(SqList *L); 28 Status DestroySqList(SqList *L); 29 Status LocateElem(SqList L, ElemType nValue); 30 Status PrintSqList(SqList L); 31 32 #endif SqList.h

 3.2)具体完毕:

  3.2.1)基本条件:

    a)函数参数中,只要传递的是指针,函数内必需首先校验指针是不是为空。

    b)假若要对各样表展开改变,那么必须进行地址传递,而不是值传递。

    c)malloc申请的内部存款和储蓄器,必得求用free释放,何况释放之后,置指针为空,幸免出现也指针。

  3.2.2)具体代码思路:

  a、InitSqList

  动态申请空间,依此对顺序表的积极分子赋值。

 

  b、InsertSqList (此处允许对空表实行插队)

  思路:校验指针参数——》校验插入点——》校验顺序表是还是不是已初叶化——》校验顺序表是还是不是已满——》遍历顺序表,找到插入点——》移动成分——》插入——》相同的时候表长扩展;

  深入分析:其实确实的插入即是单排代码,但是为了保险插入后不影响另外因素的运用,必需移动成分;为了有限匡助程序的健壮性,必得扩展比比较多校验进程;

      入眼在于下标的测算。

    2.1参数校验:指针是还是不是为空;插入点是不是违规

    2.2相继表校验:顺序表是不是已初叶化;对于插入来说,顺序表是还是不是已满;

    2.3当有着的校验完成之后,寻觅正确插入点,移动成分(从表尾向待插入点方向遍历),最终插入,扩展表长;

    (2.4)关于空表是还是不是允许插入的标题:依照不一样的要求和机能设定。即使不允许对空表插入,能够多加一层校验效能就可以;(此处允许空表插入)

 

  c、DeleteSqList (基本原理类似于Insert)

   思路:校验指针参数——》校验删除点——》校验顺序表是或不是初步化——》校验顺序表是不是为空——》遍历顺序表,搜索删除点——》移动成分——》删除——》同不经常候表长自减;

    深入分析:删除成分就是绵绵的移位成分,采纳覆盖原理就可以(从删除点向表尾方向遍历)。关键是下标的测算。

 

  d、DestroySqList

    思路:校验指针参数——》校验顺序表是不是最早化——》释放申请的内部存款和储蓄器——》相同的时间设置顺序表相关参数。

    解析:重视在于参数的校验和free过后的指针应该置空。

 

  3.3)具体代码如下:

  

全球彩票注册平台 2 1 #include "SqList.h" 2 3 void InitSqList(SqList *L) { 4 if (NULL == L) { 5 printf("Error parament."); 6 return ; 7 } 8 9 L->pElem = (ElemType*)malloc(LIST_INIT_SIZE * sizeof(SqList)); 10 if (NULL == L->pElem) { 11 printf("Error:Out of memory."); 12 return ; 13 } 14 15 L->nLength = 0; 16 L->nListSize = LIST_INIT_SIZE; 17 } 18 19 20 //Insert element to sqlist 21 Status InsertSqList(SqList *L, int nIndex, ElemType eValue) { 22 if (NULL == L) { 23 printf("Error parament."); 24 return ERROR; 25 } 26 27 if (NULL == L->pElem) { 28 printf("Error: The list is not initiated."); 29 return ERROR; 30 } 31 32 if (nIndex < 1 || nIndex > L->nLength 1) { 33 printf("Error: Invalid insert point."); 34 return ERROR; 35 } 36 37 ElemType *pNewBase; 38 if (L->nLength >= L->nListSize) { 39 pNewBase = (ElemType*)realloc(L->pElem, (LIST_INIT_SIZE SIZE_INCREMENT) * sizeof(ElemType)); 40 if (NULL == pNewBase) { 41 printf("Error:Out of memory."); 42 return OK; 43 } 44 //here can also write with 'else'. 45 //Logically no problem. But it takes effort to write the else and '{}'. Efficiently not good choice 46 L->pElem = pNewBase; 47 L->nListSize = SIZE_INCREMENT; 48 } 49 50 ElemType *pInsert, *pLast; 51 pInsert = L->pElem nIndex - 1; 52 pLast = L->pElem L->nLength - 1; 53 54 55 while (pLast >= pInsert) { 56 *(pLast 1) = *pLast; 57 pLast--; 58 } 59 60 *pInsert = eValue; 61 L->nLength; 62 63 return OK; 64 } 65 66 //Assign sqlist 67 Status AssignSqList(SqList *L) { 68 if (NULL == L) { 69 printf("Error parament."); 70 return ERROR; 71 } 72 73 if (NULL == L->pElem) { 74 printf("Error:The list is not initiated."); 75 return ERROR; 76 } 77 78 int nLength, nValue; 79 printf("Input the length:"); 80 scanf("%d", &nLength); 81 82 for (int i = 1; i <= nLength; i ) { 83 printf("Input the value:"); 84 scanf("%d", &nValue); 85 86 InsertSqList(L, i, nValue); 87 } 88 89 return OK; 90 } 91 92 //delete element from sqlist 93 Status DeleteSqList(SqList *L, int nIndex, ElemType *pValue) { 94 if (NULL == L || NULL == pValue) { 95 printf("Error parament."); 96 return ERROR; 97 } 98 99 if (NULL == L->pElem) { 100 printf("Error:The list is not initiated."); 101 return ERROR; 102 } 103 104 if (L->nLength <= 0) { 105 printf("Error:The list is empty.Can't delete."); 106 return ERROR; 107 } 108 109 if (nIndex < 1 || nIndex > L->nLength) { 110 printf("Error:Invalid delete index."); 111 return ERROR; 112 } 113 114 ElemType *pDelete, *pLast; 115 pDelete = L->pElem nIndex - 1; 116 pLast = L->pElem L->nLength - 1; 117 118 *pValue = *pDelete; 119 for (pDelete ; pDelete <= pLast; pDelete ) { 120 *(pDelete - 1) = *pDelete; 121 } 122 123 --L->nLength; 124 125 return OK; 126 } 127 128 //clear sqlist 129 Status ClearSqList(SqList *L) { 130 if (NULL == L) { 131 printf("Error parament."); 132 return ERROR; 133 } 134 135 if (NULL == L->pElem) { 136 printf("Error: The list is not initiated."); 137 return ERROR; 138 } 139 140 L->nLength = 0; 141 142 return OK; 143 } 144 145 //destroy sqlist 146 Status DestroySqList(SqList *L) { 147 if (NULL == L) { 148 printf("Error parament."); 149 return ERROR; 150 } 151 152 if (NULL == L->pElem) { 153 printf("Error:The list is not initiated."); 154 return ERROR; 155 } 156 157 free(L->pElem); 158 L->pElem = NULL; 159 L->nLength = 0; 160 L->nListSize = 0; 161 162 return OK; 163 } 164 165 //locate element from sqlist 166 Status LocateElem(SqList L, ElemType nValue) { 167 if (NULL == L.pElem) { 168 printf("Error:The list is not initiated."); 169 return ERROR; 170 } 171 172 if (L.nLength <= 0) { 173 printf("Error:The list is empty."); 174 return ERROR; 175 } 176 177 int nIndex; 178 ElemType *pLocate = L.pElem; 179 180 for (nIndex = 1; nIndex <= L.nLength; nIndex ) { 181 if (nValue == *pLocate) { 182 printf("Located succeeded."); 183 return nIndex; 184 } 185 pLocate ; 186 } 187 188 return ERROR; 189 } 190 191 192 //Print sqlist 193 Status PrintSqList(SqList L) { 194 if (NULL == L.pElem) { 195 printf("Error:The list is not initiated."); 196 return ERROR; 197 } 198 199 if (L.nLength <= 0) { 200 printf("The list is empty."); 201 return ERROR; 202 } 203 204 printf("The list is as follows:"); 205 for (int i = 1; i <= L.nLength; i ) { 206 printf("%d ", *L.pElem); 207 L.pElem ; 208 } 209 210 printf("n"); 211 return OK; 212 } SqList.c

  

  

一)申明新手上路。假如有狼狈的,不客观的地点,编码风格,算法思路有待改善的地点,还请...

  数据结构-线性表  

数据结构。顺序表,数据结构顺序表

#include <stdio.h>
#include <stdlib.h>

#define LIST_INIT_SIZE 100
#define LIST_INCREMENT 10
typedef struct Point   //element type
{
    int x;
    int y;
}Point;
typedef Point ElemType;
typedef struct          //list type
{
    ElemType *elem;     //data
    int length;         //current length
    int listsize;       //maximum size
}Sqlist;
int cpy(ElemType *des,ElemType data)
{
    des->x=data.x;
    des->y=data.y;
    return 0;
}
int elem_cmp(ElemType data1,ElemType data2);
int list_init(Sqlist *mylist);
int list_insert(Sqlist *mylist,ElemType data);
int list_find(Sqlist *mylist,ElemType data);
int list_delete(Sqlist *mylist,ElemType data);
int list_disp(Sqlist mylist);
int main()
{
    Sqlist mylist;
    list_init(&mylist);
    printf("%d,%dn",mylist.length,mylist.listsize);
    printf("Hello world!n");

    Point tempt;
    tempt.x=11;
    tempt.y=12;

    list_insert(&mylist,tempt);
    list_disp(mylist);
    printf("%d,%dn",mylist.length,mylist.listsize);
    getchar();

    tempt.x=21;
    tempt.y=22;
    list_insert(&mylist,tempt);
    list_disp(mylist);
    printf("%d,%dn",mylist.length,mylist.listsize);
    getchar();

    list_delete(&mylist,tempt);
    list_disp(mylist);
    printf("%d,%dn",mylist.length,mylist.listsize);
    getchar();

    return 0;
}
int elem_cmp(ElemType data1,ElemType data2)
{
    if( (data1.x==data2.x) &&(data1.y==data2.y) )
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
int list_init(Sqlist *mylist)
{
    mylist->elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    if(mylist->elem!=NULL)
    {
        mylist->length=0;
        mylist->listsize=LIST_INIT_SIZE;

        printf("%d,%dn",mylist->length,mylist->listsize);
        return 0;
    }
    else
    {
        printf("allocate memory is failed! sorryn");
        return 1;
    }
}
int list_insert(Sqlist *mylist,ElemType data)
{
    if(mylist->length>=mylist->listsize)
    {
        //if the memo is not enougth to use,realloc
        mylist->elem=(ElemType*)realloc(mylist->elem,LIST_INIT_SIZE LIST_INCREMENT);
        if(mylist->elem==NULL)
        {
            printf("memo realloc is failed! sorry,friendn");
            return 1;
        }
        else
        {
            mylist->listsize =LIST_INCREMENT;
        }
    }
    cpy(&mylist->elem[mylist->length],data);
    mylist->length =1;
    return 0;
}
int list_find(Sqlist *mylist,ElemType data)
{
    int i=0;
    for(i=0;i<mylist->length;i )
    {
        if(elem_cmp(mylist->elem[i],data)>0)
        {
            return i 1;
        }
    }
    return 0;
}
int list_delete(Sqlist *mylist,ElemType data)
{
    int i=0,result=list_find(mylist,data);
    if(result==0)
    {
        printf("not found the data n");
        return 1;
    }
    else
    {
        for(i=result-1;i<mylist->length;i )
        {
            mylist->elem[i]=mylist->elem[i 1];
        }
        mylist->length--;
        return 0;
    }
}
int list_disp(Sqlist mylist)
{
    system("clear");
    int j=0;
    for(j=0;j<mylist.length;j )
    {
        printf("{%d,%d}t",mylist.elem[j]全球彩票注册平台,.x,mylist.elem[j].y);
    }
    return 0;
}

为何是以0作为输入完结的? 2C
void input(SqList &L)//输入数据
{
scanf("%d",L.elem);
while//elem是指针,加*后才是值
{
L.elem ;
L.length ;
scanf("%d",L.elem);
}
}
在那几个中为啥输入0代表截至?
那是任何代码:
#include
#include
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define TRUE 1;
#define FALSE 0;
#define OK 1;
#define ERROR 0;
#define INFEASIBLE -1;
#define OVERFLOW -2;
//Status 是函数的门类,其值是函数结果意况代码
typedef int Status;
using namespace std;
typedef int ElemType;
typedef struct//线性表的动态顺序存款和储蓄结构
{
ElemType *elem;
int length;
int listsize;

链表难点,这一句为什么是二级指针
#include "stdio.h"

1. 线性表:n个数据成分的不改变集中。

 

线性表是一种常用的数据结构。在事实上行使中,线性表都以以栈、队列、字符串、数组等特殊线性表的方式来利用的。由于那几个新鲜线性表都具备各自的性状,由此,驾驭那么些特殊线性表的特征,对于数据运算的可信赖性和拉长操作效能都以重要的。  线性表是二个线性结构,它是三个带有n≥0个结点的蝇头类别,对于内部的结点,有且独有两个最早结点未有前人但有叁个后继结点,有且只有壹个终端结点未有后继但有三个先行者结点,其余的结点都有且独有二个前任和几个后继结点。

特征:

1.集聚中必存在独一的一个“第一要素”;
2.集合中必存在独一的一个 “最终成分” ;
3.除结尾多少个要素之外,均有 独一的后继(后件);
4.除首先个要素之外,均有 独一的先驱(前件)。

Java中的List接口,正是线性表。ArrayList正是顺序线性表,LinkedList正是链表线性表。

 

数据结构顺序表

不知道这一个顺序能还是无法满足你的须求,该程序用顺序表方式,能促成删除线性表的因素,之后还是可今后线性表中插入成分,后附有运转状态图:
程序如下
#include<iostream>
using namespace std;
#include<malloc.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define OVERFLOW -1
#define OK 1
#define ERROR 0
typedef int Status;
typedef int ElemType;
typedef int KeyType;
typedef struct{
ElemType *elem;
KeyType *key;
int length;
int listsize;
}SqList;
typedef struct{
KeyType key;
}SElemType;
Status InitList (SqList &L){ /*概念一个线性表*/
int length1;
printf("请鲜明顺序表的长短:");
scanf("%d",&length1);
L.listsize=length1;
L.elem=(ElemType*)malloc(length1*sizeof(ElemType));
if(!L.elem){
printf("out of space");
exit(OVERFLOW);
}
L.length=0;
return OK;
}

Status Listinsert (SqList &L,int i, ElemType e){ /*在i成分的前头插入成分e*/
ElemType *p,*q,*newbase;
if(i<1||i>L.length 1){
return ERROR;
}
if(L.length>L.listsize)
{
newbase=(ElemType*)realloc(L.elem,(L.listsize LISTINCREMENT)*sizeof(ElemType));
if (newbase==NULL){
printf("out of space");
return (OVERFLOW);
}
L.listsize =LISTINCREMENT;
}
p=&( L.elem[i-1]);
for (q=&(L.elem[L.length-1]) ;q>=p;q--){
*(q 1)=*q;
}
L.elem[i-1]=e;
L.length ;

return OK;
}
Status DeleteList (SqList &L,int i){/*删除i个元素*/
ElemType *q ,*p;
if(i<1||i>L.length){
return ERROR;
}
q = &(L.elem[i-1]);
p = L......余下全文>>
全球彩票注册平台 3  

} SqList;
Status InitList_Sq(SqList &L)//初叶化线性表
{
//构造贰个空的线性表
L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof);
if
return OVERFLOW;
L.length=0;
L.listsize=LIST_INIT_SIZE;
return OK;

#include "string.h"
#include "ctype.h"

2. 线性表的次第表示:ArrayList

 

相似接纳数组(C语言中的数组接纳顺序存款和储蓄格局。即接二连三地址存款和储蓄)来说述。

可取:在于随机访谈成分,

瑕玷:插入和和删除的时候,要求活动多量的成分。

c语言达成代码:

 

[cpp] view plain copy

 

 print?

  1. // Test.cpp : Defines the entry point for the console application.  
  2. //  
  3.   
  4. #include "stdafx.h"  
  5. #include <stdio.h>  
  6. #include "stdlib.h"  
  7. //宏定义  
  8. #define TRUE   1  
  9. #define FALSE   0  
  10. #define OK    1  
  11. #define ERROR   0  
  12. #define INFEASIBLE -1  
  13. #define OVERFLOW -2  
  14.   
  15. #define LT(a,b)   ((a)<(b))  
  16. #define N = 100         
  17.   
  18. #define LIST_INIT_SIZE 100 //线性表开首空间分配量  
  19. #define LISTINCREMENT   10 //线性表空间分配的增量  
  20.   
  21. typedef int Status;  
  22. typedef int ElemType;  
  23.   
  24. typedef struct LNode{  
  25.     ElemType  *elem;        //存款和储蓄空间的大学本科营址  
  26.     int      lenght;        //当前的长短  
  27.     int      listsize;      //当前分红的蕴藏体量  
  28. }SqList;  
  29.   
  30. /** 
  31.  *结构空的线性表 
  32.  */  
  33.   
  34. Status initList(SqList &L, int lenght){  
  35.     if (lenght == 0) lenght = LIST_INIT_SIZE;  
  36.     L.elem = (ElemType *)malloc(lenght * sizeof(ElemType));  
  37.     if(!L.elem) exit(OVECR-VFLOW);  //分配存款和储蓄空间退步  
  38.     L.lenght = 0;                //伊始空表长度为0  
  39.     L.listsize = lenght ;//开头存款和储蓄体积为100  
  40.     return OK;  
  41. }  
  42. /************************************************************************/  
  43. /* 在第i地点插入e 
  44. */  
  45. /************************************************************************/  
  46. Status insertList(SqList &L, ElemType e, int i){  
  47.     ElemType *p,  *q;  
  48.     if(i<0 ||i > L.lenght) return ETucsonRO纳瓦拉;  //i值非法  
  49.     if (L.lenght >= L.listsize) {  
  50.         ElemType *newbase = (ElemType *)realloc(L.elem ,(L.listsize  LISTINCREMENT)*sizeof(ElemType));  
  51.         if(!newbase) return OVEEvoqueFLOW;   //存储分配失利    
  52.         L.elem = newbase;               //新基值  
  53.         L.listsize  = LISTINCREMENT;    //扩张存款和储蓄体积  
  54.     }  
  55.     q = &L.elem[i];                     //q为插入的职位  
  56.     for (p = &L.elem[L.lenght]; p>=q; --p) {  
  57.         *p = *(p-1);                    //i元素之后的因素未来移动  
  58.     }  
  59.     *q = e;                             //插入e  
  60.     L.lenght  =1;  
  61.     return OK;  
  62.   
  63. }  
  64. /************************************************************************/  
  65. /* 急迅排序  
  66. */  
  67. /************************************************************************/  
  68. void sortList(SqList &L){  
  69.       
  70.   
  71. }  
  72. /************************************************************************/  
  73. /* 删除第i职位成分,并用e重临其值                                                                     */  
  74. /************************************************************************/  
  75. Status deleteListElem(SqList &L, int i, ElemType &e){  
  76.     int *p,  *q;  
  77.     if(i<0 ||i > L.lenght) return E牧马人RO凯雷德;  //i值违法  
  78.     q = &L.elem[i];                       //被剔除元素的岗位为i,L.elem正是数组名,  
  79.     e = *q;                               //被去除成分的值赋值给e  
  80.     for (p = q; p< (L.elem   L.lenght); p ){ //成分左移  
  81.         *p = *(p 1);  
  82.     }  
  83.     --L.lenght;  
  84.     return OK;  
  85. }  
  86.   
  87. /************************************************************************/  
  88. /*  神速排序 
  89. */  
  90. /************************************************************************/  
  91.   
  92. int partition(SqList &L, ElemType low, ElemType high){  
  93.     ElemType pivotkey = L.elem[low];               //枢轴记录关键字  
  94.     while (low < high) {                  //从表的两端向中档扫描  
  95.         while (low < high &&  L.elem[high] >= pivotkey ) --high;//高档地方扫描  
  96.         L.elem[low] = L.elem[high];     //沟通数据,小于pivotkey移到低等  
  97.         L.elem[high] = pivotkey;  
  98.   
  99.         while (low < high && L.elem[low] <= pivotkey )  low;     //低级扫描  
  100.         L.elem[high] = L.elem[low];               //交换数据 大于pivotkey移到高档  
  101.         L.elem[low] = pivotkey;                                   
  102.     }  
  103.     return low;  
  104. }  
  105.   
  106. void quickSort(SqList &L, ElemType low, ElemType high){  
  107.     int pivot;  
  108.     if(low < high) {                                          
  109.         pivot =  partition(L,  low,  high);       
  110.         quickSort(L,  low,  pivot -1);          //低等子表排序  
  111.         quickSort(L,  pivot  1, high);          //高级子表排序  
  112.     }  
  113.       
  114. }  
  115.   
  116.   
  117. /************************************************************************/  
  118. /*  
  119. 合併多少个线性表 
  120. */  
  121. /************************************************************************/  
  122.   
  123. void mergeList(SqList La, SqList Lb,  SqList &Lc){  
  124.     ElemType *pa, *pb, *pc;  
  125.     Lc.listsize =  La.lenght   Lb.lenght;  
  126.     initList(Lc, Lc.listsize);          //初始化LCpc = Lc.elem;  
  127.     Lc.lenght = Lc.listsize;  
  128.     pc = Lc.elem;  
  129.     pa = La.elem;  
  130.     pb = Lb.elem;  
  131.     while (pa <= &La.elem[La.lenght -1] && pb <= &Lb.elem[Lb.lenght -1]){  
  132.         if (*pa <= *pb) *pc  = *pa ;  
  133.         else *pc  = *pb ;  
  134.     }  
  135.     while(pa <= &La.elem[La.lenght -1]) *pc  = *pa ; //插入La的剩余成分  
  136.     while(pb <= &Lb.elem[Lb.lenght -1]) *pc  = *pb ; //插入Lb的剩余成分  
  137.   
  138. }  
  139.   
  140. /************************************************************************/  
  141. /* 打印list 
  142. */  
  143. /************************************************************************/  
  144. void printList(SqList L){  
  145.     printf("当前值:");   
  146.     for (int i =0; i<L.lenght;i ) {  
  147.         printf("%d ", *(L.elem i)); // L.elem为首地址  
  148.     }   
  149.     printf("rn");   
  150. }  
  151.   
  152. void main()  
  153. {  
  154.     SqList La,Lb,Lc;  
  155.     ElemType e;  
  156.     int init,i;  
  157.     init = initList(La, LIST_INIT_SIZE);  
  158.     int data[6] = {5,3,6,2,7,4};  
  159.     for (i=0; i<6;i ) {  
  160.         insertList(La,  data[i],  i);  
  161.     }  
  162.     printf("LA:rn");   
  163.     printList(La);  
  164.     deleteListElem(La, 3, e );  
  165.     printList(La);  
  166.     insertList(La,  e,  3);  
  167.     printList(La);  
  168.   
  169.     //排序  
  170.     quickSort(La,0, La.lenght-1);  
  171.     printList(La);  
  172.   
  173.     printf("LB:rn");   
  174.     initList(Lb, LIST_INIT_SIZE);  
  175.     int Bdata[5] = {1,3,2,4,6};  
  176.     for (i=0; i<5;i ) {  
  177.         insertList(Lb,  Bdata[i],  i);  
  178.     }  
  179.     //排序  
  180.     quickSort(Lb,0, Lb.lenght-1);  
  181.     printList(Lb);  
  182.   
  183.     mergeList(La, Lb,  Lc);  
  184.     printList(Lc);  
  185.   
  186. }  

 

 

 

 

数据结构顺序表

#include<stdio.h>
#include<malloc.h> //头文件包罗命令

#define List_init_size 100 //符号常量的概念
#define Listincrement 100
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

typedef int Elemtype;//抽象数据类型elemtype具体化为int类型
typedef int Status;
typedef struct { //定义结构体
Elemtype *elem;
int length;
int listsize;
}Sqlist;
Status Initlist_sq(Sqlist *l) //函数(起先化顺序表)开首化战败则赶回-2
{
l->elem =(Elemtype*)malloc(sizeof(Elemtype));
if(!l->elem ) return(OVERFLOW);
l->length =0;
l->listsize =List_init_size;
return OK;
}

Status Creatlist_sq(Sqlist *l,int n) //开首化顺序表为包括n个成分的顺序表
{
int i;
printf("Input %d numbers:n",n);
for(i=0;i<n;i )
scanf("%d",&(l->elem [i]));
l->length =n;
return OK;
}

void Outputlist_sq(Sqlist *l) //函数(输出顺序表的成分)
{
int i;
for(i=0;i<l->length ;i )
{
printf("]",l->elem [i]);
if((i 1)%5==0)
printf("n");
}
printf("n");

}
void Destroylist_sq(Sqlist*l) //销毁顺序表l
{
free(l->elem );

}

Status Insertlist_sq(Sqlist*l,int i,Elemtype e) //在顺序表的第i个岗位前插入成分e
{
int j;
Elemtype *p;
if(i>l->length )
{
printf("输入数据违法!");
return (OVERFLOW);
}

if(l->length>=l->listsize )
{
Elemtype *p;
p=(Elemtype*)realloc(l->elem ,(List_init_size Listincrement)*sizeof(Elemtype));
if(p==0)
{ ......余下全文>>  

#include stdio.h #include stdlib.h #define LIST_INIT_SIZE 100 #define LIST_INCREMENT 10 typedef struct Point //element type { int x...

}
void input(SqList &L)//输入数据
{
scanf("%d",L.elem);
while//elem是指针,加*后才是值
{
L.elem ;
L.length ;
scanf("%d",L.elem);
}
}
void print(SqList &L)//输出数据
{
int i;
for(i=0;i {
printf("%d",*L.elem);
L.elem ;
}
}
Status ListInsert_Sq(SqList &L,int i,ElemType e)//进行插队操作
{
int *p;
int *q;
ElemType *newbase;
if(iL.length 1)
return ERROR;
if(L.length==L.listsize)
{
newbase=(ElemType )realloc(L.elem,
(L.listsize LISTINCREMENT)
sizeof);
if
return ERROR;
L.elem=newbase;
L.listsize =LISTINCREMENT;
}
/*q=&(L.elem[i-1]);
for(p=&(L.elem[L.length-1]);p>=q;--p)
*=*p;
*q=e;*/
for(int j=L.length;j>=i;j--)
L.elem[j]=L.elem[j-1];
L.elem[i-1]=e;
L.length;//表长加1
return OK;
}
int main()
{
SqList L;
int a[100];
int n,num;
if(InitList_Sq//进行三遍判别
{
L.elem=a;//将数组的首地址传递给elem
printf;
input;
}
L.elem=a;//用的进程中指针已经移动,因而须要归位,才方可从第三位用起
printf("输入的多少为:n");
print;
printf;
printf("输入须要插入的地方:n");
scanf("%d",&n);
printf("输入插入的数:n");
scanf("%d",&num);
L.elem=a;
if(ListInsert_Sq
{
printf("插入后的多少元组:n",L.length);
L.elem=a;
print;
}

#include "stdlib.h"

3. 线性表的链表表示LinkedList

貌似接纳链表来汇报。

 

亮点:对于新增删操作add和remove和造福。没有要求活动成分。

劣势:不便利随机访谈成分,LinkedList要运动指针

代码达成:

 

[cpp] view plain copy

 

 print?

  1. // Test.cpp : Defines the entry point for the console application.  
  2. //  
  3. #include "stdafx.h"  
  4. #include <stdio.h>  
  5. #include "stdlib.h"  
  6. //宏定义  
  7. #define TRUE   1  
  8. #define FALSE   0  
  9. #define OK    1  
  10. #define ERROR   0  
  11. #define INFEASIBLE -1  
  12. #define OVERFLOW -2  
  13.   
  14. #define LT(a,b)   ((a)<(b))  
  15. #define N = 100         
  16.   
  17. typedef int Status;  
  18. typedef int ElemType;  
  19.   
  20. typedef struct LNode{  
  21.     ElemType  data;               
  22.     struct LNode   *next;     
  23. }LNode, *LinkList;  
  24.   
  25. /************************************************************************/  
  26. /* 
  27. 伊始化链表 
  28. */  
  29. /************************************************************************/  
  30. Status initList(LinkList &L){  
  31.     /*单链表的伊始化*/  
  32.     L = (LinkList)malloc(sizeof(LNode));    //申请三个头节点  
  33.     if(!L) exit(OVE瑞鹰FLOW);          //申请空间失利    
  34.     L->next=NULL;                //营造三个带都节点的空链表  
  35.     return OK;  
  36.   
  37.     /*  
  38.     要求改动指针的指针,所以参数必须是引用或许是 *L: 
  39.     (*L) = (Lnode *)malloc(sizeof(Lnode)); 
  40.     (*L)->next=NULL; 
  41.     return 1;                                                                      
  42.     */  
  43.   
  44. }  
  45.   
  46. /************************************************************************/  
  47. /*      
  48. 开创链表 
  49. */  
  50. /************************************************************************/  
  51. void createList(LinkList L, int n){  
  52.     /*单链表的开首化*/  
  53.     if (!L) {  
  54.         initList(L);  
  55.     }  
  56.     ElemType data;  
  57.     LinkList p,q = L;  
  58.     printf("输入节点数据的个数%d:rn", n);  
  59.     for(int i = 0; i<n; i ) {  
  60.         p = (LinkList) malloc( sizeof(LNode)); //申请壹个新节点  
  61.         scanf("%d",&data);  
  62.         p->data = data;  
  63.         p->next = q->next;  
  64.         q->next = p;  
  65.         q = p;  
  66.     }  
  67. }  
  68. /************************************************************************/  
  69. /* 在第i地方插入e 
  70. */  
  71. /************************************************************************/  
  72. Status insertList(LinkList L, ElemType e, int i){  
  73.     LinkList s, p = L;  
  74.     int j = 0;  
  75.     while (p && j<i){                //寻找i节点  
  76.         p = p->next;  
  77.         j ;  
  78.     }  
  79.     if (!p ||j >i) return ERROR;  
  80.     s = (LinkList) malloc(sizeof(LNode));       //生成新节点  
  81.     s->data = e; s->next = p->next;            //插入L中  
  82.     p->next = s;  
  83.     return OK;  
  84.   
  85. }  
  86.   
  87. /************************************************************************/  
  88. /* 删除第i地点成分,并用e再次回到其值                                                                     */  
  89. /************************************************************************/  
  90. Status deleteListElem(LinkList L, int i, ElemType &e){  
  91.     LinkList p, q;  
  92.     int j = 0;  
  93.     p = L;  
  94.     while (p && j<i){  
  95.         p = p->next;  
  96.          j;  
  97.     }  
  98.     if (!p->next || j>i)  return ERAV4RO揽胜;   //删除的任务不对  
  99.     q  = p->next; p->next = q->next;  
  100.     e = q->data; free(q);            //释放节点  
  101.     return OK;  
  102. }  
  103.   
  104.   
  105. /************************************************************************/    
  106. /*  插入排序  
  107. */    
  108. /************************************************************************/    
  109.   
  110. void  InsertSort(LinkList L)  
  111. {  
  112.     LinkList  list;             /*为原链表剩下用于间接插入排序的节点头指针*/  
  113.     LinkList  node;             /*插入节点*/  
  114.     LinkList  p;          
  115.     LinkList  q;          
  116.   
  117.     list = L->next;              /*原链表剩下用于直接插入排序的节点链表*/  
  118.     L->next = NULL;              /*只满含贰个节点的链表的静止链表。*/  
  119.     while (list != NULL)   {    /*遍历剩下冬季的链表*/  
  120.         node = list, q = L;     
  121.         while (q && node->data > q->data  ) {  
  122.             p = q;  
  123.             q = q->next;  
  124.         }  
  125.           
  126.         if (q == L) {  /*插在率先个节点以前*/  
  127.             L = node;  
  128.         }  else {     /*p是q的前驱*/  
  129.             p->next = node;     
  130.         }  
  131.         list = list->next;  
  132.         node->next = q; /*达成插入动作*/  
  133.   
  134.     }  
  135. }  
  136.   
  137.   
  138.   
  139. /************************************************************************/  
  140. /*  
  141. 合并七个线性表 
  142. */  
  143. /************************************************************************/  
  144.   
  145. void mergeList(LinkList  &La, LinkList  &Lb,  LinkList &Lc){  
  146.     LinkList pa, pb, pc;  
  147.     pa  = La->next;  
  148.     pb  = Lb->next;  
  149.     Lc =  pc = La;  
  150.     while (pa && pa) {  
  151.         if (pa->data > pb->data) {  
  152.             pc->next = pb;  
  153.             pc = pb;  
  154.             pb =pb->next;  
  155.         }else{  
  156.             pc->next = pa;  
  157.             pc = pa;   
  158.             pa =pa->next;  
  159.         }  
  160.     }  
  161.     pc->next = pa? pa :pb;  
  162.     free(Lb);  
  163. }  
  164.   
  165. /************************************************************************/  
  166. /* 打印list 
  167. */  
  168. /************************************************************************/  
  169. void printList(LinkList  L){  
  170.     printf("当前值:");  
  171.     LinkList p;  
  172.     p = L->next;  
  173.     while(p){  
  174.         printf("%d ", p->data);   
  175.         p = p->next;  
  176.     }  
  177.     printf("rn");   
  178. }  
  179.   
  180. void main()  
  181. {  
  182.     LinkList  La,Lb,Lc;  
  183.     ElemType e;  
  184.     int init,i;  
  185.     printf("LA:rn");    
  186.     initList(La);  
  187.     createList(La, 5);  
  188.     insertList(La, 7,  3);    
  189.     printList(La);  
  190.     deleteListElem(La, 3,  e);    
  191.     printList(La);  
  192.     InsertSort(La);  
  193.     printList(La);  
  194.   
  195.     printf("Lb:rn");    
  196.     initList(Lb);  
  197.     createList(Lb, 4);  
  198.     InsertSort(Lb);  
  199.     printList(Lb);  
  200.   
  201.     printf("Lc:rn");   
  202.     initList(Lc);  
  203.     mergeList(La,   Lb,   Lc);  
  204.     printList(Lc);  
  205.   
  206. }   

}

#include "io.h"

#include "math.h"

#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存款和储蓄空间开头分配量 */

本文由全球彩票平台发布于全球彩票注册平台编程,转载请注明出处:顺序存储结构,为什么是以0作为输入结束的

TAG标签: 全球彩票平台
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。