الساعة الآن 11:09 AM


أهلا وسهلا بك فى منتديات جامعة الإمام محمد بن سعود الإسلامية.

إذا كانت هذه زيارتك الأولى للملتقى تأكد من زيارة صفحة المساعدة ; كما يجب عليك التسجيل للمشاركة فى أنشطة الملتقى والكتابة فى أقسامه . نتمنى لك تصفحاً سعيداً..إدارة الملتقى

سجل دخولك الأن









NOTICE | تنبيـــه :- هذا الموضوع قديم تم انشائه قبل 1524 يوم مضى , قد تكون مشاركتك هنا غير مجدية يُفضل انشاء موضوع جديد ان تطلب الامر.
النتائج 1 إلى 2 من 2
  1. #1
    الصورة الرمزية Rn000sh
    تاريخ التسجيل : Oct 2012
    الجنس :
    عدد الكتب في مكتبتي : 0
    التقييم : 50

    بياناتى الأكاديمية

    التخصص

    :علوم حاسب

    الكلية

    : كلية علوم الحاسب والمعلومات

    المستوى

    : الثالث

    التفاعل

    مواضيعى

    : 1

    مشاركاتى

    : 1

    مقالات المدونة :

    مساعده في شيت الداتا


    السلام عليكم ورحمة الله وبركاته

    الله يعافيكم ممكن مساعده في حل شيت الداتا :"(
    ومشكوريين مقدما


    كود:
    Exercise 1:  
    By using ADT only, write a C++ program which implements a linked list that manages library books. A book is characterized by (author, price, unique ISBN number). Linked list should be ordered by ISBN number. It allows user to do one of the following: 
    1.	Build a book list by adding book information until the user enters -1. 
    2.	Delete a book from the list using ISBN number.
    3.	Look for a specific book by using ISBN number.
    4.	Change the price of books that are higher than 100 SR by giving a 25% discount.
    5.	Print the details of all books.
    Notes:
    -	Use only the public functions in the list class. 
    -	Book data type is implemented as struct:
    struct Book{
    string  author;
    double price;
    int ISBN;
    };
    -	And node struct is remaining the same:
    List<Book,int> Booklist;
    Exercise 2:  
    Without using linked list ADT (i.e. add these functions to linked list ADT):
    1.	appendList(const List &L)concatenate two given list into one big list.
    2.	in the node at that index position. The index should be in the range [0..length- 1] .
    3.	InsertNth(TYPE dataIn , int index) function inserts a new node at any index within a list. The caller may specify any index in the range [0..length-1], and the new node should be inserted at that index.
    /*	Linked List Abstract Data Type
    Written by: G & F
    Date:       2/1998
    4/1999 Converted to C++
    Copyright (c) 2001
    Brooks/Cole Publishing Company
    Thomson International
    All Rights Reserved
    Linked List Abstract Data Type
    Node ADT Declaration.  
    TYPE is a standard or user-defined data type for which
    the operators <, >, and == is defined or overloaded.
    */
    //	Node Declaration
    template <class  TYPE> 
    struct NODE 
    {
    TYPE    data;
    NODE   *link;
    }; //  End of Node Declaration
    //	List Class Declaration
    template <class  TYPE, class KTYPE> 
    class List  
    {
    private:
    NODE<TYPE> *head;
    NODE<TYPE> *pos;
    NODE<TYPE> *rear;
    int         count;
    //	     Function Declarations
    bool  _insert  (NODE<TYPE>   *pPre,   
    TYPE          dataIn);
    void  _delete  (NODE<TYPE>   *pPre,
    NODE<TYPE>   *pLoc,
    TYPE         *dataOutPtr);
    bool  _search  (NODE<TYPE>  **pPre,
    NODE<TYPE>  **pLoc,
    KTYPE         key);
    public:
    List (void);
    ~List (void);
    int        addNode      (TYPE   dataIn);
    bool       removeNode   (KTYPE  key, 
    TYPE  *dataOutPtr);
    bool       retrieveNode (KTYPE  Argu, 
    TYPE&  dataOut);
    bool       getNext      (int    fromWhere,  
    TYPE&  dataOut);
    int        listCount    (void);
    bool       emptyList    (void);
    bool       fullList     (void); 
    }; // class List 
    // 	End of List Class Declaration
    /* 	=============== List Constructor  ==============	
    Initialize the list.
    Pre    Class is being instantiated
    Post   Class instantiated and initialized
    */
    template <class TYPE, class KTYPE>
    List<TYPE, KTYPE> :: List (void)   
    {
    //	Statements 
    head     = NULL;
    pos      = NULL;
    rear     = NULL;
    count    = 0;
    } //  List Constructor 
    /*	==================== addNode =================== 
    Inserts data into linked list.
    Pre     dataIn contains data to be inserted
    Post    Data inserted or error
    Return -1 if overflow, 
    0 if successful,
    1 if duplicate key
    */
    template <class TYPE, class KTYPE> 
    int List<TYPE, KTYPE> :: addNode (TYPE dataIn)
    {
    //	Local Definitions 
    bool  found;
    bool  success;
    NODE<TYPE>  *pPre;
    NODE<TYPE>  *pLoc;
    //  Statements 
    found = _search (&pPre, &pLoc, dataIn.key);
    if (found)
    // Duplicate keys not allowed 
    return (+1);
    success = _insert (pPre,  dataIn);
    if (!success)
    // Overflow 
    return (-1);
    return (0);
    }	//  addNode 
    /*	===================== _insert ==================== 
    Inserts data into a new node in the linked list.
    Pre     Insertion location identified by pPre
    dataIn contains data to be inserted
    Post    data inserted in linked list or overflow
    Return  true  if successful, false if overflow
    */
    template <class TYPE, class KTYPE>
    bool List<TYPE, KTYPE> :: _insert (NODE<TYPE> *pPre,  
    TYPE        dataIn)
    {
    //	Local Definitions 
    NODE <TYPE>  *pNew;
    //	Statements 
    if (! (pNew = new NODE<TYPE>))
    return false;
    pNew->data = dataIn; 
    pNew->link = NULL; 
    if (pPre == NULL)
    {
    //  Adding before first node or to empty list. 
    pNew->link = head;
    head = pNew;
    } // if pPre 
    else
    {
    // Adding in middle or at end 
    pNew->link  = pPre->link;
    pPre->link  = pNew;
    } // if else  
    // Now check for add at end of list 
    if (pNew->link == NULL)
    // Adding to empty list. Set rear  
    rear = pNew;
    count++;
    return true;
    }	// _insert 
    /* 	================== removeNode ================== 
    Removes data from linked list. 
    Pre    dltkey is identifier of node to be deleted
    pDataOut is pointer to data variable to 
    receive a copy of the deleted data
    Post   data copied to output variable and node
    deleted or not found
    Return false if not found
    true  if deleted
    */
    template <class TYPE, class KTYPE>
    bool List<TYPE, KTYPE> ::  
    removeNode (KTYPE dltkey, TYPE *pDataOut)
    {
    //	Local Definitions 
    bool         found;
    NODE<TYPE>  *pPre;
    NODE<TYPE>  *pLoc;
    //	Statements 
    found = _search (&pPre, &pLoc, dltkey);
    if (found)
    _delete (pPre, pLoc, pDataOut);
    return found;
    } // removeNode
    /*	=================== _delete ================== 
    Deletes data from a linked list and returns 
    data to calling module.
    Pre  pPre is a pointer to predecessor node
    pLoc is a pointer to target node
    pDataOut is pointer to output data area
    Post Data have been deleted and returned 
    Data memory has been recycled
    */
    template <class TYPE, class KTYPE>
    void List<TYPE, KTYPE> :: _delete (NODE<TYPE>   *pPre,
    NODE<TYPE>   *pLoc, 
    TYPE         *pDataOut) 
    {
    //	Statements 
    *pDataOut = pLoc->data;
    if (pPre == NULL)
    // Deleting first node 
    head = pLoc->link;  
    else
    // Deleting any other node
    pPre->link = pLoc->link;
    // Test for deleting last node 
    if (pLoc->link == NULL)
    rear = pPre;
    count--;
    delete pLoc;
    return;
    }	//  _delete 
    /*	=================== retrieveNode ================== 
    Interface to search function. 
    Pre    key is the search argument
    dataOut is variable to receive data
    Post   dataOut contains located data if found
    if not found, contents are unchanged
    Return true if successful, false if not found
    */
    template <class TYPE, class KTYPE>
    bool List<TYPE, KTYPE> 
    :: retrieveNode (KTYPE  key, TYPE&  dataOut)
    {
    //	Local Definitions 
    bool          found;
    NODE <TYPE>  *pPre;
    NODE <TYPE>  *pLoc;
    //	Statements 
    found = _search (&pPre, &pLoc, key);
    if (found)
    dataOut = pLoc->data;
    return found;
    }	// retrieveNode 
    /*	==================== _search =================== 
    Searches list and passes back address of node 
    containing target and its logical predecessor.
    Pre    pPre is pointer variable for predecessor
    pLoc is pointer variable for found node
    key  is search argument
    Post   pLoc points to first node equal/greater key 
    -or- null if target > key of last node
    pPre points to largest node smaller than key
    -or- null if target < key of first node
    Return true if successful, false if not found
    */
    template <class TYPE, class KTYPE> 
    bool List<TYPE, KTYPE> :: _search (NODE<TYPE> **pPre,  
    NODE<TYPE> **pLoc,
    KTYPE        key)
    {
    //	Statements 
    *pPre  = NULL;
    *pLoc  = head;
    if (count == 0)
    return false;
    // Test for argument > last node in list 
    if (key > rear->data.key) 
    {
    *pPre = rear;
    *pLoc = NULL;
    return false;
    } // if 
    while (key > (*pLoc)->data.key)
    {
    //  Have not found search argument location 
    *pPre = *pLoc;
    *pLoc = (*pLoc)->link;
    } // while 
    if (key == (*pLoc)->data.key)
    //   argument found--success 
    return true;
    else
    return false;
    }	//  _search 
    /*	=============== emptyList ============== 
    Returns Boolean indicating whether the
    list is empty.
    Pre    Nothing 
    Return true if empty, false if list has data 
    */
    template<class TYPE, class KTYPE> 
    bool List<TYPE, KTYPE> :: emptyList (void) 
    {
    //	Statements 
    return (count == 0);
    }	//  emptyList 
    /*	=================== fullList ================== 
    Returns Boolean indicating whether the list is full
    or has room for more data. 
    Pre    Nothing 
    Return true if full, false if room for another node
    */
    template <class TYPE, class KTYPE>
    bool List<TYPE, KTYPE> :: fullList (void) 
    {
    //	Local Definitions  
    NODE<TYPE>  *temp;
    //	Statements 
    if (temp = new NODE<TYPE>)
    {
    delete temp;
    return false;
    } // if
    // Dynamic memory full 
    return true;
    }	// fullList 
    /*	==================== listCount ==================== 
    Returns integer representing number of nodes in list.
    Pre     Nothing
    Return  count for number of nodes in list
    */
    template <class TYPE, class KTYPE>
    int List<TYPE, KTYPE> :: listCount(void) 
    {
    //	Statements 
    return count;	
    }	// listCount
    /*	====================== getNext ===================== 
    getNext traverses a linked list. Each call either starts 
    at the beginning of the list or returns the location of  
    the element in the list that was last returned.
    Pre   fromWhere is 0 to start at the first element
    dataOut is reference to data variable 
    Post   if another element, address placed in output area
    Return true if another element located, 
    false if end of list
    */
    template <class TYPE, class KTYPE> 
    bool List<TYPE, KTYPE> :: getNext (int    fromWhere,
    TYPE&  dataOut)
    {
    //	Local Definitions 
    bool success;
    //	Statements 
    if (fromWhere == 0)
    {
    // Start from first node 
    if (count == 0)
    success = false;
    else
    {
    pos      = head;
    dataOut  = pos->data;
    success  = true;
    } // if else 
    } // if fromwhere is zero
    else
    {
    // Continue from current position 
    if (pos->link == NULL)
    success = false;
    else
    {
    pos      = pos->link;
    dataOut  = pos->data;
    success  = true;
    } // if else 
    } // if fromWhere else 
    return success;
    }	// getNext
    /*	=============== Destructor ============== 
    Deletes all data in list and recycles memory
    Pre    List is being deleted 
    Post   Data and class structure have been deleted
    */
    template<class TYPE, class KTYPE> 
    List<TYPE, KTYPE > :: ~List (void) 
    {
    //	Local Definitions 
    NODE<TYPE>   *deletePtr;
    //	Statements 
    if (head)
    {
    while (count > 0) 
    {
    deletePtr = head;
    head      = head->link; 
    count--;
    delete  deletePtr; 
    } // while
    } //  if 
    }	// Destructor 
    #include <iostream>
    #include "linkedList.h"
    using namespace std;
    struct grade {
    int key ;
    };
    int main() {
    List<grade,int> gradeList;
    grade x, y, z, dataOut;
    int i ;	
    // insert data to variables
    x.key = 50;
    y.key = 40;
    z.key = 30;
    //add three nodes 
    gradeList.addNode(x);
    gradeList.addNode(y);
    gradeList.addNode(z);
    // print three nodes
    i=0;
    cout << "Linked list after adding three nodes " << endl;
    while(gradeList.getNext(i++,dataOut))
    cout << dataOut.key ;
    //delete the node that has 40 key 
    gradeList.removeNode(40, &dataOut);
    // print two nodes
    i=0;
    cout << "Linked list after deleting one node " << endl;
    while(gradeList.getNext(i++,dataOut))
    cout << dataOut.key << endl;
    // print length of  linked list
    cout << "the length of linked list is = " << gradeList.listCount() << endl ;
    getchar();
    return 0;
    }

  2. #2
    خرريج لاتكلمني#
    الصورة الرمزية ناصر القحطاني

    تاريخ التسجيل : Oct 2010
    عدد الكتب في مكتبتي : 0
    الجنس : ذكر
    معدل تقييم المستوى : 7
    التقييم : 54

    بياناتى الأكاديمية

    نظام الدراسة

    :

    التخصص

    : نظم معلومات

    الكلية

    : كلية علوم الحاسب والمعلومات

    المستوى

    : السادس

    التفاعل

    مواضيعى

    : 12

    مشاركاتى

    : 12

    مقالات المدونة :


    هذا البرنامج مافهمت وضحي لي وان شاء الله اساعدك

    عرض التوقيع

معلومات الموضوع

الأعضاء الذين يشاهدون هذا الموضوع

الذين يشاهدون الموضوع الآن: 1 (0 من الأعضاء و 1 زائر)

مواقع النشر (المفضلة)

مواقع النشر (المفضلة)

ضوابط المشاركة

  • لا تستطيع إضافة مواضيع جديدة
  • لا تستطيع الرد على المواضيع
  • لا تستطيع إرفاق ملفات
  • لا تستطيع تعديل مشاركاتك
  •