【无标题】数据结构第二次作业

#include <stdio.h>
#include<malloc.h>

#define LIST_MAX_LENGTH 10

/**
 * linear list of integers.The key is data.
 */
 typedef struct sequentialList {
 	int actualLength;
 	
 	int data[LIST_MAX_LENGTH];//The maximum length is fixed. 
 }*SequentialListPtr;
 
 /**
 *Output the list.
 */
 void outputList(SequentialListPtr paraList){
 	for (int i = 0;i < paraList->actualLength;i ++){
 		printf("%d",paraList->data[i]);
	 }// Of for i
	 printf("\r\n");
 }//Of outputList
 
 /**
 *Output the memeory for the list.
 */
 void outputMemory(SequentialListPtr paraListPtr){
 	printf("The address of the structure : %1d\r\n",&paraListPtr);
 	printf("The address of actualLength : %1d\r\n",&paraListPtr->actualLength);
 	printf("The address of data:%1d\r\n",&paraListPtr->data);
 	printf("The address of actual data:%1d\r\n",&paraListPtr->data);
 	printf("The address of second data: %1d\r\n",&paraListPtr->data);
 }//Of outputMemory
 
 /**
 *INitalize a sequential list. No error checking for this function.
 *@param paraList The pointer to the list.Lt must be a pointer to change the list.
 *@param paraValues An int array storing all elements.
 */
 SequentialListPtr sequentialListInit (int paraData[], int paraLength){
 	SequentialListPtr resultPtr = (SequentialListPtr)malloc(sizeof(paraData));
	  for (int i = 0; i < paraLength; i++) {
	  	resultPtr->data[i] = paraData[i];
	  	  }//of for i
	  resultPtr->actualLength = paraLength;
	  
	  return resultPtr;
 }//of sequentialListInit
 
 /**
 *Insert an element into a sequential linter list.
 *@param paraListPtr The pointer to the list.It must be a pointer to change the 1
 *@param paraPosition The position,e.g.,0 stands for inserting at the first posi
 *@param paraValue The value to be inserted.
 */
 void sequentialListInsert(SequentialListPtr paraListPtr,int paraPosition, int paraValue){
 	//Step 1. Space check.
 	if(paraListPtr->actualLength >= LIST_MAX_LENGTH){
 		printf("Cannot insert elemnt: list full.\r\n");
 		return;
	 }//Of if
	 
	 //Step 2. Position check .
	 if(paraPosition < 0){
	 	printf("Cannot insert element : negative position unsupported.");
	 	return;
	 }//Of if 
	 if(paraPosition > paraListPtr->actualLength){
	 	printf("Cannot insert element: the position %d is bigger than the list length %d.\r\n",paraPosition,paraListPtr->actualLength);
	 	return;
	 }//Of if
	 
	 //Step 3. Move the remaining part .
	 for(int i = paraListPtr->actualLength; i > paraPosition; i--){
	 	paraListPtr->data[i] = paraListPtr->data[i-1];
	 	}//of for i
	 	
	 	//Step 4. Insert.
	 	paraListPtr->data[paraPosition] = paraValue;
	 	
	 	//Step 5.Update the length.
	 	paraListPtr->actualLength ++;
	 }// Of  sequentialListInsert
	 
	 /**
	 * Test the insert function.
	 */
	 void sequentialInsertTest(){
	 	int i;
	 	int tempArray[5] = {3,5,2,7, 4};
	 	
	 	printf("---- sequentialInsertTest begins.----\r\n");
	 	
	 	//Initialize.
	 	SequentialListPtr tempList = sequentialListInit(tempArray, 5);
	 	printf("After initialization,the list is:");
	 	outputList(tempList);
	 	
	 	//Insert to thr last.
	 	printf("Now insert to the first, the list is:");
	 	sequentialListInsert(tempList,0,8);
	 	outputList(tempList);
	 	
	 	//Insert to the last.
		 printf("Now insert to the last,the list is:");
		 sequentialListInsert(tempList,6,9);
		 outputList(tempList);
		 
		 //Insert beyond the tail.
		 printf("Now insert beyond the tail.\r\n");
		 sequentialListInsert(tempList,8,9);
		 printf("The list is:");
		 outputList(tempList);
		 
		 //Insert to position 3.
		 for (i =0;i<5;i++){
		 	printf("Inserting %d.\r\n",(i +10));
		 	sequentialListInsert(tempList,0,(i + 10));
		 	outputList(tempList);
		 } //Of for i
		 
		 printf("----sequentialListInsertTest ends.----\r\n");
	}//of sequentialInsertTeat
	
	/**
	*Delete an element from a sequential linear list.
	*@param paraListPtr The pointer to the list. It must be a pointer to change the list.
	*@paramparaPosition The position, e.g.,0 stands for inserting at the first position.
	8@return The deleted value.
	*/
	int sequentialListDelete(SequentialListPtr paraListPtr,int paraPosition){
		//Step 1.Position check.
		if(paraPosition<0){
			printf("invalid position: &d.\r\n",paraPosition);
			return -1;
		}//Of if
		
		if(paraPosition >=paraListPtr->actualLength){
			printf("Cannot delete element:the position %d is beyond the list length %d.\r\n",paraPosition,paraListPtr->actualLength);
			return -1;
		}//Of if 
		
		//Step 2.Move the remaining part.
		int resultValue = paraListPtr->data[paraPosition];
		for(int i = paraPosition;i< paraListPtr->actualLength; i++){
			paraListPtr->data[i] = paraListPtr->data[i+1]; 
		}//Of for i
		
		// Step 3.Update the length.
		paraListPtr->actualLength --;
		
		//Step 4. Return the value.
		return resultValue;
}//Of sequentialListDelete

