精华内容
下载资源
问答
  • 静态查找表算法

    千次阅读 2019-05-30 11:50:45
    算法2:采用顺序存储结构创建静态查找表——有序表,对有序表进行二分查找; #include <stdio.h> #include <stdlib.h> typedef int KeyType; //typedef float KeyType //typedef char...

    算法1:采用顺序存储结构创建静态查找表,对查找表进行顺序查找和改进的顺序查找,并对其查找效率进行比较;
    算法2:采用顺序存储结构创建静态查找表——有序表,对有序表进行二分查找;

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef int KeyType;
    //typedef float KeyType
    //typedef char *KeyType
    
    //对数值型关键字的比较宏定义
    #define EQ(a,b) ((a)==(b))
    #define LT(a,b) ((a)<(b))
    #define LQ(a,b) ((a)<=(b))
    
    //数据元素类型定义 
    typedef struct{
     KeyType key;//关键字域
     //...       //其他域 
    }ElemType;
    typedef struct{
     ElemType *elem;//数据元素存储空间基址,建表时按实际长度分配,0号单元留空
     int length;//表的长度 
    }SSTable;
    
    int Create(SSTable *ST)
    {//创建静态表
     int i,n;
     printf("请输入你要创建的表的长度:\n");
     scanf("%d",&n);
     ST->elem =(ElemType *)malloc((n+1)*sizeof(ElemType));
     if(!ST->elem )
     return 0;
     printf("请输入%d个数据(若采用二分法查找关键字,则顺序输入)。\n",n);
     for(i=1;i<=n;i++)
     {
      scanf("%d",&ST->elem [i].key);
     }
     ST->length =n;
     return 1;
     } 
    
    int Search_Seq(SSTable ST,KeyType key)
    {//在顺序表ST中顺序查找其关键字等于key的数据元素,
     //若找到,咋返回它在表中的位置,否则返回0.
     int i=1;
     while(i<=ST.length &&!EQ(ST.elem [i].key,key))
     ++i;
     if(i<=ST.length )
     return i;
     else
     return 0; 
    }
    
    int Search_SSeq(SSTable ST,KeyType key)
    {//改进算法。在顺序表ST中顺序查找其关键字等于key的数
     //据元素,若找到,则返回它在表中的位置,否则返回0.
     int i;
     ST.elem [0].key=key;//哨兵
     for(i=ST.length ;!EQ(ST.elem [i].key,key);--i);//从后往前找
     return i;//返回找到元素在表中的位置i,找不到时,i为0 
    }
    
    int Search_Bin(SSTable ST,KeyType key)
    {//在有序表ST中折半查找其关键字等于key的数据元素。
    //若找到,则函数值为该元素在表中的位置,否则为0.
     int low=1;
     int high=ST.length ;//置区间初值
     while(low<=high){
      int mid=(low+high)/2;
      if(EQ(key,ST.elem [mid].key))
      return mid;//找到待查元素
      else if(LT(key,ST.elem [mid].key))
      high=mid-1;//继续在前半区间进行查找
      else low=mid+1;//继续在后半区间进行查找 
     } 
     } 
    
     int main()
     {
      int i,time;
      SSTable ST;
      KeyType key;
      printf("请输入创建表的类型(0.无序表,1.有序表):\n");
      scanf("%d",&time);
      Create(&ST); 
      printf("创建成功!\n");
      printf("请输入需查找的关键字:\n");
      scanf("%d",&key);
      if(time==0)
      {
       printf("顺序查找关键字结果为:\n");
       i=Search_Seq(ST,key);
       if(i==0)
       {
        printf("查找失败,表中无此元素\n");
       }
       else
       {
        printf("查找成功!\n");
        printf("位置是%d\n",i);
       }
       printf("改进算法顺序查找关键字结果为:\n");
       i=Search_SSeq(ST,key);
       if(i==0)
       {
        printf("查找失败,表中无此元素\n");
       }
       else
       {
        printf("查找成功!\n");
        printf("位置是%d\n",i);
       }
      }
      else
      {
      printf("二分查找关键字结果为:\n");
       i=Search_Bin(ST,key);
       if(i==0)
       {
        printf("查找失败,表中无此元素\n");
       }
       else
       {
        printf("查找成功!\n");
        printf("位置是%d\n",i);
       } 
      }
     }
    展开全文
  • 算法2:采用顺序存储结构创建静态查找表--有序表,对有序表进行二分查找 */ #include<stdio.h> #include<stdlib.h> #define EQ(a,b) ((a)==(b)) #define LT(a,b) ((a)<(b)) #define LQ(a,b) ((a)<...
    /*算法1:采用顺序存储结构创建静态查找表,对查找表进行顺序查找和改进的顺序查找,并对其查找效率进行比较;
    算法2:采用顺序存储结构创建静态查找表--有序表,对有序表进行二分查找
    */
    #include<stdio.h>
    #include<stdlib.h>
    #define EQ(a,b) ((a)==(b))
    #define LT(a,b) ((a)<(b))
    #define LQ(a,b) ((a)<=(b))
    typedef int KeyType;
    typedef struct{
     	KeyType key;
    }ElemType;
    typedef struct{
    	ElemType *elem; 
    	int length;
    }SSTable;
    int create(SSTable *ST)
    {//创建静态表
     int i,n;
     printf("请输入你要创建的表的长度:\n");
     scanf("%d",&n);
     ST->elem =(ElemType *)malloc((n+1)*sizeof(ElemType));
     if(!ST->elem )
     return 0;
     printf("请输入%d个数据(若采用二分法查找关键字,则顺序输入)。\n",n);
     for(i=1;i<=n;i++)
     {
      scanf("%d",&ST->elem [i].key);
     }
     ST->length =n;
     return 1;
     } 
    int search_seq(SSTable ST,KeyType key)
    {
    	int i=1;
    	ElemType *p;
    	while(i<=ST.length&&!EQ(ST.elem[i].key,key))
    	++i;
    	if(i<=ST.length)
    	return i;
    	else
    	return 0;
    	}
    int search_seq2(SSTable ST,KeyType key)
    {
    	int i;
    	ST.elem[0].key=key;
    	for(i=ST.length;!EQ(ST.elem[i].key,key);--i);
    	return i;
    }
    int search_bin(SSTable ST,KeyType key)
    {
    	int low=1;
    	int high=ST.length;
    	while(low<=high)
    	{
    		int mid=(low+high)/2;
    		if(EQ(key,ST.elem[mid].key))
    		return mid;
    		else if(LT(key,ST.elem[mid].key))
    			high=mid-1;
    		else low=mid+1;
    		
    	}
    	return 0;
    }//search_bin
    int main()
     {
      int i,time;
      SSTable ST;
      KeyType key;
      printf("请输入创建表的类型(0.无序表,1.有序表):\n");
      scanf("%d",&time);
      create(&ST); 
      printf("创建成功!\n");
      printf("请输入需查找的关键字:\n");
      scanf("%d",&key);
      if(time==0)
      {
       printf("顺序查找关键字结果为:\n");
       i=search_seq(ST,key);
       if(i==0)
       {
        printf("查找失败,表中无此元素\n");
       }
       else
       {
        printf("查找成功!\n");
        printf("位置是%d\n",i);
       }
       printf("改进算法顺序查找关键字结果为:\n");
       i=search_seq2(ST,key);
       if(i==0)
       {
        printf("查找失败,表中无此元素\n");
       }
       else
       {
        printf("查找成功!\n");
        printf("位置是%d\n",i);
       }
      }
      else
      {
      printf("二分查找关键字结果为:\n");
       i=search_bin(ST,key);
       if(i==0)
       {
        printf("查找失败,表中无此元素\n");
       }
       else
       {
        printf("查找成功!\n");
        printf("位置是%d\n",i);
       } 
      }
     }
    
    展开全文
  • 数据结构:有序线性表类...实现返回素数的方法3.1使用静态方法3.2 直接在新的类中创建方法并应用三、程序源码与结果1. 静态方法1.1 数组方法1.2 直接循环实现2.写入新类中直接调用2.1 数组法2.2直接循环六、分析评...

    数据结构:有序线性表类中,返回素数表

    一、题目描述

    public SortedSeqList<Integer> creatPrime(int max)
        //返回包含max在内的所有素数的顺序排序表

    ​ 创建这么一种方法并通过实例实现其功能


    二、设计思路

    1.素数的定义

    所有大于1的数字中,除了其本身和1之外没有别的因数的数叫做素数(Prime Number)

    素数表

    2.实现查找素数的方法

    2.1 使用数组存储+排除法

    假设小于等于max的数字全部存储在一个数组中,且数字与数组下标相同避免混乱。

    逐一确认是否有除了1和本身之外的因数,如果有,则抹除该数字使其为0,没有则保留

    • 伪代码如下
    int[] arr= new int[max+1];
    arr[0]=arr[1]=0;
    for(int i=2;i<max+1;i++)
        arr[i]=i;
        如果能整除<i的任何一个整数,则不是素数;
        {
        使得该数组项arr[i]=0;
        }
    //得到一组素数和0;
    if(arr[i]!=0)
        insert这个数字进入SortedSeqList里面
    2.2 直接循环实现插入

    使用循环max-1次逐个判断是否为素数,并且判断一个插入一个

    if(max<2)
    {
        提示输入错误并且返回空表
    }
    else
    {
        for(int i=2;i<=max;i++)
        {	
            int judge =1;//使用judge来判断i有没有因数
            for(int j=2;j < i;j++)
            {
                if(i%j == 0)
                {
                    judge = -1;
                	break;
                }
            }
            if(judge == 1)
                 insert这个数字进入SortedSeqList里面
        }
    }
        

    3.实现返回素数表的方法

    3.1使用静态方法

    在SortedSeqList类中里面创建一个静态方法,就可以直接使用类名.createPrime调用而不用通过实例调用

    3.2 直接在新的类中创建方法并应用

    在新的类中写入成员方法createPrime,再在主函数中创建自己类的对象,调用该方法。


    三、程序源码与结果

    1. 静态方法

    • 主程序源码
    package code_02_2_3_insert;
    import java.util.*;
    
    public class PracticePrime {
    
    	public static void main(String[] args) {
    		    int max=0;
    		    System.out.println("请输入最大界限max");//交互提示,便于操作
    		    Scanner reader = new Scanner(System.in);
    		    max = reader.nextInt();
    		    
    		    SortedSeqList<Integer> Prime = new SortedSeqList<Integer>();
    		    Prime=SortedSeqList.createPrime(max);//调用静态方法,直接使用类名调用即可
    		    for(int i=0;i<Prime.n;i++)
    		    	System.out.print(Prime.get(i)+" ");//打印输来检测结果
    	}
    }
    1.1 数组方法
    • SortedSeqList类中源码
    public static SortedSeqList<Integer> createPrime(int max)  
        {
    	   SortedSeqList<Integer> pList = new SortedSeqList<Integer>();
    	   
    	   if(max<2)
    	   {
    		   System.out.println("输入数字无效,返回空表");//交互提示
    		   return pList;
    	   }
    	   else
    	   {
    		   int[] arr= new int[max+1];
    		   arr[0]=arr[1]=0;
    		 //设法得到含有插入数字的数组
    		   for(int i=2;i< max+1;i++)
    		   {
    			   arr[i]=i;//赋予初值
    			   for(int j=2;j<i;j++)//排除不是素数的数字
    			   {
    				   if(i%j == 0)
    				   {
    					   arr[i]=0;
    					   break;
    				   }
    			   }
    		   }
               
    		   //将有顺序的数组选择性的插入排序顺序表
    			 for(int i=2;i<max+1;i++)
    			 {
    				   if(arr[i] != 0)
    				   {
    					   pList.insert(arr[i]);
    				   }
    			  }
    			 return pList;
    	   }
        }	
    • 运行结果:对比上述素数表可以知道答案是正确的

      1553583021453
      在这里插入图片描述

    • 时间复杂度(max=n)

      循环嵌套,最外层循环 n1n-1 次,内层每次循环i1\leq i-1, 所以最大循环次数为 n(n1)2\frac{n(n-1)}{2}

      插入循环是简单循环,共循环 n1n-1

      所以最后循环次数最大为n(n1)2+(n1)\frac{n(n-1)}{2} + (n-1) , 时间复杂度为O(n2)O(n^2)

    1.2 直接循环实现
    • SortedSeqList类中源码
    public static SortedSeqList<Integer> createPrime(int max)  
        {
    	   SortedSeqList<Integer> pList = new SortedSeqList<Integer>();
    	   
    	   if(max<2)
    	   {
    		   System.out.println("输入数字无效,返回空表");
    		   return pList;
    	   }
    	   else
    	   {
    			 for(int i=2;i<=max;i++)
    			 {
    				 //逐个判断i有没有因数
    				 int judge = 1;//judge为判断i有无因数的标识
    				 
    				 for(int j=2; j<i; j++)
    				 {
    					 if(i%j == 0)
    					 {
    						 judge=-1;
    						 break;
    					 }
    				 }
    				 if(judge == 1)
    				 {
    					 pList.insert(i);//将判断出来的每个素数插入表格中
    				 }
    
    			  }
    			 return pList;
    	   }
    • 运行结果:对比上述素数表可以知道答案是正确的

    1553583853511

    1553583983697

    • 时间复杂度

      循环嵌套,最外层循环 n1n-1 次,内层每次循环i1\leq i-1, 所以最大循环次数为 n(n1)2\frac{n(n-1)}{2}

      所以最后的时间复杂度为O(n2)O(n^2)

    2.写入新类中直接调用

    2.1 数组法
    • 源码
    package code_02_2_3_insert;
    import java.util.*;
    
    public class PracticePrime {
    //************************************//与1.1数组法的方法体是一致的,可以不看
    	public SortedSeqList<Integer> createPrime(int max)
    	{
    		SortedSeqList<Integer> pList = new SortedSeqList<Integer>();
    		   
    		   if(max<2)
    		   {
    			   System.out.println("输入数字无效,返回空表");//交互提示
    			   return pList;
    		   }
    		   else
    		   {
    			   int[] arr= new int[max+1];
    			   arr[0]=arr[1]=0;
    			 //设法得到含有插入数字的数组
    			   for(int i=2;i< max+1;i++)
    			   {
    				   arr[i]=i;//赋予初值
    				   for(int j=2;j<i;j++)//排除不是素数的数字
    				   {
    					   if(i%j == 0)
    					   {
    						   arr[i]=0;
    						   break;
    					   }
    				   }
    			   }
    	         		   //将有顺序的数组选择性的插入排序顺序表
    				 for(int i=2;i<max+1;i++)
    				 {
    					   if(arr[i] != 0)
    					   {
    						   pList.insert(arr[i]);
    					   }
    				  }
    				 return pList;
    		   }
    	    }	
    //*************************************主函数
    	public static void main(String[] args) {
    		    int max=0;
    		    System.out.println("请输入最大界限max");//交互提示
    		    Scanner reader = new Scanner(System.in);
    		    max = reader.nextInt();
    		    
    		    PracticePrime Prime2 = new PracticePrime();//创建自己类的实例Prime2
    		    SortedSeqList<Integer> pList = new SortedSeqList<Integer>();//创建一个整型排序顺序表
    		    pList=Prime2.createPrime(max);//调用静态方法
    		    System.out.println(pList.toString());//打印字符串
    	}
    }
    
    • 运行结果:对比上述素数表可以知道答案是正确的

    1553589778686

    .1553589818370

    • 时间复杂度

      同本小节1.1(因为方法内容一样)为O(n2)O(n^2)

    2.2直接循环
    • 源码
    public SortedSeqList<Integer> createPrime(int max)
    	{//*************************与2.1直接循环的方法体是一致的,可以不看
    		SortedSeqList<Integer> pList = new SortedSeqList<Integer>();
    		   if(max<2)
    		   {
    			   System.out.println("输入数字无效,返回空表");
    			   return pList;
    		   }
    		   else
    		   {
    				 for(int i=2;i<=max;i++)
    				 { //逐个判断i有没有因数
    					 int judge = 1;//judge为判断i有无因数的标识
    					 
    					 for(int j=2; j<i; j++)
    					 {
    						 if(i%j == 0)
    						 {
    							 judge=-1;
    							 break;
    						 }
    					 }
    					 if(judge == 1)
    					 {
    						 pList.insert(i);
    					 }
    				  }
    				 return pList;
    		   }
    	    }	
    	
    //********************************************主函数!!
    	public static void main(String[] args) {
    		    int max=0;
    		    System.out.println("请输入最大界限max");//交互提示
    		    Scanner reader = new Scanner(System.in);
    		    max = reader.nextInt();
    		    
    		    PracticePrime Prime2 = new PracticePrime();//创建自己类的实例Prime2
    		    SortedSeqList<Integer> pList = new SortedSeqList<Integer>();//创建一个整型排序顺序表
    		    pList=Prime2.createPrime(max);//调用静态方法
    		    System.out.println(pList.toString());//打印字符串
    	}
    }
    • 运行结果与时间复杂度同上,此处略

    六、分析评价

    1.容错性

    此处因为传入的参数只有一个max,所以比较简单,只需要考虑max不符合素数最大界限的条件时候的容错即可,即max<=2的时候将没有对应的素数

    if(max<2)
     { …… }		   
    else
     { …… }

    2.交互性

    1)提示错误:当传入的参数max不符合获取素数的条件的时候,输出交互反馈

    2)通过流获取max:对调试的便捷性有很大的帮助

    3.高效性

    此处使用了两种方法去编写输出素数排序顺序表的具体内容,通过分析得到二者的时间复杂度都是O(n2)O(n^2) ,所以采用而用二者在时间损耗上面并无太大区别。而且因为程序内容简单,执行起来也十分高效快速。


    五、细节探究

    1.静态方法vs新类一般方法

    使用静态方法的时候可以用类直接调用,不需要通过实例;

    但是在此处方法的返回类型是确认了表内数据类型的有序顺序表而不是泛型表,与类定义中的其它基本方法类型不是十分一致,放在一起不是十分恰当。

    • 拓展:其实可以在新类里面将方法设置为静态的,可以不通过实例调用,更加方便。
    public class PracticePrime {
    	public static SortedSeqList<Integer> createPrime(int max){……}
    	public static void main(String[] args) {
    		   ~
    		   SortedSeqList<Integer> pList=PracticePrime.createPrime(max);
            //调用静态方法
    		   ~
    	}

    2.声明实例vs创建实例

    因为方法createPrime返回的类型是一个有序顺序表,而且方法内部有创建(New)了一个表,所以在调用该方法的时候其实只需要声明即可,可是节省内存空间,避免浪费。

    即:

    //静态方法
    SortedSeqList<Integer> pList;
    pList = SortedSeqList<Integer>.creatPrime();
    
    //新类一般方法
    PracticePrime Prime2 = new PracticePrime();//创建PracticePrime类的实例Prime2
    SortedSeqList<Integer> pList =Prime2.createPrime(max);//调用方法返回一个表给pList
    
    //新类的静态方法:比一般方法空间利用率高
    SortedSeqList<Integer> pList=PracticePrime.createPrime(max);

    3.打印线性表

    • 使用System.out.println和SortedSeqList里面的get()方法结合
    • 使用get方法中的toString()先转化,在打印整个字符串

    展开全文
  • 静态查找表:只做查找操作的查找表 动态查找表:查找时插入或删除数据的查找表 常见查找方式: 顺序表查找 **方法:**线性表+顺序遍历+等值比较 有序表查找 方法: 线性表+排序+折半查找/插值查找/斐波那契搜索等 ...

    查找表

    查找表是由同一类型的数据元素(或记录)构成的集合。

    根据操作可分为

    • 静态查找表:只做查找操作的查找表
    • 动态查找表:查找时插入或删除数据的查找表

    常见查找方式:

    顺序表查找

    **方法:**线性表+顺序遍历+等值比较

    有序表查找

    方法: 线性表+排序+折半查找/插值查找/斐波那契搜索等

    插值查找:基于二分查找,将查找点的选择改进为自适应选择,提高查找效率
    斐波那契搜索:就是在二分查找的基础上根据斐波那契数列进行分割的

    线性索引查找

    方法: 创建索引

    • 稠密索引: 每个记录各对应一个索引项
    • 分块索引:
      特点:块间有序,块内无序
      索引结构:最大关键码+块内个数+首元素指针
    • 倒排索引:
      索引结构:次关键码+记录号

    二叉排序树

    方法: 建立二叉排序树
    特点:左子树小于根节点,右子树大于根节点,并不重复
    优点:

    1. 查找次数小于树深度
    2. 插入删除不移动元素,时间性能好
      缺点:
    3. 查找性能取决于树的形状,极端情况下性能会很差。

    平衡二叉树(AVL)

    方法: 建立二叉平衡树
    优化的二叉排序树,左右子树深度相差不能大于一。

    多路查找树(B树)

    方法: 建立多路查找树
    多路查找树:每个节点的孩子数多于两个,每个节点可以存储多个元素。
    B树是一种平衡的多路查找树。
    2-3树:
    来源于知乎,侵删
    2-3-4树:
    来源于网络,侵删
    2-3树、2-3-4树都是特殊的多路查找树

    散列表(哈希表)查找

    方法: 建立关键字与存储位置之间的对应关系(散列函数)

    散列函数的构造方法:
    1. 直接定址法
    2. 数字分析法
    3. 平方取中法
    4. 折叠法
    5. 除留余数法
    6. 随机数法

    哈希冲突:关键字不同的元素被映射到了同一个内存位置

    处理散列冲突的方法:
    1. 开放定址法: 一旦发生冲突就去找下一个散列地址
      1. 线性探测再散列: 顺序寻找
      2. 二次探测再散列: 下一个散列地址为1^2 , (-1)^2, 2^2 , (-2)^2 , 3^2 , ( -3)^2……
      3. 伪随机探测再散列: 随机生成下一个散列地址
    2. 再哈希法: 准备多种散列函数,一旦冲突就换一种散列函数
    3. 链地址法: 为每个冲突分别建立单链表,一旦冲突则加入对应链表(同义冲突)
    4. 建立公共溢出区: 建立溢出表(顺序),所有的冲突都加入溢出表(非同义冲突)
    散列表的查找性能

    无冲突时为O(1),冲突时取决于

    1. 散列表是否均匀
    2. 处理冲突的方法
    3. 散列表的填装因子
    展开全文
  • 大话数据结构

    2017-02-09 15:26:37
    8.4 有序表查找 8.4.1 折半查找 8.4.2 插值查找 8.4.3 斐波那契查找 8.5 线性索引查找 8.5.1 稠密索引 8.5.2 分块索引 8.5.3 倒排索引 8.6 二叉排序树 8.6.1 二叉排序树查找操作 8.6.2 二叉排序树插入操作 8.6.3 ...
  • 10. 静态查找 (1)顺序查找(Search_Seq) (2)折半查找 (Serch_Bin) (3)插值查找 (Search_Ins) (4)斐波那契查找 (Search_Fib) (5)次优查找树(BiTree_SOSTree) 11. 动态查找 (1)在二叉排序树上进行...
  • 数据结构演示软件

    2013-06-02 21:32:36
    图示窗口分成3部分:中间部分或显示客户流动情况的动画,或显示程序执行过程中事件和4个队列的数值,上方两个按钮用以切换动画或静态数据,下方则显示客户总人数、客户逗留的累计时间以及调节动画中小人移动速度的...
  • 图示窗口分成3部分:中间部分或显示客户流动情况的动画,或显示程序执行过程中事件和4个队列的数值,上方两个按钮用以切换动画或静态数据,下方则显示客户总人数、客户逗留的累计时间以及调节动画中小人移动速度的...
  • 数据结构(C++)有关练习题

    热门讨论 2008-01-02 11:27:18
    内容及步骤: 1、 设计一个图的类,采用临接法进行存储,该图每个结点的数据类型类模板的模板参数进行定义(注:需先设计一个结点类Node); 2、 为该类分别设计一个实现深度优先搜索和广度优先搜索的成员...
  • mysql数据类型与创建表 mysql 增删改查 mysql 外键关联 mysql 连接查询 mysql 事务与索引 mysql python交互 sqlalchemy orm介绍 sqlalchemy 常用语法 sqlalchemy 外键关联 sqlalchemy 多外键关联 sqlalchemy 多对多...
  • 3.3.3实例成员变量和静态成员变量114 3.4方法的定义和实现116 3.4.1方法的声明117 3.4.2创建方法体与return语句117 3.4.3局部变量和成员变量的区别119 3.4.4方法的访问权限121 3.5方法的调用121 3.5.1方法...
  • 能使用二分法查找的线性表必须满足用顺序存储结构和线性表是有序表两个条件。 “有序”是特指元素按非递减排列,即从小到大排列,但允许相邻元素相等。下一节排序中,有序的含义也是如此。 对于长度为n的有序线性表...
  • 大话数据结构 程杰

    2018-09-01 10:06:43
    3.9单链表的整表创建 66 3.10单链表的整删除 69 3.11单链表结构与顺序存储结构优缺点 70 3.12静态链表 71 对于一些语言,如basic、fortran等早期的编程高级语言,由于没有指针,这链表结构,按照前面我们的讲法,...
  • 3.8.1 单链表的插入 61 3.8.2 单链表的删除 64 3.9 单链表的整表创建 66 3.10 单链表的整删除 69 3.11 单链表结构与顺序存储结构优缺点 70 3.12 静态链表 71 对于一些语言,如Basic、Fortran等早期的编程高级语言...
  • 3.9单链表的整表创建 66 3.10单链表的整删除 69 3.11单链表结构与顺序存储结构优缺点 70 3.12静态链表 71 对于一些语言,如basic、fortran等早期的编程高级语言,由于没有指针,这链表结构,按照前面我们的讲法,...
  • 3.9单链表的整表创建 66 3.10单链表的整删除 69 3.11单链表结构与顺序存储结构优缺点 70 3.12静态链表 71 对于一些语言,如basic、fortran等早期的编程高级语言,由于没有指针,这链表结构,按照前面我们的讲法,...
  • 大话数据结构-程杰

    2014-07-13 23:45:52
    3.9 单链表的整表创建 66 3.10 单链表的整删除 69 3.11 单链表结构与顺序存储结构优缺点 70 3.12 静态链表 71 对于一些语言,如Basic、Fortran等早期的编程高级语言,由于没有指针,这链表结构,按照前面我们...
  • 9.10 把装饰器作用到类和静态方法上 357 9.11 编写装饰器为被包装的函数添加参数 359 9.12 利用装饰器给类定义打补丁 362 9.13 利用元类来控制实例的创建 364 9.14 获取类属性的定义顺序 367 9.15 定义一个能接受可...
  • 创建表时,经常会创建的主键、外键、唯一约束、Check约束等  语法结构 create table 表名( [字段名] [类型] [约束] ……….. CONSTRAINT fk_column FOREIGN KEY(column1,column2,…..column_n) ...
  • 10.6 有序表 10.7 字典 10.7.1 键的类型 10.7.2 字典示例 10.7.3 Lookup类 10.7.4 其他字典类 10.8 HashSet 10.9 位数组 10.9.1 BitArray 10.9.2 BitVector32 10.10 性能 10.11 小结 第11章 Language Integrated ...
  • 实例123 有序数组折半查找 实例124 计算字符串中有多少个单词 实例125 获取数组中元素的个数 实例126 输出数组元素 实例127 将二维数组行列对换 实例128 将二维数组转换为一维数组 实例129 使用指针变量遍历...
  • C#高级编程(第6版)

    2011-05-11 11:10:30
     10.6 有序表  10.7 字典  10.7.1 键的类型  10.7.2 字典示例  10.7.3 Lookup类  10.7.4 其他字典类  10.8 HashSet  10.9 位数组  10.9.1 BitArray  10.9.2 BitVector32  10.10 性能  10.11 小结  第11...
  • 实例123 有序数组折半查找 实例124 计算字符串中有多少个单词 实例125 获取数组中元素的个数 实例126 输出数组元素 实例127 将二维数组行列对换 实例128 将二维数组转换为一维数组 实例129 使用指针变量遍历...
  •  10.6 有序表  10.7 字典  10.7.1 键的类型  10.7.2 字典示例  10.7.3 Lookup类  10.7.4 其他字典类  10.8 HashSet  10.9 位数组  10.9.1 BitArray  10.9.2 BitVector32  10.10 性能  10.11 小结  第11...
  • 1.7.1 创建ASP.NET应用程序 1.7.2 使用WPF 1.7.3 windowsStore应用程序 1.7.4 Windows服务 1.7.5 WCF 1.7.6 Windows WF 1.8 C#在.NET企业体系结构中的作用 1.9 小结 第2章 核心C# 2.1 C#基础 2.2 第一个C#程序 ...
  • 1.7.1 创建ASP.NET应用程序 1.7.2 使用WPF 1.7.3 windowsStore应用程序 1.7.4 Windows服务 1.7.5 WCF 1.7.6 Windows WF 1.8 C#在.NET企业体系结构中的作用 1.9 小结 第2章 核心C# 2.1 C#基础 2.2 第一个C#程序 ...
  • 1.7.1 创建ASP.NET应用程序 1.7.2 使用WPF 1.7.3 windowsStore应用程序 1.7.4 Windows服务 1.7.5 WCF 1.7.6 Windows WF 1.8 C#在.NET企业体系结构中的作用 1.9 小结 第2章 核心C# 2.1 C#基础 2.2 第一个C#程序 ...
  • 10.6 有序表 10.7 字典 10.7.1 键的类型 10.7.2 字典示例 10.7.3 Lookup类 10.7.4 其他字典类 10.8 HashSet 10.9 位数组 10.9.1 BitArray 10.9.2 BitVector32 10.10 性能 10.11 小结 第11章 Language Integrated ...
  • C#全能速查宝典

    热门讨论 2014-04-26 16:16:27
    《C#全能速查宝典》所讲的知识点按照功能和字母进行排序,读者既可以按照功能顺序查找,又可以按照字母顺序学习。 《C#全能速查宝典》不仅适合C#程序设计初学者,也可作为中、高级程序开发人员的参考手册。 ========...

空空如也

空空如也

1 2
收藏数 37
精华内容 14
关键字:

创建静态有序查找表