/**
 *Test the delete function.
 */
void sequentialDeleteTest(){
	int tempArray[5] = {3,5,2,7,4};
	
	printf("---- sequentialDeleteTest begins.---\r\n");
	
	//initialize.
	SequentialListPtr tempList = sequentialListInit(tempArray, 5);
	printf("After initialiazation,the list is: ");
	outputList(tempList);
	
	//Delete the first.
	printf("Now delete the first, the liat is: ");
	sequentialListDelete(tempList,0);
	outputList(tempList);
	
	//Delete to the last.
	printf("Now delete the last,the list is : ");
	sequentialListDelete(tempList,3);
	outputList(tempList);
	
	//Delete the second.
	printf("Now delete the second, the list is : ");
	sequentialListDelete(tempList,1);
	outputList(tempList);
	
	//Delete the second.
	printf("Now delete the 5th,the list is : ");
	sequentialListDelete(tempList,5);
	outputList(tempList);

    //Delete the second.
    printf("Now delete the (-6)th,the list is : ");	
	sequentialListDelete(tempList,-6);	 
	outputList(tempList);
	
	printf("----SequentialDeleteTest ends.----\r\n");
	
	outputMemory(tempList);
}//Of sequentialDeleteTest

/**
 *Locate anelement in the list.
 *@param paraListPtr The pointer to the list.
 *@param paraValue the indicated value.
 *@return The position of the value or -1 indicating not exists
 */
 int locateElement(SequentialListPtr paraListPtr,int paraValue){
 	for (int i = 0; i < paraListPtr->actualLength;i ++){
 		if(paraListPtr->data[i] == paraValue){
 			return i;
		 }//Of if
	 }//Of for i
	 
	 return -1;
 }// Of locateElement
 
 /**
 *Get an element in the list.
 *@param paraListPtr The pointer to the list.
 *@param paraPosition The given position.
 *@return The position of the value,or -1 indicating not exists
 */
 int getElement(SequentialListPtr paraListPtr,int paraPosition){
 	//Step 1. Position check.
 	if(paraPosition<0){
 		printf("Invalid position: %d.\r\n",paraPosition);
 		return -1;
	 }//Of if
	 
	 if(paraPosition >= paraListPtr->actualLength){
	 	printf("Cannot get element: the position %d is beyond the length %d.\r\n",paraPosition,paraListPtr->actualLength);
	 	return -1;
	 }//Of is
	 
	 return paraListPtr->data[paraPosition];
 }//Of locateElement
 
 /**
 *Clear element in the liat.
 *@param paraListPtr The pointer to the list.
 *@return The position of the value, or -1 indicating not exists
 */
 void clearList(SequentialListPtr paraListPtr){
 	paraListPtr->actualLength = 0;
 }//Of clearList
 
 /**
 The entrance.
 */
 int main(){
 	sequentialInsertTest();
 	sequentialDeleteTest();
 	
 }// Of main

---- sequentialInsertTest begins.----
After initialization,the list is:35274
Now insert to the first, the list is:835274
Now insert to the last,the list is:8352749
Now insert beyond the tail.
Cannot insert element: the position 8 is bigger than the list length 7.
The list is:8352749
Inserting 10.
108352749
Inserting 11.
11108352749
Inserting 12.
1211108352749
Inserting 13.
Cannot insert elemnt: list full.
1211108352749
Inserting 14.
Cannot insert elemnt: list full.
1211108352749
----sequentialListInsertTest ends.----
---- sequentialDeleteTest begins.---

--------------------------------
Process exited after 1.244 seconds with return value 3221226356
请按任意键继续. . .